Crate attribute_derive
source · [−]Expand description
Basicly clap for attribute macros:
#[derive(Attribute)]
#[attribute(ident = "collection")]
#[attribute(invalid_field = "Error when an unsupported value is set (e.g. meaning=42")]
struct CollectionAttribute {
// Options are optional by default (will be set to None if not specified)
authority: Option<String>,
#[attribute(missing = "Error when the value is not set")]
name: String,
// Any type implementing default can be flagged as default
// This will be set to Vec::default() when not specified
#[attribute(default)]
#[attribute(expected = "Error when an error occured while parsing")]
views: Vec<Type>,
// Booleans can be used without assiging a value. as a flag.
// If omitted they are set to false
some_flag
}
Will be able to parse an attribute like this:
#[collection(authority="Some String", name = r#"Another string"#, views = [Option, ()])]
Any type that ConvertParsed
is implemented for is supported. These should be the general
types that syn supports like LitStr
or Type
or that have a direct equivalent in those
like String
, char
or f32
. A special treatment have Vecs
which are parsed
using Array
with the syntax [a, b, c]
and Options
that will be None
if
not specified and Some
when the value is specified via the attribute. It is not
specified via Some(value)
but as just value
.
Limitations
There are some limitations in syntax parsing that will be lifted future releases.
- literals in top level (meaning something like
#[attr(42, 3.14, "hi")]
- function like arguments (something like
#[attr(view(a = "test"))]
- other syntaxes, maybe something like
key: value
Parse methods
There are multiple ways of parsing a struct deriving Attribute
.
For helper attributes there is:
Attribute::from_attributes
which takes in anIntoIterator<Item = &'a syn::Attribute
(e.g. a&Vec<syn::Attribute>
). Most useful for derive macros.Attribute::remove_attributes
which takes an&mut Vec<syn::Attribute>
and does not only parse theAttribute
but also removes those matching. Useful for helper attributes for proc macros, where the helper attributes need to be removed.
For parsing a single TokenStream
e.g. for parsing the proc macro input there a two ways:
Attribute::from_args
taking in aTokenStream
- As
derive(Attribute)
also derivesParse
so you can use the parse API, e.g. withparse_macro_input!(tokens as Attribute)
.
Structs
Helper struct to parse array literals:
[a, b, c]
Traits
The trait you actually derive on your attribute struct.
Helper trait to generate sensible errors