proc, input, output: cleanup warnings

input/src/input_dsl.rs

@@ -132,8 +132,7 @@ where
     M: KeyMap<'state, S, C, I> + Send + Sync
 {
     fn fmt (&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
-        write!(f, "[InputMap: {} layer(s)]", self.layers.len());
+        write!(f, "[InputMap: {} layer(s)]", self.layers.len())
-        Ok(())
     }
 }
 

output/src/ops/cond.rs

@@ -22,18 +22,13 @@ impl<A, B> Either<A, B> {
 try_from_expr!(<'source, 'state, E>: When<RenderBox<'state, E>>: |state, iter| {
     if let Some(Token { value: Value::Key("when"), .. }) = iter.peek() {
         let _ = iter.next().unwrap();
-
+        let content = iter.next().expect("no content specified").value;
-        let condition = iter.next().expect("no condition specified");
+        return Some(Self(
-        let condition = state.get(&mut iter).expect("no condition provided");
+            state.get(&mut iter)
-
+                .expect("no condition provided"),
-        let content = iter.next().expect("no content specified");
+            state.get_content(&content)
-        let content = if let Some(content) = state.get_content(&content.value) {
+                .unwrap_or_else(||panic!("no content corresponding to for {:?}", &content))
-            content
+        ))
-        } else {
-            panic!("no content corresponding to for {:?}", &content);
-        };
-
-        return Some(Self(condition, content))
     }
 });
 
