fix: Fix cfg_attr in struct declaration

Author: fl0rek

crates/macro-support/src/lib.rs

@@ -12,7 +12,7 @@ extern crate wasm_bindgen_backend as backend;
 extern crate wasm_bindgen_shared as shared;
 
 pub use crate::parser::BindgenAttrs;
-use crate::parser::MacroParse;
+use crate::parser::{ConvertToAst, MacroParse};
 use backend::{Diagnostic, TryToTokens};
 use proc_macro2::TokenStream;
 use quote::ToTokens;
@@ -24,7 +24,41 @@ mod parser;
 /// Takes the parsed input from a `#[wasm_bindgen]` macro and returns the generated bindings
 pub fn expand(attr: TokenStream, input: TokenStream) -> Result<TokenStream, Diagnostic> {
     parser::reset_attrs_used();
+    // if struct is encountered, add `derive` attribute and let everything happen there (workaround
+    // to help parsing cfg_attr correctly).
     let item = syn::parse2::<syn::Item>(input)?;
+    if let syn::Item::Struct(mut s) = item {
+        s.attrs.insert(
+            0,
+            syn::Attribute {
+                pound_token: Default::default(),
+                style: syn::AttrStyle::Outer,
+                bracket_token: Default::default(),
+                meta: syn::parse_quote! {
+                    derive(wasm_bindgen::prelude::BindgenedStruct)
+                },
+            },
+        );
+        if !attr.is_empty() {
+            let meta: syn::Meta = syn::parse2(attr)?;
+            s.attrs.insert(
+                1,
+                syn::Attribute {
+                    pound_token: Default::default(),
+                    style: syn::AttrStyle::Outer,
+                    bracket_token: Default::default(),
+                    meta: syn::parse_quote! {
+                        wasm_bindgen(#meta)
+                    },
+                },
+            );
+        }
+
+        let mut tokens = proc_macro2::TokenStream::new();
+        s.to_tokens(&mut tokens);
+        return Ok(tokens);
+    }
+
     let opts = syn::parse2(attr)?;
 
     let mut tokens = proc_macro2::TokenStream::new();
@@ -168,3 +202,19 @@ impl Parse for ClassMarker {
         })
     }
 }
+
+pub fn expand_struct_marker(item: TokenStream) -> Result<TokenStream, Diagnostic> {
+    parser::reset_attrs_used();
+
+    let mut s: syn::ItemStruct = syn::parse2(item)?;
+
+    let mut program = backend::ast::Program::default();
+    program.structs.push((&mut s).convert(&program)?);
+
+    let mut tokens = proc_macro2::TokenStream::new();
+    program.try_to_tokens(&mut tokens)?;
+
+    parser::check_unused_attrs(&mut tokens);
+
+    Ok(tokens)
+}

crates/macro-support/src/parser.rs

