Implement parse_generictree and parse_noaction using parse_map, and deprecate them

ratmice · ratmice · commit 60c486d4038f · 2025-06-12T00:46:36.000-07:00
diff --git a/lrlex/src/lib/ctbuilder.rs b/lrlex/src/lib/ctbuilder.rs
@@ -548,6 +548,7 @@ where
                                 let input = fs::read_to_string(&path)?;
                                 let l: LRNonStreamingLexer<LexerTypesT> =
                                     closure_lexerdef.lexer(&input);
+                                #[allow(deprecated)]
                                 for e in rtpb.parse_noaction(&l) {
                                     Err(format!("parsing {}: {}", path.display(), e))?
                                 }
diff --git a/lrpar/src/lib/ctbuilder.rs b/lrpar/src/lib/ctbuilder.rs
@@ -977,7 +977,7 @@ where
                 #[allow(unused_imports)]
                 pub use _parser_::*;
                 #[allow(unused_imports)]
-                use ::lrpar::Lexeme;
+                use ::lrpar::{Lexeme, Node};
             } // End of `mod #mod_name`
         };
         // Try and run a code formatter on the generated code.
@@ -1069,14 +1069,18 @@ where
                 quote! {
                     ::lrpar::RTParserBuilder::new(&grm, &stable)
                         .recoverer(#recoverer)
-                        .parse_generictree(lexer)
+                        .parse_map(
+                            lexer,
+                            &|lexeme| Node::Term{lexeme},
+                            &|ridx, nodes| Node::Nonterm{ridx, nodes}
+                        )
                 }
             }
             YaccKind::Original(YaccOriginalActionKind::NoAction) => {
                 quote! {
                     ::lrpar::RTParserBuilder::new(&grm, &stable)
                         .recoverer(#recoverer)
-                        .parse_noaction(lexer)
+                        .parse_map(lexer, &|_| (), &|_, _| ()).1
                 }
             }
             YaccKind::Original(YaccOriginalActionKind::UserAction) | YaccKind::Grmtools => {
diff --git a/lrpar/src/lib/mod.rs b/lrpar/src/lib/mod.rs
@@ -211,6 +211,7 @@ pub use crate::{
     parser::{LexParseError, Node, ParseError, ParseRepair, RTParserBuilder, RecoveryKind},
 };
 
+#[allow(deprecated)]
 pub use crate::parser::action_generictree;
 /// A convenience macro for including statically compiled `.y` files. A file `src/a/b/c.y`
 /// processed by [CTParserBuilder::grammar_in_src_dir] can then be used in a crate with
diff --git a/lrpar/src/lib/parser.rs b/lrpar/src/lib/parser.rs
@@ -206,61 +206,10 @@ where
     fnonterm(ridx, nodes)
 }
 
-impl<
-    'a,
-    'b: 'a,
-    'input: 'b,
-    StorageT: 'static + Debug + Hash + PrimInt + Unsigned,
-    LexerTypesT: LexerTypes<StorageT = StorageT>,
-> Parser<'a, 'b, 'input, StorageT, LexerTypesT, Node<LexerTypesT::LexemeT, StorageT>, ()>
-where
-    usize: AsPrimitive<StorageT>,
-{
-    fn parse_generictree(
-        rcvry_kind: RecoveryKind,
-        grm: &YaccGrammar<StorageT>,
-        token_cost: TokenCostFn<'a, StorageT>,
-        stable: &StateTable<StorageT>,
-        lexer: &'b dyn NonStreamingLexer<'input, LexerTypesT>,
-        lexemes: Vec<LexerTypesT::LexemeT>,
-    ) -> (
-        Option<Node<LexerTypesT::LexemeT, StorageT>>,
-        Vec<LexParseError<StorageT, LexerTypesT>>,
-    ) {
-        for tidx in grm.iter_tidxs() {
-            assert!(token_cost(tidx) > 0);
-        }
-        let mut actions: Vec<
-            ActionFn<
-                'a,
-                'b,
-                'input,
-                StorageT,
-                LexerTypesT,
-                Node<LexerTypesT::LexemeT, StorageT>,
-                (),
-            >,
-        > = Vec::new();
-        actions.resize(usize::from(grm.prods_len()), &action_generictree);
-        let psr = Parser {
-            rcvry_kind,
-            grm,
-            token_cost: Box::new(token_cost),
-            stable,
-            lexer,
-            lexemes,
-            actions: actions.as_slice(),
-            param: (),
-        };
-        let mut pstack = vec![stable.start_state()];
-        let mut astack = Vec::new();
-        let mut errors = Vec::new();
-        let mut spans = Vec::new();
-        let accpt = psr.lr(0, &mut pstack, &mut astack, &mut errors, &mut spans);
-        (accpt, errors)
-    }
-}
-
+#[deprecated(
+    since = "0.14",
+    note = "Deprecated with `parse_generictree` there is no direct replacement, besides a custom action"
+)]
 /// The action which implements [`cfgrammar::yacc::YaccOriginalActionKind::GenericParseTree`].
 /// Usually you should just use the action kind directly. But you can also call this from
 /// within a custom action to return a generic parse tree with custom behavior.
