feat(macro): export generic structs via instantiate()

Adds a `#[wasm_bindgen(instantiate(...))]` attribute that monomorphizes a
generic struct into one concrete JS class per listed instantiation, written as
`Type<Args> as JsName`:

    #[wasm_bindgen(instantiate(Pair<f64> as PairF64, Pair<u32> as PairU32))]
    pub struct Pair<T> { pub first: T, pub second: T }

Each instantiation is emitted as an independent `ast::Struct` with the type
parameter substituted throughout its fields, producing a distinct exported
class with its own ABI conversions and public-field accessors. Because the
struct macro is a single expansion that emits both the class and its field
accessors, the monomorphized field types cannot diverge from the class they
belong to.

Scope is deliberately limited to the struct surface: instances cross the
boundary via free functions, and public fields are read/written directly from
JS. Exporting impl methods/constructors on an instantiation, and propagating
TS-level type parameters, are follow-up work.

Validation rejects non-type (lifetime/const) parameters, arity mismatches,
duplicate or JS-keyword class names, `js_name` combined with `instantiate`,
and instantiations that don't name the struct.

Tests:
- crates/macro/ui-tests/instantiate-struct: compile-fail coverage of every
  validation path (messages are wasm-bindgen diagnostics, toolchain-stable).
- tests/wasm/instantiate: runtime round-trips over two instantiations,
  field read/write from JS, and class-distinctness (`instanceof`) checks.

Also documents the attribute under the guide's on-rust-exports reference and
updates the invalid-generics/invalid-items stderr expectations.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: rossng

crates/macro-support/src/ast.rs

@@ -507,6 +507,10 @@ pub struct FunctionArgumentData {
 pub struct Struct {
     /// The name of the struct in Rust code
     pub rust_name: Ident,
+    /// The concrete generic arguments of a monomorphized instantiation of a
+    /// generic struct, in turbofish form (e.g. `::<f64>` so the full type is
+    /// `Tr::<f64>`). `None` for ordinary non-generic structs.
+    pub rust_generics: Option<syn::AngleBracketedGenericArguments>,
     /// The export name of the struct in JS code
     pub js_name: String,
     /// The namespace-qualified internal name used for wasm symbol generation.
@@ -555,6 +559,9 @@ pub struct StructField {
     pub js_name: String,
     /// The name of the struct this field is part of
     pub struct_name: Ident,
+    /// The concrete generic arguments of the monomorphized struct this field
+    /// is part of, in turbofish form. Mirrors [`Struct::rust_generics`].
+    pub struct_generics: Option<syn::AngleBracketedGenericArguments>,
     /// Whether this value is read-only to JS
     pub readonly: bool,
     /// The type of this field

crates/macro-support/src/codegen.rs

@@ -218,7 +218,11 @@ impl TryToTokens for ast::LinkToModule {
 
 impl ToTokens for ast::Struct {
     fn to_tokens(&self, tokens: &mut TokenStream) {
-        let name = &self.rust_name;
+        let rust_ident = &self.rust_name;
+        let rust_generics = &self.rust_generics;
+        // The full (possibly monomorphized) type, e.g. `Foo` or `Tr::<f64>`.
+        // Turbofish syntax is valid in both type and expression position.
+        let name = quote! { #rust_ident #rust_generics };
         let name_str = self.qualified_name.to_string();
         let name_len = name_str.len() as u32;
         let name_chars: Vec<u32> = name_str.chars().map(|c| c as u32).collect();
@@ -548,7 +552,9 @@ impl ToTokens for ast::StructField {
         }
 
         let rust_name = &self.rust_name;
-        let struct_name = &self.struct_name;
+        let struct_ident = &self.struct_name;
+        let struct_generics = &self.struct_generics;
+        let struct_name = quote! { #struct_ident #struct_generics };
         let ty = &self.ty;
         let getter = &self.getter;
         let setter = &self.setter;

crates/macro-support/src/lib.rs

@@ -228,7 +228,8 @@ pub fn expand_struct_marker(item: TokenStream) -> Result<TokenStream, Diagnostic
     let mut s: syn::ItemStruct = syn::parse2(item)?;
 
     let mut program = ast::Program::default();
-    program.structs.push((&mut s).convert(&program)?);
+    let structs = (&mut s).convert(&program)?;
+    program.structs.extend(structs);
 
     let mut tokens = proc_macro2::TokenStream::new();
     program.try_to_tokens(&mut tokens)?;