lrama 0.6.9 → 0.6.11

data/parser.y

@@ -1,14 +1,12 @@
 class Lrama::Parser
   expect 0
+  error_on_expect_mismatch
 
   token C_DECLARATION CHARACTER IDENT_COLON IDENTIFIER INTEGER STRING TAG
 
 rule
 
-  input: prologue_declarations bison_declarations "%%" grammar epilogue_opt
-
-  prologue_declarations: # empty
-                       | prologue_declarations prologue_declaration
+  input: prologue_declaration* bison_declaration* "%%" rules_or_grammar_declaration+ epilogue_declaration?
 
   prologue_declaration: "%{"
                           {
@@ -25,116 +23,66 @@ rule
                           }
                       | "%require" STRING
 
-  bison_declarations: /* empty */ { result = "" }
-                    | bison_declarations bison_declaration
-
   bison_declaration: grammar_declaration
-                   | rule_declaration
-                   | inline_declaration
                    | "%expect" INTEGER { @grammar.expect = val[1] }
                    | "%define" variable value
-                   | "%param" params
-                   | "%lex-param" params
+                   | "%param" param+
+                   | "%lex-param" param+
                        {
                          val[1].each {|token|
                            @grammar.lex_param = Grammar::Code::NoReferenceCode.new(type: :lex_param, token_code: token).token_code.s_value
                          }
                        }
-                   | "%parse-param" params
+                   | "%parse-param" param+
                        {
                          val[1].each {|token|
                            @grammar.parse_param = Grammar::Code::NoReferenceCode.new(type: :parse_param, token_code: token).token_code.s_value
                          }
                        }
-                   | "%code" IDENTIFIER "{"
-                       {
-                         begin_c_declaration("}")
-                       }
-                     C_DECLARATION
-                       {
-                         end_c_declaration
-                       }
-                     "}"
+                   | "%code" IDENTIFIER param
                        {
-                         @grammar.add_percent_code(id: val[1], code: val[4])
+                         @grammar.add_percent_code(id: val[1], code: val[2])
                        }
-                   | "%initial-action" "{"
+                   | "%initial-action" param
                        {
-                         begin_c_declaration("}")
-                       }
-                     C_DECLARATION
-                       {
-                         end_c_declaration
-                       }
-                     "}"
-                       {
-                         @grammar.initial_action = Grammar::Code::InitialActionCode.new(type: :initial_action, token_code: val[3])
+                         @grammar.initial_action = Grammar::Code::InitialActionCode.new(type: :initial_action, token_code: val[1])
                        }
                    | "%no-stdlib" { @grammar.no_stdlib = true }
-                   | ";"
+                   | "%locations" { @grammar.locations = true }
+                   | bison_declaration ";"
 
-  grammar_declaration: "%union" "{"
-                         {
-                           begin_c_declaration("}")
-                         }
-                       C_DECLARATION
-                         {
-                           end_c_declaration
-                         }
-                       "}"
+  grammar_declaration: "%union" param
                          {
                            @grammar.set_union(
-                             Grammar::Code::NoReferenceCode.new(type: :union, token_code: val[3]),
-                             val[3].line
+                             Grammar::Code::NoReferenceCode.new(type: :union, token_code: val[1]),
+                             val[1].line
                            )
                          }
                      | symbol_declaration
-                     | "%destructor" "{"
-                         {
-                           begin_c_declaration("}")
-                         }
-                       C_DECLARATION
-                         {
-                           end_c_declaration
-                         }
-                       "}" generic_symlist
+                     | rule_declaration
+                     | inline_declaration
+                     | "%destructor" param (symbol | TAG)+
                          {
                            @grammar.add_destructor(
-                             ident_or_tags: val[6],
-                             token_code: val[3],
-                             lineno: val[3].line
+                             ident_or_tags: val[2].flatten,
+                             token_code: val[1],
+                             lineno: val[1].line
                            )
                          }
-                     | "%printer" "{"
-                         {
-                           begin_c_declaration("}")
-                         }
-                       C_DECLARATION
-                         {
-                           end_c_declaration
-                         }
-                       "}" generic_symlist
+                     | "%printer" param (symbol | TAG)+
                          {
                            @grammar.add_printer(
-                             ident_or_tags: val[6],
-                             token_code: val[3],
-                             lineno: val[3].line
+                             ident_or_tags: val[2].flatten,
+                             token_code: val[1],
+                             lineno: val[1].line
                            )
                          }
