Deprecate lrpar::Node, moving it into the mod of lrpar_mod!

Author: ratmice

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
     ///
@@ -958,6 +958,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 +984,7 @@ where
                     #![deny(unsafe_code)]
                     #[allow(unused_imports)]
                     use super::*;
+                    #additional_decls
                     #parse_function
                     #rule_consts
                     #token_epp
@@ -977,7 +993,7 @@ where
                 #[allow(unused_imports)]
                 pub use _parser_::*;
                 #[allow(unused_imports)]
-                use ::lrpar::{Lexeme, Node};
+                use ::lrpar::Lexeme;
             } // End of `mod #mod_name`
         };
         // Try and run a code formatter on the generated code.
@@ -1164,7 +1180,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,11 +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")`.

lrpar/src/lib/parser.rs

@@ -29,18 +29,29 @@ const RECOVERY_TIME_BUDGET: u64 = 60_000; // milliseconds
 #[cfg(not(test))]
 const RECOVERY_TIME_BUDGET: u64 = 500; // milliseconds
 
-/// A generic parse tree.
-#[derive(Debug, Clone, PartialEq)]
-pub enum Node<LexemeT: Lexeme<StorageT>, StorageT> {
-    /// Terminals store a single lexeme.
-    Term { lexeme: LexemeT },
-    /// Nonterminals reference a rule and have zero or more `Node`s as children.
-    Nonterm {
-        ridx: RIdx<StorageT>,
-        nodes: Vec<Node<LexemeT, StorageT>>,
-    },
+#[deprecated(
+    since = "0.14",
+    note = "Use the version of `Node` exported from your `lrpar_mod!`"
+)]
+pub type Node<T, S> = _deprecated_moved_::Node<T, S>;
+
+#[doc(hidden)]
+pub mod _deprecated_moved_ {
+    use super::*;
+    /// A generic parse tree.
+    #[derive(Debug, Clone, PartialEq)]
+    pub enum Node<LexemeT: Lexeme<StorageT>, StorageT> {
+        /// Terminals store a single lexeme.
+        Term { lexeme: LexemeT },
+        /// Nonterminals reference a rule and have zero or more `Node`s as children.
+        Nonterm {
+            ridx: RIdx<StorageT>,
+            nodes: Vec<Node<LexemeT, StorageT>>,
+        },
+    }
 }
 
+#[allow(deprecated)]
 impl<LexemeT: Lexeme<StorageT>, StorageT: 'static + PrimInt + Unsigned> Node<LexemeT, StorageT>
 where
     usize: AsPrimitive<StorageT>,
@@ -210,6 +221,7 @@ where
     since = "0.14",
     note = "Deprecated with `parse_generictree` there is no direct replacement, besides a custom action"
 )]
+#[allow(deprecated)]
 /// 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.
@@ -529,6 +541,7 @@ where
     /// Note that if `lexeme_prefix` is specified, `laidx` will still be incremented, and thus
     /// `end_laidx` *must* be set to `laidx + 1` in order that the parser doesn't skip the real
     /// lexeme at position `laidx`.
+    #[allow(deprecated)]
     pub(super) fn lr_cactus(
         &self,
         lexeme_prefix: Option<LexerTypesT::LexemeT>,
@@ -927,6 +940,7 @@ where
         since = "0.14",
         note = "Use `parse_map` to return a `lrpar::Node` instead"
     )]
+    #[allow(deprecated)]
     /// 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(
@@ -1082,6 +1096,7 @@ pub(crate) mod test {
         test_utils::{TestLexError, TestLexeme, TestLexerTypes},
     };
 
+    #[allow(deprecated)]
     pub(crate) fn do_parse<'input>(
         rcvry_kind: RecoveryKind,
         lexs: &str,
@@ -1101,6 +1116,7 @@ pub(crate) mod test {
         do_parse_with_costs(rcvry_kind, lexs, grms, input, &HashMap::new())
     }
 
+    #[allow(deprecated)]
     fn do_parse_with_costs<'input>(
         rcvry_kind: RecoveryKind,
         lexs: &str,

nimbleparse/src/main.rs

@@ -3,16 +3,18 @@ use cfgrammar::{
     header::{GrmtoolsSectionParser, Header, HeaderError, HeaderValue, Value},
     markmap::Entry,
     yacc::{YaccGrammar, YaccKind, YaccOriginalActionKind, ast::ASTWithValidityInfo},
+    RIdx, TIdx,
 };
 use getopts::Options;
 use lrlex::{DefaultLexerTypes, LRLexError, LRNonStreamingLexerDef, LexerDef};
 use lrpar::{
-    LexerTypes, Node,
+    LexerTypes,
     diagnostics::{DiagnosticFormatter, SpannedDiagnosticFormatter},
     parser::{RTParserBuilder, RecoveryKind},
+    Lexeme
 };
 use lrtable::{Minimiser, StateTable, from_yacc};
-use num_traits::AsPrimitive;
+use num_traits::{PrimInt, AsPrimitive, Unsigned};
 use num_traits::ToPrimitive as _;
 use std::{
     env,
@@ -22,8 +24,55 @@ use std::{
     io::Read,
     path::{Path, PathBuf},
     process,
+    fmt::Write,
 };
 
+
+/// A generic parse tree.
+#[derive(Debug, Clone, PartialEq)]
+pub enum Node<LexemeT: Lexeme<StorageT>, StorageT> {
+    /// Terminals store a single lexeme.
+    Term { lexeme: LexemeT },
+    /// Nonterminals reference a rule and have zero or more `Node`s as children.
+    Nonterm {
+        ridx: RIdx<StorageT>,
+        nodes: Vec<Node<LexemeT, StorageT>>,
+    },
+}
+
+#[allow(deprecated)]
+impl<LexemeT: Lexeme<StorageT>, StorageT: 'static + PrimInt + Unsigned> Node<LexemeT, StorageT>
+where
+    usize: AsPrimitive<StorageT>,
+{
+    /// Return a pretty-printed version of this node.
+    pub fn pp(&self, grm: &YaccGrammar<StorageT>, input: &str) -> String {
+        let mut st = vec![(0, self)]; // Stack of (indent level, node) pairs
+        let mut s = String::new();
+        while let Some((indent, e)) = st.pop() {
+            for _ in 0..indent {
+                s.push(' ');
+            }
+            match *e {
+                Node::Term { lexeme } => {
+                    let tidx = TIdx(lexeme.tok_id());
+                    let tn = grm.token_name(tidx).unwrap();
+                    let lt = &input[lexeme.span().start()..lexeme.span().end()];
+                    writeln!(s, "{} {}", tn, lt).ok();
+                }
+                Node::Nonterm { ridx, ref nodes } => {
+                    writeln!(s, "{}", grm.rule_name_str(ridx)).ok();
+                    for x in nodes.iter().rev() {
+                        st.push((indent + 1, x));
+                    }
+                }
+            }
+        }
+        s
+    }
+}
+
+
 const WARNING: &str = "[Warning]";
 const ERROR: &str = "[Error]";