Replace parse_generictree, parse_noaction, with a new parse_map fn.

Author: ratmice

lrlex/src/lib/ctbuilder.rs

@@ -548,7 +548,7 @@ where
                                 let input = fs::read_to_string(&path)?;
                                 let l: LRNonStreamingLexer<LexerTypesT> =
                                     closure_lexerdef.lexer(&input);
-                                for e in rtpb.parse_noaction(&l) {
+                                for e in rtpb.parse_map(&l, &|_| (), &|_, _| ()).1 {
                                     Err(format!("parsing {}: {}", path.display(), e))?
                                 }
                             }

lrpar/examples/calc_parsetree/src/main.rs

@@ -2,7 +2,7 @@ use std::io::{self, BufRead, Write};
 
 use cfgrammar::RIdx;
 use lrlex::{DefaultLexeme, lrlex_mod};
-use lrpar::{Lexeme, Node, lrpar_mod};
+use lrpar::{Lexeme, lrpar_mod};
 
 // Using `lrlex_mod!` brings the lexer for `calc.l` into scope. By default the module name will be
 // `calc_l` (i.e. the file name, minus any extensions, with a suffix of `_l`).
@@ -11,6 +11,8 @@ lrlex_mod!("calc.l");
 // `calc_y` (i.e. the file name, minus any extensions, with a suffix of `_y`).
 lrpar_mod!("calc.y");
 
+use calc_y::Node;
+
 fn main() {
     // Get the `LexerDef` for the `calc` language.
     let lexerdef = calc_l::lexerdef();

lrpar/examples/start_states/src/main.rs

@@ -2,7 +2,7 @@ use std::io::{self, BufRead, Write};
 
 use cfgrammar::RIdx;
 use lrlex::{DefaultLexeme, lrlex_mod};
-use lrpar::{Lexeme, Node, lrpar_mod};
+use lrpar::{Lexeme, lrpar_mod};
 
 // Using `lrlex_mod!` brings the lexer for `comment.l` into scope. By default the module name will be
 // `comment_l` (i.e. the file name, minus any extensions, with a suffix of `_l`).
@@ -11,6 +11,8 @@ lrlex_mod!("comment.l");
 // `comment_y` (i.e. the file name, minus any extensions, with a suffix of `_y`).
 lrpar_mod!("comment.y");
 
+use comment_y::Node;
+
 fn main() {
     // Get the `LexerDef` for the `comment` language.
     let lexerdef = comment_l::lexerdef();

lrpar/src/lib/ctbuilder.rs

@@ -522,7 +522,7 @@ where
     ///      the return type of the `%start` rule;
     ///    * or, if the `yacckind` was set to
     ///      `YaccKind::Original(YaccOriginalActionKind::GenericParseTree)`, it
-    ///      is [`crate::Node<StorageT>`].
+    ///      is [`modname::Node<StorageT>`].
     ///
     /// # Panics
     ///
@@ -897,7 +897,6 @@ where
         since = "0.11.0",
         note = "Please use grammar_path(), output_path(), build(), and token_map() instead"
     )]
-    #[allow(deprecated)]
     pub fn process_file<P, Q>(
         &mut self,
         inp: P,
@@ -958,6 +957,21 @@ where
             | YaccKind::Original(YaccOriginalActionKind::GenericParseTree) => None,
             _ => unreachable!(),
         };
+
+        let additional_decls =
+            if let Some(YaccKind::Original(YaccOriginalActionKind::GenericParseTree)) =
+                self.yacckind
+            {
+                // `lrpar::Node`` is deprecated within the lrpar crate, but not from within this module,
+                // Once it is removed from `lrpar`, we should move the declaration here entirely.
+                Some(quote! {
+                            #[allow(unused_imports)]
+                            pub use ::lrpar::parser::_deprecated_moved_::Node;
+                })
+            } else {
+                None
+            };
+
         let mod_name = format_ident!("{}", mod_name);
         let out_tokens = quote! {
             #visibility mod #mod_name {
@@ -969,6 +983,7 @@ where
                     #![deny(unsafe_code)]
                     #[allow(unused_imports)]
                     use super::*;
+                    #additional_decls
                     #parse_function
                     #rule_consts
                     #token_epp
@@ -1069,14 +1084,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 => {
@@ -1160,7 +1179,7 @@ where
                 }
             }
             YaccKind::Original(YaccOriginalActionKind::GenericParseTree) => quote! {
-                (::std::option::Option<::lrpar::Node<<#lexertypest as ::lrpar::LexerTypes>::LexemeT, #storaget>>,
+                (::std::option::Option<crate::Node<<#lexertypest as ::lrpar::LexerTypes>::LexemeT, #storaget>>,
                     ::std::vec::Vec<::lrpar::LexParseError<#storaget, #lexertypest>>)
             },
             YaccKind::Original(YaccOriginalActionKind::NoAction) => quote! {

lrpar/src/lib/mod.rs

@@ -208,10 +208,15 @@ pub mod test_utils;
 pub use crate::{
     ctbuilder::{CTParser, CTParserBuilder, RustEdition, Visibility},
     lex_api::{LexError, Lexeme, Lexer, LexerTypes, NonStreamingLexer},
-    parser::{LexParseError, Node, ParseError, ParseRepair, RTParserBuilder, RecoveryKind},
+    parser::{LexParseError, ParseError, ParseRepair, RTParserBuilder, RecoveryKind},
 };
 
+#[allow(deprecated)]
 pub use crate::parser::action_generictree;
+
+#[allow(deprecated)]
+pub use parser::Node;
+
 /// 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
 /// `lrpar_mod!("a/b/c.y")`.