@@ -413,7 +413,7 @@ impl Parse for AnyIdent {
 ///
 /// Used to convert syn tokens into an AST, that we can then use to generate glue code. The context
 /// (`Ctx`) is used to pass in the attributes from the `#[wasm_bindgen]`, if needed.
-trait ConvertToAst<Ctx> {
+pub(crate) trait ConvertToAst<Ctx> {
     /// What we are converting to.
     type Target;
     /// Convert into our target.
@@ -422,27 +422,27 @@ trait ConvertToAst<Ctx> {
     fn convert(self, context: Ctx) -> Result<Self::Target, Diagnostic>;
 }
 
-impl ConvertToAst<(&ast::Program, BindgenAttrs)> for &mut syn::ItemStruct {
+impl ConvertToAst<&ast::Program> for &mut syn::ItemStruct {
     type Target = ast::Struct;
 
-    fn convert(
-        self,
-        (program, attrs): (&ast::Program, BindgenAttrs),
-    ) -> Result<Self::Target, Diagnostic> {
+    fn convert(self, program: &ast::Program) -> Result<Self::Target, Diagnostic> {
         if !self.generics.params.is_empty() {
             bail_span!(
                 self.generics,
                 "structs with #[wasm_bindgen] cannot have lifetime or \
                  type parameters currently"
             );
         }
+        let struct_attrs = BindgenAttrs::find(&mut self.attrs)?;
+
         let mut fields = Vec::new();
-        let js_name = attrs
+        let js_name = struct_attrs
             .js_name()
             .map(|s| s.0.to_string())
             .unwrap_or(self.ident.unraw().to_string());
-        let is_inspectable = attrs.inspectable().is_some();
-        let getter_with_clone = attrs.getter_with_clone();
+        let is_inspectable = struct_attrs.inspectable().is_some();
+        let getter_with_clone = struct_attrs.getter_with_clone();
+
         for (i, field) in self.fields.iter_mut().enumerate() {
             match field.vis {
                 syn::Visibility::Public(..) => {}
@@ -484,9 +484,9 @@ impl ConvertToAst<(&ast::Program, BindgenAttrs)> for &mut syn::ItemStruct {
             });
             attrs.check_used();
         }
-        let generate_typescript = attrs.skip_typescript().is_none();
+        let generate_typescript = struct_attrs.skip_typescript().is_none();
         let comments: Vec<String> = extract_doc_comments(&self.attrs);
-        attrs.check_used();
+        struct_attrs.check_used();
         Ok(ast::Struct {
             rust_name: self.ident.clone(),
             js_name,
@@ -1159,11 +1159,6 @@ impl<'a> MacroParse<(Option<BindgenAttrs>, &'a mut TokenStream)> for syn::Item {
                     wasm_bindgen_futures: program.wasm_bindgen_futures.clone(),
                 });
             }
-            syn::Item::Struct(mut s) => {
-                let opts = opts.unwrap_or_default();
-                program.structs.push((&mut s).convert((program, opts))?);
-                s.to_tokens(tokens);
-            }
             syn::Item::Impl(mut i) => {
                 let opts = opts.unwrap_or_default();
                 (&mut i).macro_parse(program, opts)?;

crates/macro/src/lib.rs

@@ -71,3 +71,16 @@ pub fn __wasm_bindgen_class_marker(attr: TokenStream, input: TokenStream) -> Tok
         Err(diagnostic) => (quote! { #diagnostic }).into(),
     }
 }
+
+#[proc_macro_derive(BindgenedStruct, attributes(wasm_bindgen))]
+pub fn __wasm_bindgen_struct_marker(item: TokenStream) -> TokenStream {
+    match wasm_bindgen_macro_support::expand_struct_marker(item.into()) {
+        Ok(tokens) => {
+            if cfg!(feature = "xxx_debug_only_print_generated_code") {
+                println!("{}", tokens);
+            }
+            tokens.into()
+        }
+        Err(diagnostic) => (quote! { #diagnostic }).into(),
+    }
+}

src/lib.rs

@@ -63,6 +63,7 @@ pub mod prelude {
     pub use crate::JsCast;
     pub use crate::JsValue;
     pub use crate::UnwrapThrowExt;
+    pub use wasm_bindgen_macro::BindgenedStruct;
     #[doc(hidden)]
     pub use wasm_bindgen_macro::__wasm_bindgen_class_marker;
     pub use wasm_bindgen_macro::wasm_bindgen;

tests/wasm/classes.rs

@@ -480,6 +480,16 @@ fn renamed_field() {
     js_renamed_field();
 }
 
+#[cfg_attr(target_arch = "wasm32", wasm_bindgen)]
+pub struct ConditionalSkip {
+    #[cfg_attr(target_arch = "wasm32", wasm_bindgen(skip))]
+    pub skipped_field: [u8; 8],
+
+    /// cfg_attr annotated field
+    #[cfg_attr(target_arch = "wasm32", wasm_bindgen(getter_with_clone))]
+    pub needs_clone: String,
+}
+
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen)]
 pub struct ConditionalBindings {}