@@ -285,57 +234,6 @@ where
     Node::Nonterm { ridx, nodes }
 }
 
-impl<
-    'a,
-    'b: 'a,
-    'input: 'b,
-    StorageT: 'static + Debug + Hash + PrimInt + Unsigned,
-    LexerTypesT: LexerTypes<StorageT = StorageT>,
-> Parser<'a, 'b, 'input, StorageT, LexerTypesT, (), ()>
-where
-    usize: AsPrimitive<StorageT>,
-{
-    fn parse_noaction(
-        rcvry_kind: RecoveryKind,
-        grm: &YaccGrammar<StorageT>,
-        token_cost: TokenCostFn<'a, StorageT>,
-        stable: &StateTable<StorageT>,
-        lexer: &'b dyn NonStreamingLexer<'input, LexerTypesT>,
-        lexemes: Vec<LexerTypesT::LexemeT>,
-    ) -> Vec<LexParseError<StorageT, LexerTypesT>> {
-        for tidx in grm.iter_tidxs() {
-            assert!(token_cost(tidx) > 0);
-        }
-        let mut actions: Vec<ActionFn<'a, 'b, 'input, StorageT, LexerTypesT, (), ()>> = Vec::new();
-        actions.resize(usize::from(grm.prods_len()), &Parser::noaction);
-        let psr = Parser {
-            rcvry_kind,
-            grm,
-            token_cost: Box::new(token_cost),
-            stable,
-            lexer,
-            lexemes,
-            actions: actions.as_slice(),
-            param: (),
-        };
-        let mut pstack = vec![stable.start_state()];
-        let mut astack = Vec::new();
-        let mut errors = Vec::new();
-        let mut spans = Vec::new();
-        psr.lr(0, &mut pstack, &mut astack, &mut errors, &mut spans);
-        errors
-    }
-
-    fn noaction(
-        _ridx: RIdx<StorageT>,
-        _lexer: &dyn NonStreamingLexer<LexerTypesT>,
-        _span: Span,
-        _astack: vec::Drain<AStackType<LexerTypesT::LexemeT, ()>>,
-        _param: (),
-    ) {
-    }
-}
-
 impl<
     'a,
     'b: 'a,
@@ -1025,6 +923,10 @@ where
         self
     }
 
+    #[deprecated(
+        since = "0.14",
+        note = "Use `parse_map` to return a `lrpar::Node` instead"
+    )]
     /// Parse input, and (if possible) return a generic parse tree. See the arguments for
     /// [`parse_actions`](#method.parse_actions) for more details about the return value.
     pub fn parse_generictree(
@@ -1034,21 +936,9 @@ where
         Option<Node<LexerTypesT::LexemeT, StorageT>>,
         Vec<LexParseError<StorageT, LexerTypesT>>,
     ) {
-        let mut lexemes = vec![];
-        for e in lexer.iter().collect::<Vec<_>>() {
-            match e {
-                Ok(l) => lexemes.push(l),
-                Err(e) => return (None, vec![e.into()]),
-            }
-        }
-        Parser::<StorageT, LexerTypesT, Node<LexerTypesT::LexemeT, StorageT>, ()>::parse_generictree(
-            self.recoverer,
-            self.grm,
-            self.term_costs,
-            self.stable,
-            lexer,
-            lexemes,
-        )
+        self.parse_map(lexer, &|lexeme| Node::Term { lexeme }, &|ridx, nodes| {
+            Node::Nonterm { ridx, nodes }
+        })
     }
 
     /// Parse input, and (if possible) return a generic parse tree. See the arguments for
@@ -1086,27 +976,14 @@ where
         )
     }
 