-                     | "%error-token" "{"
-                         {
-                           begin_c_declaration("}")
-                         }
-                       C_DECLARATION
-                         {
-                           end_c_declaration
-                         }
-                       "}" generic_symlist
+                     | "%error-token" param (symbol | TAG)+
                          {
                            @grammar.add_error_token(
-                             ident_or_tags: val[6],
-                             token_code: val[3],
-                             lineno: val[3].line
+                             ident_or_tags: val[2].flatten,
+                             token_code: val[1],
+                             lineno: val[1].line
                            )
                          }
                      | "%after-shift" IDENTIFIER
@@ -167,6 +115,18 @@ rule
                             }
                           }
                         }
+                    | "%nterm" symbol_declarations
+                        {
+                          val[1].each {|hash|
+                            hash[:tokens].each {|id|
+                              if @grammar.find_term_by_s_value(id.s_value)
+                                on_action_error("symbol #{id.s_value} redeclared as a nonterminal", id)
+                              else
+                                @grammar.add_type(id: id, tag: hash[:tag])
+                              end
+                            }
+                          }
+                        }
                     | "%left" token_declarations_for_precedence
                         {
                           val[1].each {|hash|
@@ -208,41 +168,37 @@ rule
                           @precedence_number += 1
                         }
 
-  token_declarations: token_declaration_list
-                        {
-                          val[0].each {|token_declaration|
-                            @grammar.add_term(id: token_declaration[0], alias_name: token_declaration[2], token_id: token_declaration[1], tag: nil, replace: true)
-                          }
-                        }
-                    | TAG token_declaration_list
+  token_declarations: TAG? token_declaration+
                         {
                           val[1].each {|token_declaration|
                             @grammar.add_term(id: token_declaration[0], alias_name: token_declaration[2], token_id: token_declaration[1], tag: val[0], replace: true)
                           }
                         }
-                    | token_declarations TAG token_declaration_list
+                    | token_declarations TAG token_declaration+
                         {
                           val[2].each {|token_declaration|
                             @grammar.add_term(id: token_declaration[0], alias_name: token_declaration[2], token_id: token_declaration[1], tag: val[1], replace: true)
                           }
                         }
 
-  token_declaration_list: token_declaration { result = [val[0]] }
-                        | token_declaration_list token_declaration { result = val[0].append(val[1]) }
-
-  token_declaration: id int_opt alias { result = val }
+  token_declaration: id INTEGER? alias { result = val }
 
-  rule_declaration: "%rule" IDENTIFIER "(" rule_args ")" tag_opt ":" rule_rhs_list
+  rule_declaration: "%rule" IDENTIFIER "(" rule_args ")" TAG? ":" rule_rhs_list
                       {
                         rule = Grammar::ParameterizingRule::Rule.new(val[1].s_value, val[3], val[7], tag: val[5])
                         @grammar.add_parameterizing_rule(rule)
                       }
 
-  inline_declaration: "%rule" "%inline" id_colon ":" rule_rhs_list
+  inline_declaration: "%rule" "%inline" IDENT_COLON ":" rule_rhs_list
                       {
                         rule = Grammar::ParameterizingRule::Rule.new(val[2].s_value, [], val[4], is_inline: true)
                         @grammar.add_parameterizing_rule(rule)
                       }
+                    | "%rule" "%inline" IDENTIFIER "(" rule_args ")" ":" rule_rhs_list
+                      {
+                        rule = Grammar::ParameterizingRule::Rule.new(val[2].s_value, val[4], val[7], is_inline: true)
+                        @grammar.add_parameterizing_rule(rule)
+                      }
 
   rule_args: IDENTIFIER { result = [val[0]] }
            | rule_args "," IDENTIFIER { result = val[0].append(val[2]) }
@@ -258,17 +214,12 @@ rule
                   result = val[0].append(builder)
                 }
 
-  rule_rhs: /* empty */
+  rule_rhs: "%empty"?
             {
               reset_precs
               result = Grammar::ParameterizingRule::Rhs.new
             }
-          | "%empty"
-            {
-              reset_precs
-              result = Grammar::ParameterizingRule::Rhs.new
-            }
-          | rule_rhs symbol named_ref_opt
+          | rule_rhs symbol named_ref?
             {
               token = val[1]
               token.alias_name = val[2]
@@ -282,28 +233,16 @@ rule
                 builder.symbols << Lrama::Lexer::Token::InstantiateRule.new(s_value: val[2], location: @lexer.location, args: [val[1]])
                 result = builder
               }
-          | rule_rhs IDENTIFIER "(" parameterizing_args ")" tag_opt
+          | rule_rhs IDENTIFIER "(" parameterizing_args ")" TAG?
               {
                 builder = val[0]
                 builder.symbols << Lrama::Lexer::Token::InstantiateRule.new(s_value: val[1].s_value, location: @lexer.location, args: val[3], lhs_tag: val[5])
                 result = builder
               }