@@ -41,25 +36,16 @@ try_from_expr!(<'source, 'state, E>: When<RenderBox<'state, E>>: |state, iter| {
 try_from_expr!(<'source, 'state, E>: Either<RenderBox<'state, E>, RenderBox<'state, E>>: |state, iter| {
     if let Some(Token { value: Value::Key("either"), .. }) = iter.peek() {
         let _ = iter.next().unwrap();
-
+        let content   = iter.next().expect("no content specified").value;
-        let condition = iter.next().expect("no condition specified");
+        let alternate = iter.next().expect("no alternate specified").value;
-        let condition = state.get(&mut iter).expect("no condition provided");
+        return Some(Self(
-
+            state.get(&mut iter)
-        let content = iter.next().expect("no content specified");
+                .expect("no condition provided"),
-        let content = if let Some(content) = state.get_content(&content.value) {
+            state.get_content(&content)
-            content
+                .unwrap_or_else(||panic!("no content 1 corresponding to {:?}", &content)),
-        } else {
+            state.get_content(&alternate)
-            panic!("no content 1 corresponding to {:?}", &content);
+                .unwrap_or_else(||panic!("no content 2 corresponding to {:?}", &alternate)),
-        };
+        ))
-
-        let alternate = iter.next().expect("no alternate specified");
-        let alternate = if let Some(alternate) = state.get_content(&alternate.value) {
-            alternate
-        } else {
-            panic!("no content 2 corresponding to {:?}", &alternate);
-        };
-
-        return Some(Self(condition, content, alternate))
     }
 });
 

proc/src/lib.rs

@@ -2,23 +2,17 @@
 #![feature(box_patterns)]
 extern crate proc_macro;
 
-pub(crate) use std::collections::{BTreeMap, BTreeSet};
+pub(crate) use std::collections::BTreeMap;
 pub(crate) use std::cmp::Ordering;
 pub(crate) use std::sync::Arc;
 pub(crate) use proc_macro::TokenStream;
 pub(crate) use proc_macro2::{
-    TokenStream as TokenStream2, TokenTree,
+    TokenStream as TokenStream2, Ident, Span, Punct, Group, Delimiter, Spacing::*
-    Ident, Span, Punct, Spacing::*, Group, Delimiter, Literal
 };
 pub(crate) use syn::{
-    parse, parse_macro_input, parse_quote as pq,
+    parse_macro_input, ImplItem, ImplItemFn, LitStr, Type,
-    braced, bracketed, parenthesized, Token,
+    ItemImpl, ReturnType, Signature, FnArg, Pat, PatType, PatIdent,
-    Arm, Expr, Attribute, Meta, MetaList, Path, PathSegment, PathArguments,
-    ImplItem, ImplItemFn, LitStr, Type, ItemImpl, ReturnType, Signature, FnArg,
-    Pat, PatType, PatIdent,
     parse::{Parse, ParseStream, Result},
-    token::{PathSep, Brace},
-    punctuated::Punctuated,
 };
 pub(crate) use quote::{quote, TokenStreamExt, ToTokens};
 pub(crate) use heck::{AsKebabCase, AsUpperCamelCase};

proc/src/proc_command.rs

@@ -121,13 +121,12 @@ impl CommandArm {
             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;
+        //let ident = &self.0;
         if self.has_args() {
             out.append(Group::new(Delimiter::Brace, {
                 let mut out = TokenStream2::new();
@@ -148,8 +147,8 @@ impl CommandArm {
             out.append(Group::new(Delimiter::Brace, {
                 let mut out = TokenStream2::new();
                 for (arg, ty) in self.args() {
-                    let take_err = LitStr::new(&format!("{}: missing argument \"{}\" ({})",
+                    //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());
                     let give_err = LitStr::new(&format!("{}: missing value for \"{}\" ({})",
                         quote!{#ident}, quote!{#arg}, quote!{#ty}), Span::call_site());
                     write_quote_to(&mut out, quote! {
@@ -164,11 +163,11 @@ impl CommandArm {
     fn to_enum_variant_unbind (&self) -> TokenStream2 {
         let mut out = TokenStream2::new();
         out.append(self.to_enum_variant_ident());
-        let ident = &self.0;
+        //let ident = &self.0;
         if self.has_args() {
             out.append(Group::new(Delimiter::Brace, {
                 let mut out = TokenStream2::new();
-                for (arg, ty) in self.args() {
+                for (arg, _ty) in self.args() {
                     write_quote_to(&mut out, quote! { #arg , });
                 }
                 out
@@ -189,8 +188,10 @@ impl CommandArm {
     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_rest = write_quote(quote! { /*TODO*/ });
-        let give_args = self.args().map(|(arg, ty)|write_quote(quote! { #arg, })).collect::<Vec<_>>();
+        let give_args = self.args()
+            .map(|(arg, _ty)|write_quote(quote! { #arg, }))
+            .collect::<Vec<_>>();
         write_quote(quote! { Self::#variant => Self::#ident(state, #(#give_args)* #give_rest), })
     }
 }
@@ -216,35 +217,3 @@ impl ToTokens for CommandVariant {
         out.append(Punct::new(',', Alone));
     }
 }
-
-impl ToTokens for CommandArm {
-    fn to_tokens (&self, out: &mut TokenStream2) {
-        let Self(ident, args, returnType) = self;
-        for ident in ["tengri", "dsl", "Value", "Sym"].iter() {
-            out.append(Punct::new(':', Joint));
-            out.append(Punct::new(':', Alone));
-            out.append(Ident::new(ident, Span::call_site()));
-        }
-        out.append(Group::new(Delimiter::Parenthesis, {
-            let mut out = TokenStream2::new();
-            out.append(self.to_enum_variant_ident());
-            out
-        }));
-        out.append(Punct::new('=', Joint));
-        out.append(Punct::new('>', Alone));
-        out.append(Ident::new("Self", Span::call_site()));
-        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();
-            for arg in args.iter() {
-                // TODO
-                out.append(LitStr::new(&self.to_key(), Span::call_site()).token());
-                out.append(Punct::new(',', Alone));
-            }
-            out
-        }));
-        out.append(Punct::new(',', Alone));
-    }
-}

proc/src/proc_expose.rs

@@ -19,7 +19,7 @@ struct ExposeSym(LitStr);
 struct ExposeType(Box<Type>);
 
 impl Parse for ExposeMeta {
-    fn parse (input: ParseStream) -> Result<Self> {
+    fn parse (_input: ParseStream) -> Result<Self> {
         Ok(Self)
     }
 }

proc/src/proc_view.rs

@@ -146,15 +146,6 @@ impl ToTokens for ViewArm {
     //}
 //}
 
-fn nth_segment_is (segments: &Punctuated<PathSegment, PathSep>, n: usize, x: &str) -> bool {
-    if let Some(PathSegment { arguments: PathArguments::None, ident, .. }) = segments.get(n) {
-        if format!("{ident}") == x {
-            return true
-        }
-    }
-    return false
-}
-
 //impl std::cmp::PartialEq for ViewItem {
     //fn eq (&self, other: &Self) -> bool {
         //self.item == other.item && (format!("{:?}", self.expose) == format!("{:?}", other.expose))