+    #[deprecated(since = "0.14", note = "Use `parse_map` instead")]
     /// Parse input, returning any errors found. See the arguments for
     /// [`parse_actions`](#method.parse_actions) for more details about the return value.
     pub fn parse_noaction(
         &self,
         lexer: &dyn NonStreamingLexer<LexerTypesT>,
     ) -> Vec<LexParseError<StorageT, LexerTypesT>> {
-        let mut lexemes = vec![];
-        for e in lexer.iter().collect::<Vec<_>>() {
-            match e {
-                Ok(l) => lexemes.push(l),
-                Err(e) => return vec![e.into()],
-            }
-        }
-        Parser::<StorageT, LexerTypesT, (), ()>::parse_noaction(
-            self.recoverer,
-            self.grm,
-            self.term_costs,
-            self.stable,
-            lexer,
-            lexemes,
-        )
+        self.parse_map(lexer, &|_| (), &|_, _| ()).1
     }
 
     /// Parse input, execute actions, and return the associated value (if possible) and/or any
@@ -1259,6 +1136,7 @@ pub(crate) mod test {
             .iter()
             .map(|(k, v)| (grm.token_idx(k).unwrap(), v))
             .collect::<HashMap<_, _>>();
+        #[allow(deprecated)]
         let (r, errs) = RTParserBuilder::new(&grm, &stable)
             .recoverer(rcvry_kind)
             .term_costs(&|tidx| **costs_tidx.get(&tidx).unwrap_or(&&1))
@@ -1561,18 +1439,6 @@ Factor : 'INT';";
 ",
         );
 
-        assert_eq!(
-            rt_parser.parse_generictree(&lexer).0.unwrap(),
-            rt_parser
-                .parse_map(
-                    &lexer,
-                    &|lexeme: TestLexeme| { Node::Term { lexeme } },
-                    &|ridx, nodes| { Node::Nonterm { ridx, nodes } },
-                )
-                .0
-                .unwrap()
-        );
-
         let expected_parse_map = {
             use TestParseMap::*;
             NonTerm(
diff --git a/nimbleparse/src/main.rs b/nimbleparse/src/main.rs
@@ -7,7 +7,7 @@ use cfgrammar::{
 use getopts::Options;
 use lrlex::{DefaultLexerTypes, LRLexError, LRNonStreamingLexerDef, LexerDef};
 use lrpar::{
-    LexerTypes,
+    LexerTypes, Node,
     diagnostics::{DiagnosticFormatter, SpannedDiagnosticFormatter},
     parser::{RTParserBuilder, RecoveryKind},
 };
@@ -479,7 +479,9 @@ where
     fn parse_string(self, input_path: PathBuf, input_src: String) -> Result<(), NimbleparseError> {
         let lexer = self.lexerdef.lexer(&input_src);
         let pb = RTParserBuilder::new(&self.grm, &self.stable).recoverer(self.recoverykind);
-        let (pt, errs) = pb.parse_generictree(&lexer);
+        let (pt, errs) = pb.parse_map(&lexer, &|lexeme| Node::Term { lexeme }, &|ridx, nodes| {
+            Node::Nonterm { ridx, nodes }
+        });
         match pt {
             Some(pt) => println!("{}", pt.pp(&self.grm, &input_src)),
             None => println!("Unable to repair input sufficiently to produce parse tree.\n"),
@@ -559,7 +561,10 @@ where
         for input_path in input_paths {
             let input = read_file(&input_path);
             let lexer = self.lexerdef.lexer(&input);
-            let (pt, errs) = pb.parse_generictree(&lexer);
+            let (pt, errs) =
+                pb.parse_map(&lexer, &|lexeme| Node::Term { lexeme }, &|ridx, nodes| {
+                    Node::Nonterm { ridx, nodes }
+                });
             if errs.is_empty() && pt.is_some() {
                 // Since we're parsing many files, don't output all of their parse trees, just print the file name.
                 println!("parsed: {}", input_path.display())

Original file line number	Diff line number	Diff line change
`@@ -548,6 +548,7 @@ where`
`548`	`548`	`let input = fs::read_to_string(&path)?;`
`549`	`549`	`let l: LRNonStreamingLexer<LexerTypesT> =`
`550`	`550`	`closure_lexerdef.lexer(&input);`
	`551`	`+ #[allow(deprecated)]`
`551`	`552`	`for e in rtpb.parse_noaction(&l) {`
`552`	`553`	`Err(format!("parsing {}: {}", path.display(), e))?`
`553`	`554`	`}`