mod expr support, lite refactoring, simple Decode trait alias for complex Parser

Author: functora

rust/rustell/README.md

@@ -4,6 +4,6 @@ Rustell is a development tool for Rust, designed for users who are not accustome
 
 Its usage is similar to "rustfmt": Rustell reads Rust source code (which may omit some required semicolons) from standard input ("stdin") and produces corrected output with all necessary semicolons inserted through standard output ("stdout"). It is intended to be used as a text editor plugin, typically invoked right before running "rustfmt".
 
-Rustell is implemented as a partial Rust parser. It parses only those parts of the code that depend on semicolons, such as "use", "mod", and "let" statements, as well as statements inside "{ ... }" code blocks (excluding the final statement in a block). Rustell converts these expressions into an internal AST, consuming any existing semicolons if present. Code that does not belong to these statements is left untouched and represented as a special "other" node type within the AST.
+Rustell is implemented as a partial Rust parser. It parses only those parts of the code that depend on semicolons, such as "use", "mod", and "let" statements, as well as statements inside "{ ... }" code blocks (excluding the final statement in a block). Rustell converts these expressions into an internal AST, consuming any existing semicolons if present. Code that does not belong to these statements is left untouched and represented as a special "raw" node type within the AST.
 
-Finally, Rustell renders its AST back into Rust source code, appending semicolons where required while preserving "other" nodes exactly as they appeared in the original input.
+Finally, Rustell renders its AST back into Rust source code, appending semicolons where required while preserving "raw" nodes exactly as they appeared in the original input.

rust/rustell/src/decode.rs

@@ -3,32 +3,43 @@ use chumsky::prelude::Parser;
 use chumsky::prelude::*;
 use chumsky::text::whitespace;
 
-pub fn expr<'a>() -> impl Parser<
-    'a,
-    &'a str,
-    Vec<Expr<'a>>,
-    extra::Err<Rich<'a, char>>,
-> {
-    choice((expr_use(), expr_other()))
+pub trait Decode<'a, T>:
+    Parser<'a, &'a str, T, extra::Err<Rich<'a, char>>>
+{
+}
+
+impl<'a, T, U> Decode<'a, T> for U where
+    U: Parser<'a, &'a str, T, extra::Err<Rich<'a, char>>>
+{
+}
+
+pub fn expr<'a>() -> impl Decode<'a, Vec<Expr<'a>>> {
+    choice((expr_ast(), expr_raw()))
         .repeated()
         .collect::<Vec<_>>()
 }
 
-fn expr_use<'a>()
--> impl Parser<'a, &'a str, Expr<'a>, extra::Err<Rich<'a, char>>>
-{
+fn expr_ast<'a>() -> impl Decode<'a, Expr<'a>> {
+    choice((expr_mod(), expr_use()))
+}
+
+fn expr_mod<'a>() -> impl Decode<'a, Expr<'a>> {
+    let tok =
+        token(text::ascii::ident()).and_is(keyword().not());
+    just("mod")
+        .ignore_then(tok)
+        .then_ignore(lexeme(";").or_not())
+        .map(Expr::Mod)
+}
+
+fn expr_use<'a>() -> impl Decode<'a, Expr<'a>> {
     just("use")
         .ignore_then(expr_use_rec())
         .then_ignore(lexeme(";").or_not())
         .map(Expr::Use)
 }
 
-fn expr_use_rec<'a>() -> impl Parser<
-    'a,
-    &'a str,
-    ExprUse<'a>,
-    extra::Err<Rich<'a, char>>,
-> {
+fn expr_use_rec<'a>() -> impl Decode<'a, ExprUse<'a>> {
     recursive(|expr_use_rec| {
         let item = expr_use_tok()
             .then(
@@ -62,61 +73,41 @@ fn expr_use_rec<'a>() -> impl Parser<
     })
 }
 
-fn expr_use_tok<'a>()
--> impl Parser<'a, &'a str, &'a str, extra::Err<Rich<'a, char>>>
-+ Clone {
+fn expr_use_tok<'a>() -> impl Decode<'a, &'a str> + Clone {
     token(text::ascii::ident()).and_is(
         keyword_except(&["crate", "super", "self", "Self"])
             .not(),
     )
 }
 
-fn expr_other<'a>()
--> impl Parser<'a, &'a str, Expr<'a>, extra::Err<Rich<'a, char>>>
-{
+fn expr_raw<'a>() -> impl Decode<'a, Expr<'a>> {
     any()
-        .and_is(expr_use().not())
+        .and_is(expr_ast().not())
         .repeated()
         .at_least(1)
         .to_slice()
-        .map(Expr::Other)
+        .map(Expr::Raw)
 }
 
 fn token<'a>(
-    tok: impl Parser<
-        'a,
-        &'a str,
-        &'a str,
-        extra::Err<Rich<'a, char>>,
-    > + Clone,
-) -> impl Parser<
-    'a,
-    &'a str,
-    &'a str,
-    extra::Err<Rich<'a, char>>,
-> + Clone {
+    tok: impl Decode<'a, &'a str> + Clone,
+) -> impl Decode<'a, &'a str> + Clone {
     whitespace().or_not().ignore_then(tok)
 }
 
 fn lexeme<'a>(
     seq: &'a str,
