Rust: Support path-specific `additional_derives`

[tomasol]

Currently additional_derives can only be set globally, which feels too broad.
For use cases like adding serde annotations it would be better if the derives could be scoped per type or interface. Would it make sense to extend the generate! macro to accept a map of path -> derives?

[dman-os]

Not just derives but heavily in need of type targeted attrs. Use-cases like serde customization are critical in many cases. Also, would be great if it was hierarchical so that it can target whole packages/modules/types with ease.

For the basic need of segregating derives, I'm currently using multiple generate! sections:

mod wit {
   pub mod serde {
        wit_bindgen::generate!({
            //  #1395 unfortunately, the linker doesn't like `generate!` on the same world twice
            world: "serde-world",
            generate_all,
            additional_derives: [serde::Serialize, serde::Deserialize],
        });
    }
    wit_bindgen::generate!({
        world: "true-world",
        with: {
            "path:to/world": crate::wit::serde::path::to::world,
            // wasi io doesn't like serde
            "wasi:io/poll@0.2.6": generate,
            "wasi:logging/logging@0.1.0-draft": wasi::wit,
        }
    });
}

With how popular proc-macros are in the rust ecosystem, I suspect I'll always wanting more customization in generate!. Though maybe there's some elegant solution lying in wait.

Right now, the solution I've settled on is to write a simple code generator that spits out wit types, corresponding rust types with customization and their binding generate! from a single source of truth.

[wilfreddenton]

#1656 does this. additional_type_attributes / additional_member_attributes take per-selector attributes keyed by the same names with uses (bare, package, interface, or fully-qualified), so you can scope a derive to a package, an interface, or a single type instead of the whole world. Curious whether the selector grammar covers what you had in mind.

[dman-os]

@wilfreddenton that looks very good, thanks.

This is not a response to your PR but the general generate! macro itself but, I wonder if a more Rust like approach would be more appropriate. Macro guidelines suggest using a rusty syntax in macros where possible. Think something like

generate! {
    world: "xxx",
    {
         #[from = "path:to:world", generate_all]
         mod path::to::world {
              #[from = "record-name"]
              #[derive(Serde,Serialize)
               struct RecordName {
                   #[attrib_specifying_lift_lowering]
                   myString: CustomStringType,
                   #[field_attrib]
                   ..default_fields()
               } 
         }
     }
}

This is a rough 2min sketch and I'll say that the current syntax is probably more portable across different wit-bindgen languages

[tomasol]

@wilfreddenton Thanks, #1656 actually covers all my hacks!