typed ast tokens fix

Author: functora

rust/rustell/src/decode.rs

@@ -27,13 +27,15 @@ fn expr_mod<'a>() -> impl Decode<'a, Expr<'a>> {
     let tok =
         token(text::ascii::ident()).and_is(keyword().not());
     just("mod")
+        .then_ignore(whitespace().at_least(1))
         .ignore_then(tok)
         .then_ignore(lexeme(";").or_not())
         .map(Expr::Mod)
 }
 
 fn expr_use<'a>() -> impl Decode<'a, Expr<'a>> {
     just("use")
+        .then_ignore(whitespace().at_least(1))
         .ignore_then(expr_use_rec())
         .then_ignore(lexeme(";").or_not())
         .map(Expr::Use)

rust/rustell/tests/integration.rs

@@ -397,6 +397,76 @@ fn mixed_use_and_raw_cases() {
     assert_eq!(decode(&encode(&rhs)), rhs)
 }
 
+#[test]
+fn small_mixed_lib() {
+    let lhs = r#"
+    pub mod decode;
+    pub mod encode;
+    pub use chumsky::prelude::Parser;
+
+    #[derive(Eq, PartialEq, Debug, Clone)]
+    pub enum Expr<'a> {
+        Mod(&'a str),
+        Use(ExprUse<'a>),
+        Raw(&'a str),
+    }
+
+    #[derive(Eq, PartialEq, Debug, Clone)]
+    pub enum ExprUse<'a> {
+        Item {
+            module: &'a str,
+            rename: Option<&'a str>,
+            nested: Option<Box<ExprUse<'a>>>,
+        },
+        Many(Vec<ExprUse<'a>>),
+        Glob,
+    }"#;
+    let rhs = vec![
+        Expr::Raw("\n    pub "),
+        Expr::Mod("decode"),
+        Expr::Raw("\n    pub "),
+        Expr::Mod("encode"),
+        Expr::Raw("\n    pub "),
+        Expr::Use(ExprUse::Item {
+            module: "chumsky",
+            rename: None,
+            nested: Some(Box::new(ExprUse::Item {
+                module: "prelude",
+                rename: None,
+                nested: Some(Box::new(ExprUse::Item {
+                    module: "Parser",
+                    rename: None,
+                    nested: None,
+                })),
+            })),
+        }),
+        Expr::Raw(
+            r#"
+
+    #[derive(Eq, PartialEq, Debug, Clone)]
+    pub enum Expr<'a> {
+        Mod(&'a str),
+        Use(ExprUse<'a>),
+        Raw(&'a str),
+    }
+
+    #[derive(Eq, PartialEq, Debug, Clone)]
+    pub enum ExprUse<'a> {
+        Item {
+            module: &'a str,
+            rename: Option<&'a str>,
+            nested: Option<Box<ExprUse<'a>>>,
+        },
+        Many(Vec<ExprUse<'a>>),
+        Glob,
+    }"#,
+        ),
+    ];
+    assert_eq!(decode(lhs), rhs);
+    assert_eq!(decode(&sloppy(lhs)), rhs);
+    assert_eq!(decode(&encode(&rhs)), rhs)
+}
+
 #[test]
 fn roundtrip_source_files() {
     get_rust_files("./").into_iter().for_each(|path| {