feat momo: Support parsing pattern in params

So that we can slap it on more functions.

Signed-off-by: Jiahao XU <[email protected]>

Author: NobodyXu

gix-macros/src/lib.rs

@@ -13,7 +13,7 @@ enum Conversion<'a> {
 }
 
 impl<'a> Conversion<'a> {
-    fn conversion_expr(&self, i: Ident) -> Expr {
+    fn conversion_expr(&self, i: &Ident) -> Expr {
         match *self {
             Conversion::Into(_) => parse_quote!(#i.into()),
             Conversion::AsRef(_) => parse_quote!(#i.as_ref()),
@@ -23,12 +23,10 @@ impl<'a> Conversion<'a> {
 }
 
 fn parse_bounded_type(ty: &Type) -> Option<Ident> {
-    if let Type::Path(TypePath { qself: None, ref path }) = ty {
-        if path.segments.len() == 1 {
-            return Some(path.segments[0].ident.clone());
-        }
+    match &ty {
+        Type::Path(TypePath { qself: None, path }) if path.segments.len() == 1 => Some(path.segments[0].ident.clone()),
+        _ => None,
     }
-    None
 }
 
 fn parse_bounds(bounds: &Punctuated<TypeParamBound, Token![+]>) -> Option<Conversion> {
@@ -60,7 +58,6 @@ fn parse_generics(decl: &Signature) -> HashMap<Ident, Conversion<'_>> {
         if let GenericParam::Type(ref tp) = gp {
             if let Some(conversion) = parse_bounds(&tp.bounds) {
                 ty_conversions.insert(tp.ident.clone(), conversion);
-                continue;
             }
         }
     }
@@ -70,7 +67,6 @@ fn parse_generics(decl: &Signature) -> HashMap<Ident, Conversion<'_>> {
                 if let Some(ident) = parse_bounded_type(&pt.bounded_ty) {
                     if let Some(conversion) = parse_bounds(&pt.bounds) {
                         ty_conversions.insert(ident, conversion);
-                        continue;
                     }
                 }
             }
@@ -79,51 +75,76 @@ fn parse_generics(decl: &Signature) -> HashMap<Ident, Conversion<'_>> {
     ty_conversions
 }
 
-fn pat_to_ident(pat: &Pat) -> Ident {
-    if let Pat::Ident(ref pat_ident) = *pat {
-        return pat_ident.ident.clone();
-    }
-    unimplemented!("No non-ident patterns for now!");
-}
-
-fn pat_to_expr(pat: &Pat) -> Expr {
-    let ident = pat_to_ident(pat);
-    parse_quote!(#ident)
-}
-
 fn convert<'a>(
     inputs: &'a Punctuated<FnArg, Token![,]>,
     ty_conversions: &HashMap<Ident, Conversion<'a>>,
-) -> (Punctuated<Expr, Token![,]>, bool) {
+) -> (Punctuated<FnArg, Token![,]>, Punctuated<Expr, Token![,]>, bool) {
+    let mut argtypes = Punctuated::new();
     let mut argexprs = Punctuated::new();
     let mut has_self = false;
-    inputs.iter().for_each(|input| match input {
-        FnArg::Receiver(..) => {
+    inputs.iter().enumerate().for_each(|(i, input)| match input.clone() {
+        FnArg::Receiver(receiver) => {
             has_self = true;
+            argtypes.push(FnArg::Receiver(receiver));
         }
-        FnArg::Typed(PatType { ref pat, ref ty, .. }) => match **ty {
-            Type::ImplTrait(TypeImplTrait { ref bounds, .. }) => {
-                if let Some(conv) = parse_bounds(bounds) {
-                    let ident = pat_to_ident(pat);
-                    argexprs.push(conv.conversion_expr(ident));
-                } else {
-                    argexprs.push(pat_to_expr(pat));
+        FnArg::Typed(mut pat_type) => {
+            let pat_ident = match &mut *pat_type.pat {
+                Pat::Ident(pat_ident) if pat_ident.by_ref.is_none() && pat_ident.subpat.is_none() => pat_ident,
+                _ => {
+                    pat_type.pat = Box::new(Pat::Ident(PatIdent {
+                        ident: Ident::new(&format!("arg_{i}_gen_by_momo_"), proc_macro2::Span::call_site()),
+                        attrs: Default::default(),
+                        by_ref: None,
+                        mutability: None,
+                        subpat: None,
+                    }));
+
+                    if let Pat::Ident(pat_ident) = &mut *pat_type.pat {
+                        pat_ident
+                    } else {
+                        panic!()
+                    }
                 }
-            }
-            Type::Path(..) => {
-                if let Some(conv) = parse_bounded_type(ty).and_then(|ident| ty_conversions.get(&ident)) {
-                    let ident = pat_to_ident(pat);
-                    argexprs.push(conv.conversion_expr(ident));
-                } else {
-                    argexprs.push(pat_to_expr(pat));
+            };
+            // Outer function type argument pat does not need mut unless its
+            // type is `impl AsMut`.
+            pat_ident.mutability = None;
+
+            let ident = &pat_ident.ident;
+
+            let to_expr = || parse_quote!(#ident);
+
+            match *pat_type.ty {
+                Type::ImplTrait(TypeImplTrait { ref bounds, .. }) => {
+                    if let Some(conv) = parse_bounds(bounds) {
+                        argexprs.push(conv.conversion_expr(ident));
+                        if let Conversion::AsMut(_) = conv {
+                            pat_ident.mutability = Some(Default::default());
+                        }
+                    } else {
+                        argexprs.push(to_expr());
+                    }
+                }
+                Type::Path(..) => {
+                    if let Some(conv) = parse_bounded_type(&pat_type.ty).and_then(|ident| ty_conversions.get(&ident)) {
+                        argexprs.push(conv.conversion_expr(ident));
+                        if let Conversion::AsMut(_) = conv {
+                            pat_ident.mutability = Some(Default::default());
+                        }
+                    } else {
+                        argexprs.push(to_expr());
+                    }
+                }
+                _ => {
+                    argexprs.push(to_expr());
                 }
             }
-            _ => {
-                argexprs.push(pat_to_expr(pat));
-            }
-        },
+
+            // Now that mutability is decided, push the type into argtypes
+            argtypes.push(FnArg::Typed(pat_type));
+        }
     });
-    (argexprs, has_self)
+    (argtypes, argexprs, has_self)
 }
 
 fn contains_self_type_path(path: &Path) -> bool {
@@ -199,7 +220,7 @@ fn momo_inner(code: proc_macro2::TokenStream) -> proc_macro2::TokenStream {
 
     if let Item::Fn(item_fn) = fn_item {
         let ty_conversions = parse_generics(&item_fn.sig);
-        let (argexprs, has_self) = convert(&item_fn.sig.inputs, &ty_conversions);
+        let (argtypes, argexprs, has_self) = convert(&item_fn.sig.inputs, &ty_conversions);
 
         let uses_self = has_self
             || item_fn.sig.inputs.iter().any(has_self_type)
@@ -211,6 +232,11 @@ fn momo_inner(code: proc_macro2::TokenStream) -> proc_macro2::TokenStream {
             proc_macro2::Span::call_site(),
         );
 
+        let outer_sig = Signature {
+            inputs: argtypes,
+            ..item_fn.sig.clone()
+        };
+
         let new_inner_item = Item::Fn(ItemFn {
             // Remove doc comment since they will increase compile-time and
             // also generates duplicate warning/error messages for the doc,
@@ -226,7 +252,7 @@ fn momo_inner(code: proc_macro2::TokenStream) -> proc_macro2::TokenStream {
             vis: Visibility::Inherited,
             sig: Signature {
                 ident: inner_ident.clone(),
-                ..item_fn.sig.clone()
+                ..item_fn.sig
             },
             block: item_fn.block,
         });
@@ -243,7 +269,7 @@ fn momo_inner(code: proc_macro2::TokenStream) -> proc_macro2::TokenStream {
             let new_item = Item::Fn(ItemFn {
                 attrs: item_fn.attrs,
                 vis: item_fn.vis,
-                sig: item_fn.sig,
+                sig: outer_sig,
                 block: if has_self {
                     parse_quote!({ self.#inner_ident(#argexprs) })
                 } else {
@@ -258,7 +284,7 @@ fn momo_inner(code: proc_macro2::TokenStream) -> proc_macro2::TokenStream {
             let new_item = Item::Fn(ItemFn {
                 attrs: item_fn.attrs,
                 vis: item_fn.vis,
-                sig: item_fn.sig,
+                sig: outer_sig,
                 block: parse_quote!({
                     #[allow(unused_mut)]
                     #new_inner_item

gix-macros/tests/test.rs

@@ -192,6 +192,25 @@ impl TryInto<String> for S {
     }
 }
 
+#[allow(unused)]
+#[momo]
+fn test_fn_pat<E>(
+    a: impl Into<String>,
+    b: impl AsRef<str>,
+    mut c: impl AsMut<str>,
+    d: impl TryInto<String, Error = E>,
+    S(_g): S,
+) -> Result<(), E> {
+    let mut s = a.into();
+    s += b.as_ref();
+    s += c.as_mut();
+    s += &d.try_into()?;
+
+    drop(s);
+
+    Ok(())
+}
+
 #[test]
 fn test_basic_fn() {
     assert_eq!(