lrama 0.6.10 → 0.6.11

data/lib/lrama/state/reduce.rb

@@ -26,9 +26,8 @@ module Lrama
       end
 
       def selected_look_ahead
-        if @look_ahead
-          # @type ivar @look_ahead: Array<Grammar::Symbol>
-          @look_ahead - @not_selected_symbols
+        if look_ahead
+          look_ahead - @not_selected_symbols
         else
           []
         end

data/lib/lrama/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lrama
-  VERSION = "0.6.10".freeze
+  VERSION = "0.6.11".freeze
 end

data/parser.y

@@ -61,26 +61,26 @@ rule
                      | symbol_declaration
                      | rule_declaration
                      | inline_declaration
-                     | "%destructor" param generic_symbol+
+                     | "%destructor" param (symbol | TAG)+
                          {
                            @grammar.add_destructor(
-                             ident_or_tags: val[2],
+                             ident_or_tags: val[2].flatten,
                              token_code: val[1],
                              lineno: val[1].line
                            )
                          }
-                     | "%printer" param generic_symbol+
+                     | "%printer" param (symbol | TAG)+
                          {
                            @grammar.add_printer(
-                             ident_or_tags: val[2],
+                             ident_or_tags: val[2].flatten,
                              token_code: val[1],
                              lineno: val[1].line
                            )
                          }
-                     | "%error-token" param generic_symbol+
+                     | "%error-token" param (symbol | TAG)+
                          {
                            @grammar.add_error_token(
-                             ident_or_tags: val[2],
+                             ident_or_tags: val[2].flatten,
                              token_code: val[1],
                              lineno: val[1].line
                            )
@@ -115,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|
@@ -156,13 +168,7 @@ rule
                           @precedence_number += 1
                         }
 
-  token_declarations: token_declaration+
-                        {
-                          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+
+  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)
@@ -208,7 +214,7 @@ rule
                   result = val[0].append(builder)
                 }
 
-  rule_rhs: empty
+  rule_rhs: "%empty"?
             {
               reset_precs
               result = Grammar::ParameterizingRule::Rhs.new
@@ -250,11 +256,16 @@ rule
               result = builder
             }
 
-  alias: # empty
-       | string_as_id { result = val[0].s_value }
+  alias: string_as_id? { result = val[0].s_value if val[0] }
 
-  symbol_declarations: symbol+ { result = [{tag: nil, tokens: val[0]}] }
-                     | TAG symbol+ { result = [{tag: val[0], tokens: val[1]}] }
+  symbol_declarations: TAG? symbol+
+                       {
+                          result = if val[0]
+                            [{tag: val[0], tokens: val[1]}]
+                          else
+                            [{tag: nil, tokens: val[1]}]
+                          end
+                       }
                      | symbol_declarations TAG symbol+ { result = val[0].append({tag: val[1], tokens: val[2]}) }
 
   symbol: id
@@ -311,7 +322,7 @@ rule
                 result = val[0].append(builder)
               }
 
-  rhs: empty
+  rhs: "%empty"?
          {
            reset_precs
            result = @grammar.create_rule_builder(@rule_counter, @midrule_action_counter)
@@ -362,9 +373,15 @@ 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])] }
 
   midrule_action: "{"
@@ -404,12 +421,6 @@ rule
        | STRING
        | "{...}"
 
-  generic_symbol: symbol
-                | TAG
-
-  empty: /* empty */
-       | "%empty"
-
   string_as_id: STRING { result = Lrama::Lexer::Token::Ident.new(s_value: val[0]) }
 end
 

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

data/sig/lrama/counterexamples/production_path.rbs

@@ -0,0 +1,11 @@
+module Lrama
+  class Counterexamples
+    class ProductionPath < Path
+      def type: () -> :production
+
+      def transition?: () -> false
+
+      def production?: () -> true
+    end
+  end
+end

data/sig/lrama/counterexamples/start_path.rbs

@@ -0,0 +1,13 @@
+module Lrama
+  class Counterexamples
+    class StartPath < Path
+      def initialize: (StateItem to_state_item) -> void
+
+      def type: () -> :start
+
+      def transition?: () -> false
+
+      def production?: () -> false
+    end
+  end
+end