-) -> impl Parser<
-    'a,
-    &'a str,
-    &'a str,
-    extra::Err<Rich<'a, char>>,
-> + Clone {
+) -> impl Decode<'a, &'a str> + Clone {
     token(just(seq))
 }
 
+fn keyword<'a>() -> impl Decode<'a, &'a str> + Clone {
+    keyword_except(&[])
+}
+
 fn keyword_except<'a>(
     except: &[&str],
-) -> impl Parser<
-    'a,
-    &'a str,
-    &'a str,
-    extra::Err<Rich<'a, char>>,
-> + Clone {
+) -> impl Decode<'a, &'a str> + Clone {
     choice(
         [
             "as", "break", "const", "continue", "crate",

rust/rustell/src/encode.rs

@@ -15,7 +15,7 @@ fn expr_one<'a>(ast: &'a Expr<'a>) -> IntoIter<&'a str> {
             .chain(once(";"))
             .collect::<Vec<_>>()
             .into_iter(),
-        Expr::Other(x) => vec![*x].into_iter(),
+        Expr::Raw(x) => vec![*x].into_iter(),
     }
 }
 

rust/rustell/src/lib.rs

@@ -6,7 +6,7 @@ pub use chumsky::prelude::Parser;
 pub enum Expr<'a> {
     Mod(&'a str),
     Use(ExprUse<'a>),
-    Other(&'a str),
+    Raw(&'a str),
 }
 
 #[derive(Eq, PartialEq, Debug, Clone)]

rust/rustell/tests/integration.rs

@@ -143,14 +143,14 @@ fn test_parser_crate() {
 }
 
 #[test]
-fn test_parser_other_then_use() {
+fn test_parser_raw_then_use() {
     let lhs = r#"
     fn test() {
         println!("Hello")
     }
     use crate::module::Type;"#;
     let rhs = vec![
-        Expr::Other(
+        Expr::Raw(
             r#"
     fn test() {
         println!("Hello")
@@ -183,7 +183,7 @@ fn test_parser_multiple() {
     use std::fs;
     "#;
     let rhs = vec![
-        Expr::Other("\n    "),
+        Expr::Raw("\n    "),
         Expr::Use(ExprUse::Item {
             module: "std",
             rename: None,
@@ -193,7 +193,7 @@ fn test_parser_multiple() {
                 nested: None,
             })),
         }),
-        Expr::Other("\n    "),
+        Expr::Raw("\n    "),
         Expr::Use(ExprUse::Item {
             module: "std",
             rename: None,
@@ -203,15 +203,15 @@ fn test_parser_multiple() {
                 nested: None,
             })),
         }),
-        Expr::Other("\n    "),
+        Expr::Raw("\n    "),
     ];
     assert_eq!(decode(lhs), rhs);
     assert_eq!(decode(&sloppy(lhs)), rhs);
     assert_eq!(decode(&encode(&rhs)), rhs)
 }
 
 #[test]
-fn test_parser_multiple_with_other() {
+fn test_parser_multiple_with_raw() {
     let lhs = r#"
     use std::io;
     fn test() {
@@ -220,7 +220,7 @@ fn test_parser_multiple_with_other() {
     use std::fs;
     "#;
     let rhs = vec![
-        Expr::Other("\n    "),
+        Expr::Raw("\n    "),
         Expr::Use(ExprUse::Item {
             module: "std",
             rename: None,
@@ -230,7 +230,7 @@ fn test_parser_multiple_with_other() {
                 nested: None,
             })),
         }),
-        Expr::Other(
+        Expr::Raw(
             r#"
     fn test() {
         println!("Hello")
@@ -246,7 +246,7 @@ fn test_parser_multiple_with_other() {
                 nested: None,
             })),
         }),
-        Expr::Other("\n    "),
+        Expr::Raw("\n    "),
     ];
     assert_eq!(decode(lhs), rhs);
     assert_eq!(decode(&sloppy(lhs)), rhs);
@@ -267,7 +267,7 @@ fn test_parser_mixed_all_cases() {
     }
     "#;
     let rhs = vec![
-        Expr::Other("\n    "),
+        Expr::Raw("\n    "),
         Expr::Use(ExprUse::Item {
             module: "std",
             rename: None,
@@ -297,7 +297,7 @@ fn test_parser_mixed_all_cases() {
                 },
             ]))),
         }),
-        Expr::Other("\n    "),
+        Expr::Raw("\n    "),
         Expr::Use(ExprUse::Item {
             module: "crate",
             rename: None,
@@ -311,7 +311,7 @@ fn test_parser_mixed_all_cases() {
                 })),
             })),
         }),
-        Expr::Other(
+        Expr::Raw(
             r#"
 
     fn hello() {