Add trace attribute

node_derive/Cargo.toml

@@ -10,5 +10,5 @@ edition = "2018"
 proc-macro = true
 
 [dependencies]
-syn = "0.14.4"
+syn = { version = "0.15.18", features = ["full", "fold", "parsing"] }
-quote = "0.6.3"
+quote = "0.6.9"

node_derive/src/lib.rs

@@ -4,7 +4,7 @@ extern crate proc_macro;
 
 use crate::proc_macro::TokenStream;
 use quote::quote;
-use syn;
+use syn::{self, parse_macro_input, ItemFn};
 
 #[proc_macro_derive(Node)]
 pub fn node_derive(input: TokenStream) -> TokenStream {
@@ -113,3 +113,25 @@ fn impl_any_node(ast: &syn::DeriveInput) -> TokenStream {
     };
     gen.into()
 }
+
+#[proc_macro_attribute]
+pub fn trace(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    let item = parse_macro_input!(item as ItemFn);
+    impl_trace(&item)
+}
+
+fn impl_trace(item: &syn::ItemFn) -> TokenStream {
+    let ident = &item.ident;
+    let mut item = item.clone();
+    let tracer = quote! {
+        println!("{}: {:?}", stringify!(#ident), s);
+    };
+    let tracer: TokenStream = tracer.into();
+    let tracer = parse_macro_input!(tracer as syn::Stmt);
+    item.block.stmts.insert(0, tracer);
+
+    let gen = quote! {
+        #item
+    };
+    gen.into()
+}

src/parser/expressions/expression_leftside_values.rs

@@ -151,8 +151,26 @@ pub fn nonrange_variable_lvalue(s: Span) -> IResult<Span, NonrangeVariableLvalue
 
 #[cfg(test)]
 mod tests {
-    //use super::*;
+    use super::*;
 
     #[test]
-    fn test() {}
+    fn test_net_lvalue() {
+        parser_test!(net_lvalue, "A", Ok((_, _)));
+        parser_test!(net_lvalue, "{A[7:0],A[15:8],A[23:16]}", Ok((_, _)));
+        parser_test!(net_lvalue, "'{A[7:0],A[15:8]}", Ok((_, _)));
+    }
+
+    #[test]
+    fn test_variable_lvalue() {
+        parser_test!(variable_lvalue, "A", Ok((_, _)));
+        parser_test!(variable_lvalue, "{A[7:0],A[15:8],A[23:16]}", Ok((_, _)));
+        parser_test!(variable_lvalue, "'{A[7:0],A[15:8]}", Ok((_, _)));
+    }
+
+    #[test]
+    fn test_nonrange_variable_lvalue() {
+        parser_test!(nonrange_variable_lvalue, "A", Ok((_, _)));
+        parser_test!(nonrange_variable_lvalue, "A[][2][3]", Ok((_, _)));
+        //parser_test!(nonrange_variable_lvalue, "A[][]", Ok((_, _)));
+    }
 }

src/parser/expressions/numbers.rs

@@ -548,16 +548,4 @@ mod tests {
         parser_test!(unbased_unsized_literal, "'x", Ok((_, _)));
         parser_test!(unbased_unsized_literal, "'z", Ok((_, _)));
     }
-
-    #[test]
-    fn test_node() {
-        if let Ok((_, x)) = all_consuming(number)(Span::new_extra("10.00", 0)) {
-            //assert_eq!(x.test(), "aaaa");
-            //let y: AnyNode = (&x).into();
-            for a in &x {
-                dbg!(a);
-                //assert_eq!(format!("{:?}", a), "aaa");
-            }
-        }
-    }
 }

src/parser/expressions/primaries.rs

@@ -587,45 +587,38 @@ mod tests {
 
     #[test]
     fn test_primary() {
-        let ret = all_consuming(primary)(Span::new_extra("2.1ns", 0));
+        parser_test!(
-        if let Ok((_, Primary::PrimaryLiteral(PrimaryLiteral::TimeLiteral(_)))) = ret {
+            primary,
-        } else {
+            "2.1ns",
-            assert!(false, "{:?}", ret)
+            Ok((_, Primary::PrimaryLiteral(PrimaryLiteral::TimeLiteral(_))))
-        }
+        );
-        let ret = all_consuming(primary)(Span::new_extra("40 ps", 0));
+        parser_test!(
-        if let Ok((_, Primary::PrimaryLiteral(PrimaryLiteral::TimeLiteral(_)))) = ret {
+            primary,
-        } else {
+            "40 ps",
-            assert!(false, "{:?}", ret)
+            Ok((_, Primary::PrimaryLiteral(PrimaryLiteral::TimeLiteral(_))))
-        }
+        );
-        let ret = all_consuming(primary)(Span::new_extra("'0", 0));
+        parser_test!(
-        if let Ok((_, Primary::PrimaryLiteral(PrimaryLiteral::UnbasedUnsizedLiteral(_)))) = ret {
+            primary,
-        } else {
+            "'0",
-            assert!(false, "{:?}", ret)
+            Ok(
-        }
+                (
-        let ret = all_consuming(primary)(Span::new_extra("10", 0));
+                    _,
-        if let Ok((_, Primary::PrimaryLiteral(PrimaryLiteral::Number(_)))) = ret {
+                    Primary::PrimaryLiteral(PrimaryLiteral::UnbasedUnsizedLiteral(_))
-        } else {
+                ),
-            assert!(false, "{:?}", ret)
+            )
-        }
+        );
-        let ret = all_consuming(primary)(Span::new_extra("\"aaa\"", 0));
+        parser_test!(
-        if let Ok((_, Primary::PrimaryLiteral(PrimaryLiteral::StringLiteral(_)))) = ret {
+            primary,
-        } else {
+            "10",
-            assert!(false, "{:?}", ret)
+            Ok((_, Primary::PrimaryLiteral(PrimaryLiteral::Number(_))))
-        }
+        );
-        let ret = all_consuming(primary)(Span::new_extra("this", 0));
+        parser_test!(
-        if let Ok((_, Primary::This(_))) = ret {
+            primary,
-        } else {
+            "\"aaa\"",
-            assert!(false, "{:?}", ret)
+            Ok((_, Primary::PrimaryLiteral(PrimaryLiteral::StringLiteral(_))))
-        }
+        );
-        let ret = all_consuming(primary)(Span::new_extra("$", 0));
+        parser_test!(primary, "this", Ok((_, Primary::This(_))));
-        if let Ok((_, Primary::Dollar(_))) = ret {
+        parser_test!(primary, "$", Ok((_, Primary::Dollar(_))));
-        } else {
+        parser_test!(primary, "null", Ok((_, Primary::Null(_))));
-            assert!(false, "{:?}", ret)
-        }
-        let ret = all_consuming(primary)(Span::new_extra("null", 0));
-        if let Ok((_, Primary::Null(_))) = ret {
-        } else {
-            assert!(false, "{:?}", ret)
-        }
     }
 }