data/sig/lrama/counterexamples/state_item.rbs

@@ -0,0 +1,10 @@
+module Lrama
+  class Counterexamples
+    class StateItem
+     attr_accessor state: State
+     attr_accessor item: States::Item
+
+      def initialize: (State state, States::Item item) -> void
+    end
+  end
+end

data/sig/lrama/counterexamples/transition_path.rbs

@@ -0,0 +1,11 @@
+module Lrama
+  class Counterexamples
+    class TransitionPath < Path
+      def type: () -> :transition
+
+      def transition?: () -> true
+
+      def production?: () -> false
+    end
+  end
+end

data/sig/lrama/counterexamples/triple.rbs

@@ -0,0 +1,20 @@
+module Lrama
+  class Counterexamples
+    class Triple
+      attr_accessor s: State
+      attr_accessor itm: States::Item
+      attr_accessor l: Set[Grammar::Symbol]
+
+      alias state s
+      alias item itm
+      alias precise_lookahead_set l
+
+      def initialize: (State s, States::Item itm, Set[Grammar::Symbol] l) -> void
+
+      def state_item: () -> StateItem
+      def inspect: () -> ::String
+
+      alias to_s inspect
+    end
+  end
+end

data/sig/lrama/counterexamples.rbs

@@ -0,0 +1,29 @@
+module Lrama
+  class Counterexamples
+    @states: States
+    @transitions: Hash[[StateItem, Grammar::Symbol], StateItem]
+    @reverse_transitions: Hash[[StateItem, Grammar::Symbol], Set[StateItem]]
+    @productions: Hash[StateItem, Set[States::Item]]
+    @reverse_productions: Hash[[State, Grammar::Symbol], Set[States::Item]]
+
+    attr_reader transitions: Hash[[StateItem, Grammar::Symbol], StateItem]
+    attr_reader productions: Hash[StateItem, Set[States::Item]]
+
+    def initialize: (States states) -> void
+    def to_s: () -> "#<Counterexamples>"
+    alias inspect to_s
+    def compute: (State conflict_state) -> Array[Example]
+
+    private
+
+    def setup_transitions: () -> void
+    def setup_productions: () -> void
+    def shift_reduce_example: (State conflict_state, State::ShiftReduceConflict conflict) -> Example
+    def reduce_reduce_examples: (State conflict_state, State::ReduceReduceConflict conflict) -> Example
+    def find_shift_conflict_shortest_path: (::Array[StartPath|TransitionPath|ProductionPath]? reduce_path, State conflict_state, States::Item conflict_item) -> ::Array[StartPath|TransitionPath|ProductionPath]
+    def find_shift_conflict_shortest_state_items: (::Array[StartPath|TransitionPath|ProductionPath]? reduce_path, State conflict_state, States::Item conflict_item) -> Array[StateItem]
+    def build_paths_from_state_items: (Array[StateItem] state_items) -> ::Array[StartPath|TransitionPath|ProductionPath]
+    def shortest_path: (State conflict_state, States::Item conflict_reduce_item, Grammar::Symbol conflict_term) -> ::Array[StartPath|TransitionPath|ProductionPath]?
+    def follow_l: (States::Item item, Set[Grammar::Symbol] current_l) -> Set[Grammar::Symbol]
+  end
+end

data/sig/lrama/grammar/symbol.rbs

@@ -13,7 +13,7 @@ module Lrama
       attr_accessor destructor: Destructor?
       attr_accessor error_token: ErrorToken
 
-      attr_accessor first_set: Set[Array[Symbol]] | Set[Symbol]
+      attr_accessor first_set: Set[Grammar::Symbol]
       attr_accessor first_set_bitmap: Integer
       attr_writer eof_symbol: bool
       attr_writer error_symbol: bool

data/sig/lrama/grammar/symbols/resolver.rbs

