Function Attributes

crates/backend/src/ast.rs

@@ -375,9 +375,9 @@ pub struct Function {
     /// Whether the function has a js_name attribute
     pub renamed_via_js_name: bool,
     /// The arguments to the function
-    pub arguments: Vec<syn::PatType>,
-    /// The return type of the function, if provided
-    pub ret: Option<syn::Type>,
+    pub arguments: Vec<FunctionArgumentData>,
+    /// The data of return type of the function
+    pub ret: FunctionReturnData,
     /// Any custom attributes being applied to the function
     pub rust_attrs: Vec<syn::Attribute>,
     /// The visibility of this function in Rust
@@ -394,6 +394,32 @@ pub struct Function {
     pub variadic: bool,
 }
 
+/// Information about a function's return
+#[cfg_attr(feature = "extra-traits", derive(Debug))]
+#[derive(Clone)]
+pub struct FunctionReturnData {
+    /// Specifies the type of the function's return
+    pub r#type: Option<syn::Type>,
+    /// Specifies the return type override provided by attributes
+    pub ty_override: Option<String>,
+    /// Specifies the return description
+    pub desc: Option<String>,
+}
+
+/// Information about a function's argument
+#[cfg_attr(feature = "extra-traits", derive(Debug))]
+#[derive(Clone)]
+pub struct FunctionArgumentData {
+    /// Specifies the argument name
+    pub js_name: Option<String>,
+    /// Specifies the type of the function's argument
+    pub pat_type: syn::PatType,
+    /// Specifies the argument type override provided by attributes
+    pub ty_override: Option<String>,
+    /// Specifies the argument description
+    pub desc: Option<String>,
+}
+
 /// Information about a Struct being exported
 #[cfg_attr(feature = "extra-traits", derive(Debug))]
 #[derive(Clone)]

crates/backend/src/codegen.rs

@@ -637,7 +637,7 @@ impl TryToTokens for ast::Export {
 
         let mut argtys = Vec::new();
         for (i, arg) in self.function.arguments.iter().enumerate() {
-            argtys.push(&*arg.ty);
+            argtys.push(&*arg.pat_type.ty);
             let i = i + offset;
             let ident = Ident::new(&format!("arg{}", i), Span::call_site());
             fn unwrap_nested_types(ty: &syn::Type) -> &syn::Type {
@@ -647,7 +647,7 @@ impl TryToTokens for ast::Export {
                     _ => ty,
                 }
             }
-            let ty = unwrap_nested_types(&arg.ty);
+            let ty = unwrap_nested_types(&arg.pat_type.ty);
 
             match &ty {
                 syn::Type::Reference(syn::TypeReference {
@@ -720,7 +720,7 @@ impl TryToTokens for ast::Export {
             elems: Default::default(),
             paren_token: Default::default(),
         });
-        let syn_ret = self.function.ret.as_ref().unwrap_or(&syn_unit);
+        let syn_ret = self.function.ret.r#type.as_ref().unwrap_or(&syn_unit);
         if let syn::Type::Reference(_) = syn_ret {
             bail_span!(syn_ret, "cannot return a borrowed ref with #[wasm_bindgen]",)
         }
@@ -1323,7 +1323,7 @@ impl TryToTokens for ast::ImportFunction {
             ast::ImportFunctionKind::Normal => {}
         }
         let vis = &self.function.rust_vis;
-        let ret = match &self.function.ret {
+        let ret = match &self.function.ret.r#type {
             Some(ty) => quote! { -> #ty },
             None => quote!(),
         };
@@ -1337,8 +1337,8 @@ impl TryToTokens for ast::ImportFunction {
         let wasm_bindgen_futures = &self.wasm_bindgen_futures;
 
         for (i, arg) in self.function.arguments.iter().enumerate() {
-            let ty = &arg.ty;
-            let name = match &*arg.pat {
+            let ty = &arg.pat_type.ty;
+            let name = match &*arg.pat_type.pat {
                 syn::Pat::Ident(syn::PatIdent {
                     by_ref: None,
                     ident,
@@ -1347,7 +1347,7 @@ impl TryToTokens for ast::ImportFunction {
                 }) => ident.clone(),
                 syn::Pat::Wild(_) => syn::Ident::new(&format!("__genarg_{}", i), Span::call_site()),
                 _ => bail_span!(
-                    arg.pat,
+                    arg.pat_type.pat,
                     "unsupported pattern in #[wasm_bindgen] imported function",
                 ),
             };
@@ -1542,7 +1542,7 @@ impl ToTokens for DescribeImport<'_> {
             ast::ImportKind::Type(_) => return,
             ast::ImportKind::Enum(_) => return,
         };
-        let argtys = f.function.arguments.iter().map(|arg| &arg.ty);
+        let argtys = f.function.arguments.iter().map(|arg| &arg.pat_type.ty);
         let nargs = f.function.arguments.len() as u32;
         let inform_ret = match &f.js_ret {
             Some(ref t) => quote! { <#t as WasmDescribe>::describe(); },

crates/backend/src/encode.rs

@@ -220,19 +220,38 @@ fn shared_function<'a>(func: &'a ast::Function, _intern: &'a Interner) -> Functi
         .iter()
         .enumerate()
         .map(|(idx, arg)| {
-            if let syn::Pat::Ident(x) = &*arg.pat {
+            // use argument's "js_name" if it was provided in attributes
+            if let Some(name) = &arg.js_name {
+                return name.clone();
+            }
+            if let syn::Pat::Ident(x) = &*arg.pat_type.pat {
                 return x.ident.unraw().to_string();
             }
             format!("arg{}", idx)
         })
         .collect::<Vec<_>>();
+    let fn_attrs = Some(FunctionAttributes {
+        ret: FunctionComponentAttributes {
+            ty: func.ret.ty_override.clone(),
+            desc: func.ret.desc.clone(),
+        },
+        args: func
+            .arguments
+            .iter()
+            .map(|arg_attr| FunctionComponentAttributes {
+                ty: arg_attr.ty_override.clone(),
+                desc: arg_attr.desc.clone(),
+            })
+            .collect::<Vec<_>>(),
+    });
     Function {
         arg_names,
         asyncness: func.r#async,
         name: &func.name,
         generate_typescript: func.generate_typescript,
         generate_jsdoc: func.generate_jsdoc,
         variadic: func.variadic,
+        fn_attrs,
     }
 }
 

crates/cli-support/src/decode.rs

@@ -1,4 +1,4 @@
-use std::{ops::Deref, str};
+use std::{fmt::Debug, ops::Deref, str};
 
 pub trait Decode<'src>: Sized {
     fn decode(data: &mut &'src [u8]) -> Self;
@@ -94,6 +94,24 @@ impl<'src, T: Decode<'src>> Decode<'src> for Option<T> {
     }
 }
 
+impl Debug for FunctionAttributes {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_fmt(format_args!(
+            "FunctionAttributes {{ ret: {:?}, args: {:?} }}",
+            self.ret, self.args
+        ))
+    }
+}
+
+impl Debug for FunctionComponentAttributes {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_fmt(format_args!(
+            "FunctionComponentAttributes {{ ty: {:?}, desc: {:?} }}",
+            self.ty, self.desc
+        ))
+    }
+}
+
 macro_rules! decode_struct {
     ($name:ident ($($lt:tt)*) $($field:ident: $ty:ty,)*) => {
         pub struct $name <$($lt)*> {