Write unit tests for the rust generator

Tests are added to the crate pdl-tests, which implements a
private proc_macro pdl! that generates a rust module from
an inline PDL grammar.

The tests are added following this pattern:

```
 #[pdl_inline(r#"
 // inline pdl grammar to be tested
 "#)]
 #[cfg(test)]
 mod test_module {
   #[test]
   fn test_one() {
   }

   // more tests
 }
```

Author: hchataing

Cargo.toml

@@ -3,4 +3,5 @@ members = [
     "pdl-compiler",
     "pdl-derive",
     "pdl-runtime",
+    "pdl-tests",
 ]

pdl-derive/src/lib.rs

@@ -74,6 +74,47 @@ fn pdl_proc_macro(path: syn::LitStr, input: syn::ItemMod) -> TokenStream {
     }
 }
 
+fn pdl_inline_proc_macro(code: syn::LitStr, input: syn::ItemMod) -> TokenStream {
+    // Load and parse the grammar.
+    let mut sources = pdl_compiler::ast::SourceDatabase::new();
+    let file = match pdl_compiler::parser::parse_inline(&mut sources, "stdin", code.value()) {
+        Ok(file) => file,
+        Err(err) => {
+            let mut buffer = termcolor::Buffer::no_color();
+            term::emit(&mut buffer, &term::Config::default(), &sources, &err)
+                .expect("could not emit parser diagnostics");
+            return syn::Error::new(code.span(), String::from_utf8(buffer.into_inner()).unwrap())
+                .to_compile_error();
+        }
+    };
+
+    // Run the analyzer.
+    let analyzed_file = match pdl_compiler::analyzer::analyze(&file) {
+        Ok(file) => file,
+        Err(diagnostics) => {
+            let mut buffer = termcolor::Buffer::no_color();
+            diagnostics.emit(&sources, &mut buffer).expect("could not emit analyzer diagnostics");
+            return syn::Error::new(code.span(), String::from_utf8(buffer.into_inner()).unwrap())
+                .to_compile_error();
+        }
+    };
+
+    // Generate the pdl backend implementation.
+    let parser = pdl_compiler::backends::rust::generate_tokens(&sources, &analyzed_file, &[]);
+    let mod_ident = input.ident;
+    let mod_attrs = input.attrs;
+    let mod_vis = input.vis;
+    let mod_items = input.content.map(|(_, items)| items).unwrap_or_default();
+
+    quote! {
+        #(#mod_attrs)*
+        #mod_vis mod #mod_ident {
+            #parser
+            #(#mod_items)*
+        }
+    }
+}
+
 /// The main method that's called by the proc macro
 /// (a wrapper around `pest_generator::derive_parser`)
 #[proc_macro_attribute]
@@ -86,8 +127,21 @@ pub fn pdl(
     pdl_proc_macro(attr, input).into()
 }
 
+/// The main method that's called by the proc macro
+/// (a wrapper around `pest_generator::derive_parser`)
+#[proc_macro_attribute]
+pub fn pdl_inline(
+    attr: proc_macro::TokenStream,
+    input: proc_macro::TokenStream,
+) -> proc_macro::TokenStream {
+    let attr = parse_macro_input!(attr as syn::LitStr);
+    let input = parse_macro_input!(input as syn::ItemMod);
+    pdl_inline_proc_macro(attr, input).into()
+}
+
 #[cfg(test)]
 mod test {
+    use super::pdl_inline_proc_macro;
     use super::pdl_proc_macro;
     use proc_macro2::TokenStream;
     use quote::quote;
@@ -167,4 +221,55 @@ mod test {
             Some("error[E")
         ));
     }
+
+    #[test]
+    fn test_derive_valid_inline() {
+        assert!(!is_compile_error(
+            pdl_inline_proc_macro(
+                make_attr(quote! {
+                r#"
+                    little_endian_packets
+                    packet Prout {
+                        x: 8,
+                    }
+                "# }),
+                make_input(quote! { mod Test {} }),
+            ),
+            None
+        ));
+    }
+
+    #[test]
+    fn test_derive_parser_error_inline() {
+        assert!(is_compile_error(
+            pdl_inline_proc_macro(
+                make_attr(quote! {
+                r#"
+                    little_endian_packets
+                    enum A {
+                        X = 0
+                    }
+                "# }),
+                make_input(quote! { mod Test {} }),
+            ),
+            Some("error: failed to parse input file")
+        ));
+    }
+
+    #[test]
+    fn test_derive_analyzer_error_inline() {
+        assert!(is_compile_error(
+            pdl_inline_proc_macro(
+                make_attr(quote! {
+                r#"
+                    little_endian_packets
+                    packet A {
+                        x: Unknown,
+                    }
+                "# }),
+                make_input(quote! { mod Test {} }),
+            ),
+            Some("error[E")
+        ));
+    }
 }

pdl-tests/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "pdl-tests"
+version = "0.0.0"
+publish = false
+edition = "2021"
+description = "PDL Rust generated code tests"
+
+[dependencies]
+bytes = "1.4.0"
+thiserror = "1.0.47"
+pdl-compiler = {path = "../pdl-compiler"}
+pdl-runtime = {path = "../pdl-runtime"}
+pdl-derive = {path = "../pdl-derive"}
+codespan-reporting = "0.11.1"
+proc-macro2 = "1.0.66"
+quote = "1.0.33"
+syn = {version = "2.0.29", features = ["full"]}
+termcolor = "1.2.0"