-          | rule_rhs "{"
-            {
-              if @prec_seen
-                on_action_error("multiple User_code after %prec", val[0])  if @code_after_prec
-                @code_after_prec = true
-              end
-              begin_c_declaration("}")
-            }
-          C_DECLARATION
-            {
-              end_c_declaration
-            }
-          "}" named_ref_opt
+          | rule_rhs midrule_action named_ref?
             {
-              user_code = val[3]
-              user_code.alias_name = val[6]
+              user_code = val[1]
+              user_code.alias_name = val[2]
               builder = val[0]
               builder.user_code = user_code
               result = builder
@@ -317,84 +256,45 @@ rule
               result = builder
             }
 
-  int_opt: # empty
-         | INTEGER
+  alias: string_as_id? { result = val[0].s_value if val[0] }
 
-  alias: # empty
-       | STRING # TODO: change this to string_as_id
-
-  symbol_declarations: symbol_declaration_list
-                         {
-                           result = [{tag: nil, tokens: val[0]}]
-                         }
-                     | TAG symbol_declaration_list
-                         {
-                           result = [{tag: val[0], tokens: val[1]}]
-                         }
-                     | symbol_declarations TAG symbol_declaration_list
+  symbol_declarations: TAG? symbol+
                        {
-                         result = val[0].append({tag: val[1], tokens: val[2]})
+                          result = if val[0]
+                            [{tag: val[0], tokens: val[1]}]
+                          else
+                            [{tag: nil, tokens: val[1]}]
+                          end
                        }
-
-  symbol_declaration_list: symbol { result = [val[0]] }
-                         | symbol_declaration_list symbol { result = val[0].append(val[1]) }
+                     | symbol_declarations TAG symbol+ { result = val[0].append({tag: val[1], tokens: val[2]}) }
 
   symbol: id
         | string_as_id
 
-  params: params "{"
-            {
-              begin_c_declaration("}")
-            }
-          C_DECLARATION
-            {
-              end_c_declaration
-            }
-          "}"
-            {
-              result = val[0].append(val[3])
-            }
-        | "{"
-            {
-              begin_c_declaration("}")
-            }
-          C_DECLARATION
-            {
-              end_c_declaration
-            }
-          "}"
-            {
-              result = [val[2]]
-            }
-
-  token_declarations_for_precedence: token_declaration_list_for_precedence
-                                       {
-                                         result = [{tag: nil, tokens: val[0]}]
-                                       }
-                                   | TAG token_declaration_list_for_precedence
-                                       {
-                                         result = [{tag: val[0], tokens: val[1]}]
-                                       }
-                                   | token_declarations_for_precedence TAG token_declaration_list_for_precedence
-                                       {
-                                         result = val[0].append({tag: val[1], tokens: val[2]})
-                                       }
-
-  token_declaration_list_for_precedence: token_declaration_for_precedence { result = [val[0]] }
-                                       | token_declaration_list_for_precedence token_declaration_for_precedence { result = val[0].append(val[1]) }
-
-  token_declaration_for_precedence: id
+  param: "{" {
+               begin_c_declaration("}")
+             }
+         C_DECLARATION
+             {
+               end_c_declaration
+             }
+         "}"
+             {
+               result = val[2]
+             }
+
+  token_declarations_for_precedence: id+ { result = [{tag: nil, tokens: val[0]}] }
+                                   | TAG id+ { result = [{tag: val[0], tokens: val[1]}] }
+                                   | id TAG id+ { result = val[0].append({tag: val[1], tokens: val[2]}) }
 
   id: IDENTIFIER { on_action_error("ident after %prec", val[0]) if @prec_seen }
     | CHARACTER { on_action_error("char after %prec", val[0]) if @prec_seen }
 
-  grammar: rules_or_grammar_declaration
-         | grammar rules_or_grammar_declaration
 
-  rules_or_grammar_declaration: rules
+  rules_or_grammar_declaration: rules ";"?
                               | grammar_declaration ";"
 
-  rules: id_colon named_ref_opt ":" rhs_list
+  rules: IDENT_COLON named_ref? ":" rhs_list
            {
              lhs = val[0]
              lhs.alias_name = val[1]
@@ -421,19 +321,13 @@ rule
                 end
                 result = val[0].append(builder)
               }
-          | rhs_list ";"
 
