serde_json multi-typed literal parsing

[nyurik]

I am implementing #[attr(default = <literal>)], and my value can be multi-typed depending on what it gets attached to. The serde_json::Value is the format I will eventually have to work with. Darling seem to have the needed from_value() functions, but I am not too certain how to use it to convert from a syn::Lit into serde_json::Value, possibly via some magical match statement? Thx!

[TedDriggs]

I'm afraid there's no magical match statement - you'll need to write your own that looks at each Lit variant, gets its value, then uses the .into() conversion for it. How complex that will be depends on how many kinds of JSON value you want to allow, and whether you're going to require it be a literal or would accept any expression that produces impl Into<serde_json::Value>.

Your simplest approach might be this:

#[derive(FromMeta)]
struct Receiver {
    #[darling(with = preserve_str_literal)]
    default: syn::Expr,
}

Then in the code you generate from this, you'd use default by writing...

let default_expr = self.default;
quote_spanned!(default_expr.span()=>serde_json::Value::from(#default_expr));

This allows any input that evaluates to something which can be converted to a JSON value.

[nyurik]

@TedDriggs thank you so much for your help! Everything works great, except that it now a required field. Is it possible to have optional expressions, to parse things like #[arg(special)] (no default param)?

#[derive(FromMeta)]
struct Receiver {
    #[darling(with = preserve_str_literal)]
    default: Option<syn::Expr>,
    special: Option<bool>,
}

[nyurik]

Alternatively, perhaps it might make sense to simplify the API, and use dedicated virtual attributes:

// `param` has two attributes, one "bool" and one with an aribtrary value
fn foo(  #[default("value")]  #[special]  param: String  )

Is this type of parsing possible?

[TedDriggs]

darling is designed for serde-style attributes, where there is an outer namespace and then modifiers are placed within that. As a result, checking for something like #[special] isn't well-supported; you have to do a bunch of work by hand to identify that.

[TedDriggs]

Is it possible to have optional expressions, to parse things like #[arg(special)] (no default param)?

That should just work already: If default isn't set by the caller of your macro, that field will fall back to calling <Option<syn::Expr> as FromMeta>::from_none, which will return Some(None), so the caller won't get an error in this case.