modprog / attribute-derive

Side Project Stack

(so I maybe finish some of it)

• Sane Figglet unicode and toml based fogfont format
• 
• macro_rules like proc macro input parser
• Implement secret store for ENV tokens
• Email client
• bitfireAT/icsx5#235

attribute-derive's Issues

Introduce Utility Types to reduce syn full dependency

Add

• PseudoExpr Should collect a superset of valid expression syntax in a tokenstream.
• PseudoType Should collect a superset of valid type syntax in a tokenstream
• ...

Introduce Utility Types to reduce syn full dependency

Add

• PseudoExpr Should collect a superset of valid expression syntax in a tokenstream.
• PseudoType Should collect a superset of valid type syntax in a tokenstream
• ...

Accept attribute arguments TokenStream as input

So that users don't have to do this.

rewrite documentation

Does not work if trait is not importet

Support flattening attributes

Similar to #4, I'm adding a new attribute for ViewSchema and want to share the view() identifier name, so that all the parameters just live on the same level, but I can avoid repeating the shared attributes on both types. Using the same example from #4, what I would hope is for:

struct Attr {
   #[attribute(flatten)]
   shared: SharedAttributes
}

struct SharedAttributes {
    shared_key: String
}

Should parse

#[attr(shared_key = "hi")]

#[automatically_derived]

Sub Attributes

Sometimes complex attributes might require sub attributes like so:

struct Attr {
   #[attribute(sub_attribute)]
   key: SubAttr
}

struct SubAttr {
    sub_key: String
}

Should parse

#[attr(key(sub_key = "hi"))]

allow ommiting attribute ident

trait bound `syn::ExprClosure: attribute_derive::parsing::AttributeBase` is not satisfied

When upgrading refuse-macros from 0.8 to 0.9, my usage of syn::ExprClosure no longer compiles with this error:

error[E0277]: the trait bound `syn::ExprClosure: attribute_derive::parsing::AttributeBase` is not satisfied
   --> refuse-macros/src/lib.rs:202:10
    |
202 | #[derive(FromAttr)]
    |          ^^^^^^^^ the trait `attribute_derive::parsing::AttributeBase` is not implemented for `syn::ExprClosure`
    |
    = help: the following other types implement trait `attribute_derive::parsing::AttributeBase`:
              bool
              char
              isize
              i8
              i16
              i32
              i64
              i128
            and 173 others
    = note: required for `std::option::Option<syn::ExprClosure>` to implement `attribute_derive::parsing::AttributeBase`
    = note: this error originates in the derive macro `FromAttr` (in Nightly builds, run with -Z macro-backtrace for more info)

I'm not sure if this isn't meant to be supported, if there's a better syn type to be using, or if this is just an oversight.

Edit: Oops, didn't realize that I haven't pushed the macro changes yet. Here's what the usage looks like:

#[derive(FromAttr)]
#[attribute(ident = collectable)]
struct MapAsAttr {
    target: Option<syn::Type>,
    map: Option<syn::ExprClosure>,
}

Error when trying to use the crate

I took an example directly from the docs:

#[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>,
}

But I'm getting an error

error: expected `#[attribute(ident=attribute_name, aliases=[alias1, alias2], error="..", error(unknown_field="..", unknown_field_single="..", unknown_field_empty="..", duplicate_field="..", missing_field="..", field_help="..", missing_flag"..", flag_help".."))]`
 --> node_macro/src/lib.rs:6:10
  |
6 | #[derive(Attribute)]
  |          ^^^^^^^^^
  |
  = note: this error originates in the derive macro `Attribute` (in Nightly builds, run with -Z macro-backtrace for more info)

My Cargo.toml:

[package]
name = "node_macro"
version = "0.1.0"
edition = "2021"

[lib]
proc-macro = true

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
syn = { version = "2.0" }
quote = "1.0"
proc-macro2 = "1.0"
attribute-derive = "0.6"

consider replacing manual implementation of all syn types implementing `Parse` to AsRef specialization

Emit all validation errors not only first

https://docs.rs/syn/latest/syn/struct.Error.html#method.combine

spanned type, that keeps reference to span

allow fields to represent top level attributes

i.e.:

#[derive(FromAttr)]
#[attribute(flatten)]
struct FieldAttribute {
    default: FlagOrValue<Expr>,
    children: bool,
}

would parse

#[default]
#[default = <expr>]
// This is supported additionally, because
// `=` only supports a subset of expressions
#[default(<expr>)]

#[children]

We could support this maybe as a fieldlevel attribute as well, or allow the field value to be anything that implements FromAttr to allow hybrid structs with nested and unnested attributes.

Quoted/Parenthesized values

Support the "standard" way of using "meta" attributes:

#[derive(Attribute)]
struct Args {
    #[attribute(quoted)]
    key: Expression,
    #[attribute(parenthesized)]
    other: Path
}

should parse something like

#[attr(key="a + b", other(::a::b::C))]

Don't pollute global scope with helper structs.