fix minor bugs:

    fix(parser) error 'use of moved value' for same mapto name in group pattern
    fix(core) assert macro to debug_asert macro
    fix(ruety_lr, core) `shift` predefined variable's default value is whether the shift action is possible.
    fix(parser) surpress warnings for generated `Stack`
    fix(parser) add explicit typename to __rustylr_terminals
    remove(parser) don't print expected tokens on grammar parse error
    fix lib.rs doc comments typo
    fix(core,parser) remove rule_id
    fix `%lalr` was not present in QuickReference

Author: ehwan

SYNTAX.md

@@ -14,6 +14,7 @@
  - [`%left`, `%right`](#reduce-type-optional)
  - [`%err`, `%error`](#error-type-optional)
  - [`%glr`](#glr-parser-generation)
+ - [`%lalr`](#lalr-parser-generation)
 
 
 ---

example/lrtest/src/main.rs

@@ -5,24 +5,19 @@ fn main() {
 
     let _ = grammar.set_reduce_type('0', ReduceType::Right);
 
-    grammar.add_rule(
-        "Num",
-        vec![Token::NonTerm("Digit"), Token::NonTerm("Num")],
-        0,
-    );
-    grammar.add_rule("Num", vec![Token::NonTerm("Digit")], 0);
+    grammar.add_rule("Num", vec![Token::NonTerm("Digit"), Token::NonTerm("Num")]);
+    grammar.add_rule("Num", vec![Token::NonTerm("Digit")]);
 
-    grammar.add_rule("Digit", vec![Token::Term('0')], 0);
+    grammar.add_rule("Digit", vec![Token::Term('0')]);
 
-    grammar.add_rule("Token", vec![Token::NonTerm("Num")], 0);
+    grammar.add_rule("Token", vec![Token::NonTerm("Num")]);
     grammar.add_rule(
         "Tokens",
         vec![Token::NonTerm("Token"), Token::NonTerm("Tokens")],
-        0,
     );
-    grammar.add_rule("Tokens", vec![Token::NonTerm("Token")], 0);
+    grammar.add_rule("Tokens", vec![Token::NonTerm("Token")]);
 
-    grammar.add_rule("Aug", vec![Token::NonTerm("Tokens"), Token::Term('\0')], 0);
+    grammar.add_rule("Aug", vec![Token::NonTerm("Tokens"), Token::Term('\0')]);
 
     match grammar.build("Aug") {
         Ok(_) => {

rusty_lr/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rusty_lr"
-version = "3.1.0"
+version = "3.1.1"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 description = "GLR, LR(1) and LALR(1) parser generator with custom reduce action"
@@ -10,9 +10,9 @@ keywords = ["parser", "bison", "lr", "glr", "compiler"]
 categories = ["parsing", "compilers", "parser-implementations"]
 
 [dependencies]
-rusty_lr_core = { version = "3.1.0", path = "../rusty_lr_core" }
-rusty_lr_derive = { version = "2.1.0", path = "../rusty_lr_derive", optional = true }
-rusty_lr_buildscript = { version = "0.19.0", path = "../rusty_lr_buildscript", optional = true }
+rusty_lr_core = { version = "3.2.0", path = "../rusty_lr_core" }
+rusty_lr_derive = { version = "2.2.0", path = "../rusty_lr_derive", optional = true }
+rusty_lr_buildscript = { version = "0.20.0", path = "../rusty_lr_buildscript", optional = true }
 
 [features]
 default = ["derive"]

rusty_lr/src/lib.rs

@@ -83,7 +83,7 @@
 //! The `Context` struct has the following functions:
 //!  - `feed(&mut self, &Parser, TerminalType, &mut UserData) -> Result<(), ParseError>` : feed token to the parser
 //!
-//! Node that `UserData` is `()` by default, unless it is defined by [`%userdata`](#userdata-type-optional) directive.
+//! Note that `UserData` is `()` by default, unless it is defined by [`%userdata`](#userdata-type-optional) directive.
 //! All you need to do is to call `new()` to generate the parser, a context.
 //! Then, you can feed the input sequence one by one with `feed()` function.
 //! Once the input sequence is feeded (including `eof` token), without errors,
@@ -267,6 +267,7 @@
 //!  - [`%left`, `%right`](#reduce-type-optional)
 //!  - [`%err`, `%error`](#error-type-optional)
 //!  - [`%glr`](#glr-parser-generation)
+//!  - [`%lalr`](#lalr-parser-generation)
 //!
 //!
 //! ---
@@ -374,7 +375,8 @@
 //! **predefined variables** can be used in `ReduceAction`:
 //!  - `data` ( `&mut UserData` ) : userdata passed to the `feed()` function.
 //!  - `lookahead` ( `&Term` ) : lookahead token that caused the reduce action.
-//!  - `shift` ( `&mut bool` ) : revoke the shift action if set to `false`. See [Resolving Ambiguities](#resolving-ambiguities) section.
+//!  - `shift` ( `&mut bool` ) : revoke the shift action if set to `false`. Default value is whether the shift action is possible.
+//!     See [Resolving Ambiguities](#resolving-ambiguities) section.
 //!
 //! To access the data of each token, you can directly use the name of the token as a variable.
 //!  - For non-terminal symbols, the type of variable is `RuleType`.

rusty_lr_buildscript/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rusty_lr_buildscript"
-version = "0.19.0"
+version = "0.20.0"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 description = "buildscipt tools for rusty_lr"
@@ -11,8 +11,8 @@ categories = ["parsing"]
 
 
 [dependencies]
-rusty_lr_parser = { version = "3.22.0", path = "../rusty_lr_parser" }
-rusty_lr_core = { version = "3.1.0", path = "../rusty_lr_core", features = [
+rusty_lr_parser = { version = "3.23.0", path = "../rusty_lr_parser" }
+rusty_lr_core = { version = "3.2.0", path = "../rusty_lr_core", features = [
   "builder",
 ] }
 codespan-reporting = "0.11"

rusty_lr_core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rusty_lr_core"
-version = "3.1.0"
+version = "3.2.0"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 description = "core library for rusty_lr"

rusty_lr_core/src/builder/grammar.rs

@@ -49,29 +49,28 @@ impl<Term, NonTerm> Grammar<Term, NonTerm> {
     }
 
     /// add new production rule for given nonterminal 'name'
-    pub fn add_rule(&mut self, name: NonTerm, rule: Vec<Token<Term, NonTerm>>, id: usize) -> usize
+    pub fn add_rule(&mut self, name: NonTerm, rule: Vec<Token<Term, NonTerm>>) -> usize
     where
         NonTerm: Clone + Hash + Eq,
     {
         let index = self.rules.len();
         self.rules_map.entry(name.clone()).or_default().push(index);
-        let rule = ProductionRule { name, rule, id };
+        let rule = ProductionRule { name, rule };
         self.rules.push((rule, None));
         index
     }
     pub fn add_rule_with_lookaheads(
         &mut self,
         name: NonTerm,
         rule: Vec<Token<Term, NonTerm>>,
-        id: usize,
         lookaheads: BTreeSet<Term>,
     ) -> usize
     where
         NonTerm: Clone + Hash + Eq,
     {
         let index = self.rules.len();
         self.rules_map.entry(name.clone()).or_default().push(index);
-        let rule = ProductionRule { name, rule, id };
+        let rule = ProductionRule { name, rule };
         self.rules.push((rule, Some(lookaheads)));
         index
     }

rusty_lr_core/src/glr/mod.rs

@@ -69,6 +69,7 @@ where
                             Rc::clone(&node),
                             context,
                             &term,
+                            next_term_shift_state.is_some(),
                             userdata,
                         );
                     }
@@ -79,6 +80,7 @@ where
                             Rc::clone(&node),
                             context,
                             &term,
+                            true,
                             userdata,
                         );
                         if shift_for_this_node {
@@ -97,7 +99,15 @@ where
                                 .push(Rc::new(next_node));
                         }
                     } else {
-                        reduce(parser, reduce_rules[0], node, context, &term, userdata);
+                        reduce(
+                            parser,
+                            reduce_rules[0],
+                            node,
+                            context,
+                            &term,
+                            false,
+                            userdata,
+                        );
                     }
                 }
             } else if let Some(next_term_shift_state) = next_term_shift_state {
@@ -216,6 +226,7 @@ fn reduce<P: Parser, Data: NodeData<Term = P::Term, NonTerm = P::NonTerm> + Clon
     node: Rc<Node<Data>>,
     context: &mut Context<Data>,
     term: &P::Term,
+    has_shift: bool,
     userdata: &mut Data::UserData,
 ) -> bool
 where
@@ -230,7 +241,7 @@ where
     #[cfg(not(feature = "tree"))]
     let parent = data_extracted;
 
-    let mut do_shift = true;
+    let mut do_shift = has_shift;
     match Data::new_nonterm(
         reduce_rule,
         &mut context.reduce_args,

rusty_lr_core/src/glr/node.rs

@@ -83,14 +83,14 @@ impl<Data: NodeData> Node<Data> {
     /// This function should not be called from root node.
     #[cfg(feature = "tree")]
     pub fn to_tree(&self) -> &Tree<Data::Term, Data::NonTerm> {
-        assert!(self.parent.is_some());
+        debug_assert!(self.parent.is_some());
         self.tree.as_ref().unwrap()
     }
     /// Get token tree for this node.
     /// This function should not be called from root node.
     #[cfg(feature = "tree")]
     pub fn into_tree(self) -> Tree<Data::Term, Data::NonTerm> {
-        assert!(self.parent.is_some());
+        debug_assert!(self.parent.is_some());
         self.tree.unwrap()
     }
 
@@ -113,13 +113,13 @@ impl<Data: NodeData> Node<Data> {
     /// Get data for this node.
     /// This function should not be called from root node.
     pub fn to_data(&self) -> &Data {
-        assert!(self.parent.is_some());
+        debug_assert!(self.parent.is_some());
         self.data.as_ref().unwrap()
     }
     /// Get data for this node.
     /// This function should not be called from root node.
     pub fn into_data(self) -> Data {
-        assert!(self.parent.is_some());
+        debug_assert!(self.parent.is_some());
         self.data.unwrap()
     }
     /// Get list of data from root to this node.

rusty_lr_core/src/rule.rs

@@ -30,8 +30,6 @@ impl Display for ReduceType {
 pub struct ProductionRule<Term, NonTerm> {
     pub name: NonTerm,
     pub rule: Vec<Token<Term, NonTerm>>,
-    /// id user assigned to this rule
-    pub id: usize,
 }
 impl<Term: Display, NonTerm: Display> Display for ProductionRule<Term, NonTerm> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -76,7 +74,6 @@ impl<Term, NonTerm> ProductionRule<Term, NonTerm> {
                     Token::NonTerm(nonterm) => Token::NonTerm(nonterm_map(nonterm)),
                 })
                 .collect(),
-            id: self.id,
         }
     }
 }

rusty_lr_derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rusty_lr_derive"
-version = "2.1.0"
+version = "2.2.0"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 description = "proc-macro definitions for rusty_lr"
@@ -14,7 +14,7 @@ proc-macro = true
 
 [dependencies]
 proc-macro2 = "1.0.86"
-rusty_lr_parser = { version = "3.22.0", path = "../rusty_lr_parser" }
+rusty_lr_parser = { version = "3.23.0", path = "../rusty_lr_parser" }
 
 
 [features]

rusty_lr_executable/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rustylr"
-version = "1.0.1"
+version = "1.0.2"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 description = "executable for rusty_lr"
@@ -11,6 +11,6 @@ categories = ["parsing"]
 
 [dependencies]
 clap = { version = "4.5.7", features = ["derive"] }
-rusty_lr_buildscript = { version = "0.19.0", path = "../rusty_lr_buildscript", features = [
+rusty_lr_buildscript = { version = "0.20.0", path = "../rusty_lr_buildscript", features = [
   "fxhash",
 ] }

rusty_lr_parser/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rusty_lr_parser"
-version = "3.22.0"
+version = "3.23.0"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 description = "macro line parser for rusty_lr"
@@ -12,7 +12,7 @@ categories = ["parsing"]
 [dependencies]
 proc-macro2 = "1.0.86"
 quote = "1.0"
-rusty_lr_core = { version = "3.1.0", path = "../rusty_lr_core", features = [
+rusty_lr_core = { version = "3.2.0", path = "../rusty_lr_core", features = [
   "builder",
 ] }
 

rusty_lr_parser/src/emit.rs

@@ -288,7 +288,6 @@ impl Grammar {
         // =====================================================================
         let mut tokens_initializer = TokenStream::new();
         let mut rule_names_initializer = TokenStream::new();
-        let mut rule_id_initializer = TokenStream::new();
 
         {
             for rule in rules.into_iter() {
@@ -314,10 +313,6 @@ impl Grammar {
                 rule_names_initializer.extend(quote! {
                     #nonterminals_enum_name::#name,
                 });
-                let id = Literal::usize_unsuffixed(rule.id);
-                rule_id_initializer.extend(quote! {
-                    #id,
-                });
             }
         };
 
@@ -491,29 +486,20 @@ impl Grammar {
             }
         };
 
-        let rule_id_typename = integer_typename(
-            self.nonterminals
-                .iter()
-                .map(|nonterm| nonterm.rules.iter().map(|rule| rule.id).max().unwrap())
-                .max()
-                .unwrap()
-                + 1,
-        );
         let reduce_terminals_cache_typename = integer_typename(reduce_terminals_cache_count);
         let ruleset0_cache_typename = integer_typename(ruleset0_cache_count);
 
+        let token_typename = &self.token_typename;
+
         Ok(quote! {
-            let __rustylr_terminals = vec![#comma_separated_terminals];
+            let __rustylr_terminals:Vec<#token_typename> = vec![#comma_separated_terminals];
             const RUSTYLR_RULES_TOKENS: &[&[#module_prefix::Token<#terminal_index_typename, #nonterminals_enum_name>]] = &[#tokens_initializer];
             const RUSTYLR_RULES_NAME: &[#nonterminals_enum_name] = &[#rule_names_initializer];
-            const RUSTYLR_RULES_ID: &[#rule_id_typename] = &[#rule_id_initializer];
 
             let rules: Vec<#rule_typename> = RUSTYLR_RULES_NAME.iter().zip(
-                RUSTYLR_RULES_TOKENS.iter().zip(
-                    RUSTYLR_RULES_ID.iter()
-                )
+                RUSTYLR_RULES_TOKENS.iter()
             ).map(
-                | (name, (tokens, id)) | {
+                | (name, tokens) | {
                     #rule_typename {
                         name: *name,
                         rule: tokens.iter().map(
@@ -524,7 +510,6 @@ impl Grammar {
                                 }
                             }
                         ).collect(),
-                        id: *id as usize,
                     }
                 }
             ).collect();
@@ -800,15 +785,15 @@ impl Grammar {
         /// struct that holds internal parser data,
         /// including data stack for each non-terminal,
         /// and state stack for DFA
-        #[allow(unused_braces, unused_parens, unused_variables, non_snake_case, unused_mut)]
+        #[allow(unused_braces, unused_parens, unused_variables, non_snake_case, unused_mut, non_snake_case, non_camel_case_types)]
         pub struct #stack_struct_name {
             #stack_def_streams
         }
-        #[allow(unused_braces, unused_parens, unused_variables, non_snake_case, unused_mut, dead_code)]
+        #[allow(unused_braces, unused_parens, unused_variables, non_snake_case, unused_mut, non_snake_case, non_camel_case_types, dead_code)]
         impl #stack_struct_name {
             #fn_reduce_for_each_rule_stream
         }
-        #[allow(unused_braces, unused_parens, unused_variables, non_snake_case, unused_mut, dead_code)]
+        #[allow(unused_braces, unused_parens, unused_variables, non_snake_case, unused_mut, non_snake_case, non_camel_case_types, dead_code)]
         impl #module_prefix::lr::Stack for #stack_struct_name {
             type Term = #token_typename;
             type NonTerm = #nonterminals_enum_name;
@@ -844,7 +829,7 @@ impl Grammar {
         }
 
         /// struct that holds parser data, DFA tables
-        #[allow(unused_braces, unused_parens, unused_variables, non_snake_case, unused_mut)]
+        #[allow(unused_braces, unused_parens, unused_variables, non_snake_case, unused_mut, dead_code)]
         pub struct #parser_struct_name {
             /// production rules
             pub rules: Vec<#rule_typename>,
@@ -863,7 +848,7 @@ impl Grammar {
             }
         }
 
-        #[allow(unused_braces, unused_parens, unused_variables, non_snake_case, unused_mut)]
+        #[allow(unused_braces, unused_parens, unused_variables, non_snake_case, unused_mut, dead_code)]
         impl #parser_struct_name {
             /// Create new parser instance.
             /// Parser can be reused with different context, for multiple parsing.