@@ -14,8 +14,8 @@ module Lrama
         def sort_by_number!: () -> Array[Grammar::Symbol]
         def add_term: (id: Lexer::Token, ?alias_name: String?, ?tag: Lexer::Token::Tag?, ?token_id: Integer?, ?replace: bool) -> Grammar::Symbol
         def add_nterm: (id: Lexer::Token, ?alias_name: String?, ?tag: Lexer::Token::Tag?) -> Grammar::Symbol
-        def find_symbol_by_s_value: (Grammar::Symbol s_value) -> Grammar::Symbol?
-        def find_symbol_by_s_value!: (Grammar::Symbol s_value) -> Grammar::Symbol
+        def find_symbol_by_s_value: (::String s_value) -> Grammar::Symbol?
+        def find_symbol_by_s_value!: (::String s_value) -> Grammar::Symbol
         def find_symbol_by_id: (Lexer::Token id) -> Grammar::Symbol?
         def find_symbol_by_id!: (Lexer::Token id) -> Grammar::Symbol
         def find_symbol_by_token_id: (Integer token_id) -> Grammar::Symbol?
@@ -47,7 +47,7 @@ module Lrama
         def find_symbol_by_number!: (Integer number) -> Grammar::Symbol
         def find_symbol_by_id!: (Lexer::Token id) -> Grammar::Symbol
         def token_to_symbol: (Lexer::Token token) -> Grammar::Symbol
-        def find_symbol_by_s_value!: (Grammar::Symbol s_value) -> Grammar::Symbol
+        def find_symbol_by_s_value!: (::String s_value) -> Grammar::Symbol
         def fill_nterm_type: (Array[Grammar::Type] types) -> void
         def fill_symbol_number: () -> void
         def fill_printer: (Array[Grammar::Printer] printers) -> void

data/sig/lrama/grammar.rbs

@@ -91,5 +91,18 @@ module Lrama
     def fill_sym_to_rules: () -> Array[Rule]
     def validate_rule_lhs_is_nterm!: () -> void
     def set_locations: () -> void
+
+    interface _DelegatedMethods
+    def rules: () -> Array[Rule]
+    def accept_symbol: () -> Grammar::Symbol
+    def eof_symbol: () -> Grammar::Symbol
+    def undef_symbol: () -> Grammar::Symbol
+
+    # delegate to @symbols_resolver
+    def symbols: () -> Array[Grammar::Symbol]
+    def terms: () -> Array[Grammar::Symbol]
+    def nterms: () -> Array[Grammar::Symbol]
+    def find_symbol_by_s_value!: (::String s_value) -> Grammar::Symbol
+    end
   end
 end

data/sig/lrama/state/reduce_reduce_conflict.rbs

@@ -1,11 +1,11 @@
 module Lrama
   class State
     class ReduceReduceConflict
-      attr_accessor symbols: Array[Grammar::Symbol?]
+      attr_accessor symbols: Array[Grammar::Symbol]
       attr_accessor reduce1: State::Reduce
       attr_accessor reduce2: State::Reduce
 
-      def initialize: (?symbols: Array[Grammar::Symbol?], ?reduce1: State::Reduce, ?reduce2: State::Reduce) -> void
+      def initialize: (?symbols: Array[Grammar::Symbol], ?reduce1: State::Reduce, ?reduce2: State::Reduce) -> void
 
       def type: () -> :reduce_reduce
     end

data/sig/lrama/state.rbs

