proc: command: associated fns instead of methods

proc/src/proc_command.rs

@@ -109,21 +109,28 @@ impl CommandArm {
     fn ident_to_enum_variant (ident: &Ident) -> Arc<str> {
         format!("{}", AsUpperCamelCase(format!("{ident}"))).into()
     }
+    fn has_args (&self) -> bool {
+        self.1.len() > 1
+    }
+    fn args (&self) -> impl Iterator<Item = (&Ident, &Box<Type>)> {
+        self.1.iter().skip(1).filter_map(|arg|if let FnArg::Typed(PatType {
+            ty, pat: box Pat::Ident(PatIdent { ident: arg, .. }), ..
+        }) = arg {
+            Some((arg, ty))
+        } else {
+            unreachable!("only typed args should be present at this position");
+            None
+        })
+    }
     fn to_enum_variant_def (&self) -> TokenStream2 {
         let mut out = TokenStream2::new();
         out.append(self.to_enum_variant_ident());
         let ident = &self.0;
-        if self.1.len() > 2 {
+        if self.has_args() {
             out.append(Group::new(Delimiter::Brace, {
                 let mut out = TokenStream2::new();
-                for arg in self.1.iter().skip(2) {
+                for (arg, ty) in self.args() {
-                    if let FnArg::Typed(PatType {
+                    write_quote_to(&mut out, quote! { #arg : #ty , });
-                        ty, pat: box Pat::Ident(PatIdent { ident, .. }), ..
-                    }) = arg {
-                        write_quote_to(&mut out, quote! { #ident : #ty , });
-                    } else {
-                        unreachable!("only typed args should be present at this position")
-                    }
                 }
                 out
             }));
@@ -135,24 +142,18 @@ impl CommandArm {
         let mut out = TokenStream2::new();
         out.append(self.to_enum_variant_ident());
         let ident = &self.0;
-        if self.1.len() > 2 {
+        if self.has_args() {
             out.append(Group::new(Delimiter::Brace, {
                 let mut out = TokenStream2::new();
-                for arg in self.1.iter().skip(2) {
+                for (arg, ty) in self.args() {
-                    if let FnArg::Typed(PatType {
+                    let take_err = LitStr::new(&format!("{}: missing argument \"{}\" ({})",
-                        ty, pat: box Pat::Ident(PatIdent { ident: arg, .. }), ..
+                        quote!{#ident}, quote!{#arg}, quote!{#ty}), Span::call_site());
-                    }) = arg {
+                    let give_err = LitStr::new(&format!("{}: missing value \"{}\" ({})",
-                        let take_err = LitStr::new(&format!("{}: missing argument \"{}\" ({})",
+                        quote!{#ident}, quote!{#arg}, quote!{#ty}), Span::call_site());
-                            quote!{#ident}, quote!{#arg}, quote!{#ty}), Span::call_site());
+                    write_quote_to(&mut out, quote! {
-                        let give_err = LitStr::new(&format!("{}: missing value \"{}\" ({})",
+                        #arg : Context::get(state, &iter.next().expect(#take_err).value)
-                            quote!{#ident}, quote!{#arg}, quote!{#ty}), Span::call_site());
+                            .expect(#give_err) ,
-                        write_quote_to(&mut out, quote! {
+                    });
-                            #arg : Context::get(state, &iter.next().expect(#take_err).value)
-                                .expect(#give_err) ,
-                        });
-                    } else {
-                        unreachable!("only typed args should be present at this position")
-                    }
                 }
                 out
             }));
@@ -163,17 +164,11 @@ impl CommandArm {
         let mut out = TokenStream2::new();
         out.append(self.to_enum_variant_ident());
         let ident = &self.0;
-        if self.1.len() > 2 {
+        if self.has_args() {
             out.append(Group::new(Delimiter::Brace, {
                 let mut out = TokenStream2::new();
-                for arg in self.1.iter().skip(2) {
+                for (arg, ty) in self.args() {
-                    if let FnArg::Typed(PatType {
+                    write_quote_to(&mut out, quote! { #arg , });
-                        ty, pat: box Pat::Ident(PatIdent { ident: arg, .. }), ..
-                    }) = arg {
-                        write_quote_to(&mut out, quote! { #arg , });
-                    } else {
-                        unreachable!("only typed args should be present at this position")
-                    }
                 }
                 out
             }));
@@ -181,52 +176,21 @@ impl CommandArm {
         out
     }
     fn to_matcher (&self) -> TokenStream2 {
-        let mut out = TokenStream2::new();
+        let key = LitStr::new(&self.to_key(), Span::call_site());
-        let key     = LitStr::new(&self.to_key(), Span::call_site());
-        let ident   = &self.0;
-        let take_args = self.1.iter().skip(2).map(|arg|{
-            if let FnArg::Typed(PatType {
-                ty, pat: box Pat::Ident(PatIdent { ident: arg, .. }), ..
-            }) = arg {
-                let take_err = LitStr::new(&format!("{}: missing argument \"{}\" ({})",
-                    quote!{#ident}, quote!{#arg}, quote!{#ty}), Span::call_site());
-                write_quote(quote! {
-                    let #ident: #ty = Context::<#ty>::get(
-                        state,
-                        &iter.next().expect(#take_err).value
-                    );
-                })
-            } else {
-                unreachable!("only typed args should be present at this position")
-            }
-        }).collect::<Vec<_>>();
-        let variant = Self::ident_to_enum_variant(&self.0);
         let variant = self.to_enum_variant_bind();
+        let pattern = quote! {
+            Some(::tengri::dsl::Token { value: ::tengri::dsl::Value::Key(#key), .. })
+        };
         write_quote(quote! {
-            Some(::tengri::dsl::Token { value: ::tengri::dsl::Value::Key(#key), .. }) => {
+            #pattern => { let mut iter = iter.clone(); Some(Self::#variant) },
-                let mut iter = iter.clone();
-                //#(#take_args)*
-                //let rest = iter; // TODO
-                Some(Self::#variant)
-            },
         })
     }
     fn to_implementation (&self) -> TokenStream2 {
         let ident = &self.0;
         let variant = self.to_enum_variant_unbind();
         let mut give_rest = write_quote(quote! { /*TODO*/ });
-        let give_args = self.1.iter().skip(2).map(|arg|{
+        let give_args = self.args().map(|(arg, ty)|write_quote(quote! { #arg, })).collect::<Vec<_>>();
-            if let FnArg::Typed(PatType {
+        write_quote(quote! { Self::#variant => Self::#ident(state, #(#give_args)* #give_rest), })
-                ty, pat: box Pat::Ident(PatIdent { ident: arg, .. }), ..
-            }) = arg {
-                //let give_err = LitStr::new(&format!("{}: missing value \"{}\" ({})",
-                    //quote!{#ident}, quote!{#pat}, quote!{#ty}), Span::call_site());
-                write_quote(quote! { #arg, })
-            } else {
-                unreachable!("only typed args should be present at this position")
-            }
-        }).collect::<Vec<_>>();
-        write_quote(quote! { Self::#variant => self.#ident(state, #(#give_args)* #give_rest), })
     }
 }
 
@@ -269,8 +233,9 @@ impl ToTokens for CommandArm {
         }));
         out.append(Punct::new('=', Joint));
         out.append(Punct::new('>', Alone));
-        out.append(Ident::new("self", Span::call_site()));
+        out.append(Ident::new("Self", Span::call_site()));
-        out.append(Punct::new('.', Alone));
+        out.append(Punct::new(':', Joint));
+        out.append(Punct::new(':', Alone));
         out.append(ident.clone());
         out.append(Group::new(Delimiter::Parenthesis, {
             let mut out = TokenStream2::new();