Test building parsers with modified start rules.

Author: ratmice

lrpar/cttests/Cargo.toml

@@ -12,7 +12,7 @@ crate-type = ["cdylib"]
 [build-dependencies]
 cfgrammar = { path = "../../cfgrammar" }
 lrlex = { path = "../../lrlex" }
-lrpar = { path = "../" }
+lrpar = { path = "../", features = ["_unstable_api"] }
 glob.workspace = true
 yaml-rust2.workspace = true
 cfg_aliases = "0.2.1"

lrpar/cttests/build.rs

@@ -1,3 +1,4 @@
+use cfgrammar::yacc::ast::ASTWithValidityInfo;
 use glob::glob;
 #[path = "src/cgen_helper.rs"]
 mod cgen_helper;
@@ -46,6 +47,68 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             .build()
             .unwrap();
     }
+
+    {
+        use lrpar::unstable_api::UnstableApi;
+        // In this case we'll be building multiple grammars
+        //
+        // 1. Parse multi_start_rule.y into an AST
+        // 2. Clone the original and change the start rule.
+        // 3. Build a grammar for `multi_start_rule.y` unchanged.
+        // 4. Build the modified grammar.
+        let grammar_path = &std::env::current_dir().unwrap().join("src/multi_start.y");
+        let grammar_src = std::fs::read_to_string(grammar_path).unwrap();
+        let grammar_src_clone = grammar_src.clone();
+        let valid_ast = ASTWithValidityInfo::new(cfgrammar::yacc::YaccKind::Grmtools, &grammar_src);
+        eprintln!("rules {:?}", valid_ast.ast().rules);
+        let bstart_rule = valid_ast.ast().get_rule("BStart").unwrap().clone();
+        let modified_ast = valid_ast.clone_and_change_start_rule(bstart_rule).unwrap();
+        CTLexerBuilder::new()
+            .lrpar_config(move |ctp| {
+                ctp.grammar_ast(valid_ast.clone(), UnstableApi)
+                    .with_grammar_src(grammar_src.clone(), UnstableApi)
+                    .grammar_in_src_dir("multi_start.y")
+                    .unwrap()
+                    .mod_name("ast_unmodified_y")
+                    .output_path(format!(
+                        "{}/ast_unmodified.y.rs",
+                        std::env::var("OUT_DIR").unwrap()
+                    ))
+            })
+            .lexer_in_src_dir("multi_start.l")
+            .unwrap()
+            .output_path(format!(
+                "{}/ast_unmodified.l.rs",
+                std::env::var("OUT_DIR").unwrap()
+            ))
+            .mod_name("ast_unmodified_l")
+            .build()
+            .unwrap();
+        CTLexerBuilder::new()
+            .lrpar_config(move |ctp| {
+                ctp.grammar_ast(modified_ast.clone(), UnstableApi)
+                    .with_grammar_src(grammar_src_clone.clone(), UnstableApi)
+                    .grammar_in_src_dir("multi_start.y")
+                    .unwrap()
+                    .mod_name("ast_modified_y")
+                    .output_path(format!(
+                        "{}/ast_modified.y.rs",
+                        std::env::var("OUT_DIR").unwrap()
+                    ))
+                    // We still need to disable these because they are checked after ast validation.
+                    .warnings_are_errors(false)
+                    .show_warnings(false)
+            })
+            .lexer_in_src_dir("multi_start.l")
+            .unwrap()
+            .mod_name("ast_modified_l")
+            .output_path(format!(
+                "{}/ast_modified.l.rs",
+                std::env::var("OUT_DIR").unwrap()
+            ))
+            .build()
+            .unwrap();
+    }
     println!("cargo::rerun-if-changed=src/storaget.l");
     println!(
         "cargo::rerun-if-changed={}/storaget.l.rs",

lrpar/cttests/src/lib.rs

@@ -62,6 +62,12 @@ lrpar_mod!("storaget.y");
 lrlex_mod!("grmtools_section.l");
 lrpar_mod!("grmtools_section.y");
 
+lrlex_mod!("ast_unmodified.l");
+lrpar_mod!("ast_unmodified.y");
+
+lrlex_mod!("ast_modified.l");
+lrpar_mod!("ast_modified.y");
+
 #[test]
 fn multitypes() {
     let lexerdef = multitypes_l::lexerdef();
@@ -423,6 +429,26 @@ fn test_lex_flags() {
     }
 }
 
+#[test]
+fn ast_unmodified() {
+    let lexerdef = ast_unmodified_l::lexerdef();
+    let lexer = lexerdef.lexer("A: BBBB, CCCCC;");
+    match &ast_unmodified_y::parse(&lexer) {
+        (_, errs) if errs.is_empty() => (),
+        (_, e) => panic!("{:?}", e),
+    }
+}
+
+#[test]
+fn ast_modified() {
+    let lexerdef = ast_modified_l::lexerdef();
+    let lexer = lexerdef.lexer("CCCCC, BBBB");
+    match &ast_modified_y::parse(&lexer) {
+        (_, errs) if errs.is_empty() => (),
+        (_, e) => panic!("{:?}", e),
+    }
+}
+
 // Codegen failure tests
 #[cfg(test)]
 generate_codegen_fail_tests!("src/ctfails/*.test");

lrpar/cttests/src/multi_start.l

@@ -0,0 +1,8 @@
+%%
+A+ 'A'
+B+ 'B'
+C+ 'C'
+; ';'
+: ':'
+, ','
+[ \n\t] ;

lrpar/cttests/src/multi_start.y

@@ -0,0 +1,13 @@
+%grmtools{yacckind: Grmtools}
+%start AStart
+%token A B C
+%%
+
+AStart -> ()
+ : A ':' BStart ';' {()}
+ ;
+
+BStart -> () 
+ : B ',' C {()}
+ | C ',' B {()}
+ ;