Function Attributes

crates/backend/src/ast.rs

@@ -392,6 +392,32 @@ pub struct Function {
     pub generate_jsdoc: bool,
     /// Whether this is a function with a variadict parameter
     pub variadic: bool,
+    /// Function attributes used to provide extra information about function's components
+    pub fn_attrs: Option<FunctionAttributes>,
+}
+
+/// Extra information about a function's components
+#[cfg_attr(feature = "extra-traits", derive(Debug))]
+#[derive(Clone, Default)]
+pub struct FunctionAttributes {
+    /// Function's return attributes
+    pub ret: FunctionComponentAttributes,
+    /// Function's arguments attributes
+    pub args: Vec<FunctionComponentAttributes>,
+}
+
+/// Information about a function's component
+#[cfg_attr(feature = "extra-traits", derive(Debug))]
+#[derive(Clone, Default)]
+pub struct FunctionComponentAttributes {
+    /// Specifies the type for a function component
+    pub ty: Option<String>,
+    /// Description of the function component
+    pub desc: Option<String>,
+    /// Specifies a name of the function argument
+    pub name: Option<String>,
+    /// Specifies if the component is optional (used for function arguments)
+    pub optional: bool,
 }
 
 /// Information about a Struct being exported

crates/backend/src/encode.rs

@@ -220,19 +220,44 @@ fn shared_function<'a>(func: &'a ast::Function, _intern: &'a Interner) -> Functi
         .iter()
         .enumerate()
         .map(|(idx, arg)| {
+            // use argument's "js_name" if it was provided in attributes
+            if let Some(arg_js_name) = func
+                .fn_attrs
+                .as_ref()
+                .and_then(|attrs| attrs.args.get(idx).and_then(|v| v.name.clone()))
+            {
+                return arg_js_name;
+            }
             if let syn::Pat::Ident(x) = &*arg.pat {
                 return x.ident.unraw().to_string();
             }
             format!("arg{}", idx)
         })
         .collect::<Vec<_>>();
+    let fn_attrs = func.fn_attrs.as_ref().map(|attrs| FunctionAttributes {
+        ret: FunctionComponentAttributes {
+            ty: attrs.ret.ty.clone(),
+            desc: attrs.ret.desc.clone(),
+            optional: false,
+        },
+        args: attrs
+            .args
+            .iter()
+            .map(|arg_attr| FunctionComponentAttributes {
+                ty: arg_attr.ty.clone(),
+                desc: arg_attr.desc.clone(),
+                optional: arg_attr.optional,
+            })
+            .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: {:?}, optional: {} }}",
+            self.ty, self.desc, self.optional
+        ))
+    }
+}
+
 macro_rules! decode_struct {
     ($name:ident ($($lt:tt)*) $($field:ident: $ty:ty,)*) => {
         pub struct $name <$($lt)*> {