Simplify processing of structured MetaItems

[dtolnay]

Diesel uses the following to parse attributes of the form #[changeset_options(treat_none_as_null = "true")]:

match options_attr.value {
    syn::MetaItem::List(_, ref values) => {
        if values.len() != 1 {
            usage_err();
        }
        match values[0] {
            syn::MetaItem::NameValue(ref name, ref value)
                if name.as_ref() == "treat_none_as_null" => value == "true",
            _ => usage_err(),
        }
    }
    _ => usage_err(),
}

I expect this use case to be pretty common so let's provide helpers to make it less bad.

[dtolnay]

Something like this in this case:

if let attr_pat!{ #[_(treat_none_as_null = "true")] } = options_attr {
    true
} else {
    usage_err()
}

or:

if let attr_pat!{ #[_(treat_none_as_null = ref value)] } = options_attr {
    value == "true"
} else {
    usage_err()
}

[killercup]

Interesting idea to use a macro for this. The macro as you described it above looks for this explicit pattern, right? How'd you handle the default case, i.e., the option we are looking for is not set (but maybe others are)?

I'd've suggested introducing a special attr type for attrs that are like #[$name($($key = $val),+)] (in contrast to e.g. #[$name = $val]).

let changeset_options: OptionsAttr =
    macro_input
    .attr("changeset_options")
    .parse_as_options_attr()
    .unwrap_or_else(usage_error);
let treat_none_as_null =
    changeset_options
    .boolean_field("treat_none_as_null")
    .unwrap_or(false);

[sgrif]

One easy win would be to drop Attribute entirely. I don't think the is_sugared_doc field does much for us.

[dtolnay]

Here is a neat idea from @killercup in colin-kiegel/rust-derive-builder#32 - use Serde!

I feel like there should be an idiomatic solution to parsing syn attributes to structs. Maybe another derive crate? A small serde plugin for (de)serializing things to/from rust attributes? The possibilities are infinite! :D

#[derive(Deserialize)] struct Options { setters: SetterOptions, /* … */ }
#[derive(Deserialize)] struct GetterOptions { pattern: SetterPattern, public: bool, private: bool }
#[derive(Deserialize)] enum SetterPattern { Owned, Mutable, Immutable }

// …
let attr: syn::Attribute = attr;
let opt: Options = parse_attribute!(builder_options);

[Nemo157]

I wrote a little procedural macro crate for parsing attributes prom-attire. Still needs documentation written, but the initial diesel example (#[changeset_options(treat_none_as_null = "true")]) would be:

#[derive(PromAttire)]
#[attire(scope = "changeset_options")]
ChangesetOptions {
    treat_none_as_null: bool
}

let options = ChangesetOptions::from(macro_input.attrs.as_slice());

[dtolnay]

Amazing. I'm happy to recommend prom-attire as the solution to this. Thanks @Nemo157!