@@ -0,0 +1,79 @@
+module Lrama
+  class State
+    @id: untyped
+
+    @accessing_symbol: untyped
+
+    @kernels: untyped
+
+    @items: Array[States::Item]
+
+    @items_to_state: untyped
+
+    @conflicts: Array[State::ShiftReduceConflict|State::ReduceReduceConflict]
+
+    @resolved_conflicts: untyped
+
+    @default_reduction_rule: untyped
+
+    @closure: untyped
+
+    @nterm_transitions: untyped
+
+    @term_transitions: untyped
+
+    @transitions: Array[[Shift, State]]
+
+    attr_reader id: untyped
+
+    attr_reader accessing_symbol: untyped
+
+    attr_reader kernels: untyped
+
+    attr_reader conflicts: Array[State::ShiftReduceConflict|State::ReduceReduceConflict]
+
+    attr_reader resolved_conflicts: untyped
+
+    attr_reader default_reduction_rule: untyped
+
+    attr_reader closure: untyped
+
+    attr_reader items: Array[States::Item]
+
+    attr_accessor shifts: Array[Shift]
+
+    attr_accessor reduces: untyped
+
+    def initialize: (untyped id, untyped accessing_symbol, Array[States::Item] kernels) -> void
+
+    def closure=: (untyped closure) -> untyped
+
+    def non_default_reduces: () -> untyped
+
+    def compute_shifts_reduces: () -> untyped
+
+    def set_items_to_state: (untyped items, untyped next_state) -> untyped
+
+    def set_look_ahead: (untyped rule, untyped look_ahead) -> untyped
+
+    def nterm_transitions: () -> untyped
+
+    def term_transitions: () -> untyped
+
+    def transitions: () -> Array[[Shift, State]]
+
+    def selected_term_transitions: () -> untyped
+
+    def transition: (untyped sym) -> untyped
+
+    def find_reduce_by_item!: (untyped item) -> untyped
+
+    def default_reduction_rule=: (untyped default_reduction_rule) -> untyped
+
+    def has_conflicts?: () -> untyped
+
+    def sr_conflicts: () -> untyped
+
+    def rr_conflicts: () -> untyped
+  end
+end

data/sig/lrama/states.rbs

@@ -0,0 +1,101 @@
+module Lrama
+  class States
+    include Grammar::_DelegatedMethods
+
+    @grammar: untyped
+
+    @warning: untyped
+
+    @trace_state: untyped
+
+    @states: Array[State]
+
+    @direct_read_sets: untyped
+
+    @reads_relation: untyped
+
+    @read_sets: untyped
+
+    @includes_relation: untyped
+
+    @lookback_relation: untyped
+
+    @follow_sets: untyped
+
+    @la: untyped
+
+    extend Forwardable
+
+    include Lrama::Report::Duration
+
+    attr_reader states: Array[State]
+
+    attr_reader reads_relation: untyped
+
+    attr_reader includes_relation: untyped
+
+    attr_reader lookback_relation: untyped
+
+    def initialize: (untyped grammar, untyped warning, ?trace_state: bool) -> void
+
+    def compute: () -> untyped
+
+    def reporter: () -> untyped
+
+    def states_count: () -> untyped
+
+    def direct_read_sets: () -> untyped
+
+    def read_sets: () -> untyped
+
+    def follow_sets: () -> untyped
+
+    def la: () -> untyped
+
+    private
+
+    def sr_conflicts: () -> untyped
+
+    def rr_conflicts: () -> untyped
+
+    def trace_state: () { (untyped) -> untyped } -> (untyped | nil)
+
+    def create_state: (untyped accessing_symbol, untyped kernels, untyped states_created) -> (::Array[untyped | false] | ::Array[untyped | true])
+
+    def setup_state: (untyped state) -> untyped
+
+    def enqueue_state: (untyped states, untyped state) -> untyped
+
+    def compute_lr0_states: () -> untyped
+
+    def nterm_transitions: () -> untyped
+
+    def compute_direct_read_sets: () -> untyped
+
+    def compute_reads_relation: () -> untyped
+
+    def compute_read_sets: () -> untyped
+
+    def transition: (untyped state, untyped symbols) -> untyped
+
+    def compute_includes_relation: () -> untyped
+
+    def compute_lookback_relation: () -> untyped
+
+    def compute_follow_sets: () -> untyped
+
+    def compute_look_ahead_sets: () -> untyped
+
+    def bitmap_to_terms: (untyped bit) -> untyped
+
+    def compute_conflicts: () -> untyped
+
+    def compute_shift_reduce_conflicts: () -> untyped
+
+    def compute_reduce_reduce_conflicts: () -> untyped
+
+    def compute_default_reduction: () -> untyped
+
+    def check_conflicts: () -> untyped
+  end
+end