-  rhs: /* empty */
-         {
-           reset_precs
-           result = Grammar::RuleBuilder.new(@rule_counter, @midrule_action_counter)
-         }
-     | "%empty"
+  rhs: "%empty"?
          {
            reset_precs
-           result = Grammar::RuleBuilder.new(@rule_counter, @midrule_action_counter)
+           result = @grammar.create_rule_builder(@rule_counter, @midrule_action_counter)
          }
-     | rhs symbol named_ref_opt
+     | rhs symbol named_ref?
          {
            token = val[1]
            token.alias_name = val[2]
@@ -441,39 +335,27 @@ rule
            builder.add_rhs(token)
            result = builder
          }
-     | rhs symbol parameterizing_suffix tag_opt
+     | rhs symbol parameterizing_suffix named_ref? TAG?
          {
-           token = Lrama::Lexer::Token::InstantiateRule.new(s_value: val[2], location: @lexer.location, args: [val[1]], lhs_tag: val[3])
+           token = Lrama::Lexer::Token::InstantiateRule.new(s_value: val[2], alias_name: val[3], location: @lexer.location, args: [val[1]], lhs_tag: val[4])
            builder = val[0]
            builder.add_rhs(token)
            builder.line = val[1].first_line
            result = builder
          }
-     | rhs IDENTIFIER "(" parameterizing_args ")" tag_opt
+     | rhs IDENTIFIER "(" parameterizing_args ")" named_ref? TAG?
          {
-           token = Lrama::Lexer::Token::InstantiateRule.new(s_value: val[1].s_value, location: @lexer.location, args: val[3], lhs_tag: val[5])
+           token = Lrama::Lexer::Token::InstantiateRule.new(s_value: val[1].s_value, alias_name: val[5], location: @lexer.location, args: val[3], lhs_tag: val[6])
            builder = val[0]
            builder.add_rhs(token)
            builder.line = val[1].first_line
            result = builder
          }
-     | rhs "{"
+     | rhs midrule_action named_ref? TAG?
          {
-           if @prec_seen
-             on_action_error("multiple User_code after %prec", val[0])  if @code_after_prec
-             @code_after_prec = true
-           end
-           begin_c_declaration("}")
-         }
-       C_DECLARATION
-         {
-           end_c_declaration
-         }
-       "}" named_ref_opt tag_opt
-         {
-           user_code = val[3]
-           user_code.alias_name = val[6]
-           user_code.tag = val[7]
+           user_code = val[1]
+           user_code.alias_name = val[2]
+           user_code.tag = val[3]
            builder = val[0]
            builder.user_code = user_code
            result = builder
@@ -491,27 +373,46 @@ rule
                        | "+" { result = "nonempty_list" }
                        | "*" { result = "list" }
 
-  parameterizing_args: symbol { result = [val[0]] }
+  parameterizing_args: symbol parameterizing_suffix?
+                          {
+                            result = if val[1]
+                              [Lrama::Lexer::Token::InstantiateRule.new(s_value: val[1].s_value, location: @lexer.location, args: val[0])]
+                            else
+                              [val[0]]
+                            end
+                          }
                      | parameterizing_args ',' symbol { result = val[0].append(val[2]) }
-                     | symbol parameterizing_suffix { result = [Lrama::Lexer::Token::InstantiateRule.new(s_value: val[1].s_value, location: @lexer.location, args: val[0])] }
                      | IDENTIFIER "(" parameterizing_args ")" { result = [Lrama::Lexer::Token::InstantiateRule.new(s_value: val[0].s_value, location: @lexer.location, args: val[2])] }
 
-  named_ref_opt: # empty
-               | '[' IDENTIFIER ']' { result = val[1].s_value }
-
-  id_colon: IDENT_COLON
-
-  epilogue_opt: # empty
-              | "%%"
-                  {
-                    begin_c_declaration('\Z')
-                    @grammar.epilogue_first_lineno = @lexer.line + 1
-                  }
-                C_DECLARATION
-                  {
-                    end_c_declaration
-                    @grammar.epilogue = val[2].s_value
-                  }
+  midrule_action: "{"
+                    {
+                      if @prec_seen
+                        on_action_error("multiple User_code after %prec", val[0])  if @code_after_prec
+                        @code_after_prec = true
+                      end
+                      begin_c_declaration("}")
+                    }
+                  C_DECLARATION
+                    {
+                      end_c_declaration
+                    }
+                  "}"
+                    {
+                      result = val[2]
+                    }
+
+  named_ref: '[' IDENTIFIER ']' { result = val[1].s_value }
+
+  epilogue_declaration: "%%"
+                          {
+                            begin_c_declaration('\Z')
+                            @grammar.epilogue_first_lineno = @lexer.line + 1
+                          }
+                        C_DECLARATION
+                          {
+                            end_c_declaration
+                            @grammar.epilogue = val[2].s_value
+                          }
 
   variable: id
 
@@ -520,16 +421,7 @@ rule
        | STRING
        | "{...}"
 
-  generic_symlist: generic_symlist_item { result = [val[0]] }
-                 | generic_symlist generic_symlist_item { result = val[0].append(val[1]) }
-
-  generic_symlist_item: symbol
-                      | TAG
-
   string_as_id: STRING { result = Lrama::Lexer::Token::Ident.new(s_value: val[0]) }
-
-  tag_opt: # empty
-         | TAG
 end
 
 ---- inner

data/rbs_collection.lock.yaml

@@ -1,6 +1,14 @@
 ---
 path: ".gem_rbs_collection"
 gems:
+- name: diff-lcs
+  version: '1.5'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 71fb7ae83789ae150bdee1cd8a7cd3035b5d79e2
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
 - name: erb
   version: '0'
   source:
@@ -18,7 +26,7 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: 4b0d2f72e63b6c3e92dc54e19ce23dd24524f9a7
+    revision: 71fb7ae83789ae150bdee1cd8a7cd3035b5d79e2
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: stackprof
@@ -26,7 +34,7 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: 4b0d2f72e63b6c3e92dc54e19ce23dd24524f9a7
+    revision: 71fb7ae83789ae150bdee1cd8a7cd3035b5d79e2
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: strscan

data/sig/lrama/counterexamples/derivation.rbs

@@ -0,0 +1,33 @@
+module Lrama
+  class Counterexamples
+    class Derivation
+      @item: States::Item
+
+      @left: Derivation?
+
+      @right: Derivation?
+
+      attr_reader item: States::Item
+
+      attr_reader left: Derivation?
+
+      attr_reader right: Derivation?
+
+      attr_writer right: Derivation?
+
+      def initialize: (States::Item item, Derivation? left, ?Derivation? right) -> void
+
+      def to_s: () -> ::String
+
+      alias inspect to_s
+
+      def render_strings_for_report: () -> Array[String]
+
+      def render_for_report: () -> String
+
+      private
+
+      def _render_for_report: (Derivation derivation, Integer offset, Array[String] strings, Integer index) -> Integer
+    end
+  end
+end

data/sig/lrama/counterexamples/example.rbs

@@ -0,0 +1,45 @@
+module Lrama
+  class Counterexamples
+    class Example
+      @path1: ::Array[StartPath | TransitionPath | ProductionPath]
+
+      @path2: ::Array[StartPath | TransitionPath | ProductionPath]
+
+      @conflict: (State::ShiftReduceConflict | State::ReduceReduceConflict)
+
+      @conflict_symbol: Grammar::Symbol
+
+      @counterexamples: Counterexamples
+
+      @derivations1: Derivation
+
+      @derivations2: Derivation
+
+      attr_reader path1: ::Array[StartPath | TransitionPath | ProductionPath]
+
+      attr_reader path2: ::Array[StartPath | TransitionPath | ProductionPath]
+
+      attr_reader conflict: (State::ShiftReduceConflict | State::ReduceReduceConflict)
+
+      attr_reader conflict_symbol: Grammar::Symbol
+
+      def initialize: (::Array[StartPath | TransitionPath | ProductionPath]? path1, ::Array[StartPath | TransitionPath | ProductionPath]? path2, (State::ShiftReduceConflict | State::ReduceReduceConflict) conflict, Grammar::Symbol conflict_symbol, Counterexamples counterexamples) -> void
+
+      def type: () -> (:shift_reduce | :reduce_reduce)
+
+      def path1_item: () -> States::Item
+
+      def path2_item: () -> States::Item
+
+      def derivations1: () -> Derivation
+
+      def derivations2: () -> Derivation
+
+      private
+
+      def _derivations: (::Array[StartPath | TransitionPath | ProductionPath] paths) -> Derivation
+
+      def find_derivation_for_symbol: (StateItem state_item, Grammar::Symbol sym) -> Derivation?
+    end
+  end
+end

data/sig/lrama/counterexamples/path.rbs

@@ -0,0 +1,21 @@
+module Lrama
+  class Counterexamples
+    class Path
+      @from_state_item: StateItem?
+
+      @to_state_item: StateItem
+
+      def initialize: (StateItem? from_state_item, StateItem to_state_item) -> void
+
+      def from: () -> StateItem?
+
+      def to: () -> StateItem
+
+      def to_s: () -> ::String
+
+      alias inspect to_s
+
+      def type: -> bot
+    end
+  end
+end