lrama 0.7.0 → 0.7.1

data/lib/lrama/reporter/terms.rb

@@ -0,0 +1,44 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Lrama
+  class Reporter
+    class Terms
+      # @rbs (?terms: bool, **bool _) -> void
+      def initialize(terms: false, **_)
+        @terms = terms
+      end
+
+      # @rbs (IO io, Lrama::States states) -> void
+      def report(io, states)
+        return unless @terms
+
+        look_aheads = states.states.each do |state|
+          state.reduces.flat_map do |reduce|
+            reduce.look_ahead unless reduce.look_ahead.nil?
+          end
+        end
+
+        next_terms = states.states.flat_map do |state|
+          state.term_transitions.map {|shift| shift.next_sym }
+        end
+
+        unused_symbols = states.terms.reject do |term|
+          (look_aheads + next_terms).include?(term)
+        end
+
+        io << states.terms.count << " Terms\n\n"
+
+        io << states.nterms.count << " Non-Terminals\n\n"
+
+        unless unused_symbols.empty?
+          io << "#{unused_symbols.count} Unused Terms\n\n"
+          unused_symbols.each_with_index do |term, index|
+            io << sprintf("%5d %s", index, term.id.s_value) << "\n"
+          end
+          io << "\n\n"
+        end
+      end
+    end
+  end
+end

data/lib/lrama/reporter.rb

@@ -0,0 +1,39 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+require_relative 'reporter/conflicts'
+require_relative 'reporter/grammar'
+require_relative 'reporter/precedences'
+require_relative 'reporter/profile'
+require_relative 'reporter/rules'
+require_relative 'reporter/states'
+require_relative 'reporter/terms'
+
+module Lrama
+  class Reporter
+    include Lrama::Tracer::Duration
+
+    # @rbs (**bool options) -> void
+    def initialize(**options)
+      @options = options
+      @rules = Rules.new(**options)
+      @terms = Terms.new(**options)
+      @conflicts = Conflicts.new
+      @precedences = Precedences.new
+      @grammar = Grammar.new(**options)
+      @states = States.new(**options)
+    end
+
+    # @rbs (File io, Lrama::States states) -> void
+    def report(io, states)
+      report_duration(:report) do
+        report_duration(:report_rules) { @rules.report(io, states) }
+        report_duration(:report_terms) { @terms.report(io, states) }
+        report_duration(:report_conflicts) { @conflicts.report(io, states) }
+        report_duration(:report_precedences) { @precedences.report(io, states) }
+        report_duration(:report_grammar) { @grammar.report(io, states) }
+        report_duration(:report_states) { @states.report(io, states, ielr: states.ielr_defined?) }
+      end
+    end
+  end
+end

data/lib/lrama/state/action/goto.rb

@@ -0,0 +1,33 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Lrama
+  class State
+    class Action
+      class Goto
+        # TODO: rbs-inline 0.11.0 doesn't support instance variables.
+        #       Move these type declarations above instance variable definitions, once it's supported.
+        #       see: https://github.com/soutaro/rbs-inline/pull/149
+        #
+        # @rbs!
+        #   @from_state: State
+        #   @next_sym: Grammar::Symbol
+        #   @to_items: Array[Item]
+        #   @to_state: State
+
+        attr_reader :from_state #: State
+        attr_reader :next_sym #: Grammar::Symbol
+        attr_reader :to_items #: Array[Item]
+        attr_reader :to_state #: State
+
+        # @rbs (State from_state, Grammar::Symbol next_sym, Array[Item] to_items, State to_state) -> void
+        def initialize(from_state, next_sym, to_items, to_state)
+          @from_state = from_state
+          @next_sym = next_sym
+          @to_items = to_items
+          @to_state = to_state
+        end
+      end
+    end
+  end
+end

data/lib/lrama/state/action/reduce.rb

@@ -0,0 +1,71 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Lrama
+  class State
+    class Action
+      class Reduce
+        # TODO: rbs-inline 0.11.0 doesn't support instance variables.
+        #       Move these type declarations above instance variable definitions, once it's supported.
+        #       see: https://github.com/soutaro/rbs-inline/pull/149
+        #
+        # @rbs!
+        #   @item: Item
+        #   @look_ahead: Array[Grammar::Symbol]?
+        #   @look_ahead_sources: Hash[Grammar::Symbol, Array[Action::Goto]]?
+        #   @not_selected_symbols: Array[Grammar::Symbol]
+
+        attr_reader :item #: Item
+        attr_reader :look_ahead #: Array[Grammar::Symbol]?
+        attr_reader :look_ahead_sources #: Hash[Grammar::Symbol, Array[Action::Goto]]?
+        attr_reader :not_selected_symbols #: Array[Grammar::Symbol]
+
+        # https://www.gnu.org/software/bison/manual/html_node/Default-Reductions.html
+        attr_accessor :default_reduction #: bool
+
+        # @rbs (Item item) -> void
+        def initialize(item)
+          @item = item
+          @look_ahead = nil
+          @look_ahead_sources = nil
+          @not_selected_symbols = []
+        end
+
+        # @rbs () -> Grammar::Rule
+        def rule
+          @item.rule
+        end
+
+        # @rbs (Array[Grammar::Symbol] look_ahead) -> Array[Grammar::Symbol]
+        def look_ahead=(look_ahead)
+          @look_ahead = look_ahead.freeze
+        end
+
+        # @rbs (Hash[Grammar::Symbol, Array[Action::Goto]] sources) -> Hash[Grammar::Symbol, Array[Action::Goto]]
+        def look_ahead_sources=(sources)
+          @look_ahead_sources = sources.freeze
+        end
+
+        # @rbs (Grammar::Symbol sym) -> Array[Grammar::Symbol]
+        def add_not_selected_symbol(sym)
+          @not_selected_symbols << sym
+        end
+
+        # @rbs () -> (::Array[Grammar::Symbol?])
+        def selected_look_ahead
+          if look_ahead
+            look_ahead - @not_selected_symbols
+          else
+            []
+          end
+        end
+
+        # @rbs () -> void
+        def clear_conflicts
+          @not_selected_symbols = []
+          @default_reduction = nil
+        end
+      end
+    end
+  end
+end

data/lib/lrama/state/action/shift.rb

@@ -0,0 +1,39 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Lrama
+  class State
+    class Action
+      class Shift
+        # TODO: rbs-inline 0.11.0 doesn't support instance variables.
+        #       Move these type declarations above instance variable definitions, once it's supported.
+        #       see: https://github.com/soutaro/rbs-inline/pull/149
+        #
+        # @rbs!
+        #   @from_state: State
+        #   @next_sym: Grammar::Symbol
+        #   @to_items: Array[Item]
+        #   @to_state: State
+
+        attr_reader :from_state #: State
+        attr_reader :next_sym #: Grammar::Symbol
+        attr_reader :to_items #: Array[Item]
+        attr_reader :to_state #: State
+        attr_accessor :not_selected #: bool
+
+        # @rbs (State from_state, Grammar::Symbol next_sym, Array[Item] to_items, State to_state) -> void
+        def initialize(from_state, next_sym, to_items, to_state)
+          @from_state = from_state
+          @next_sym = next_sym
+          @to_items = to_items
+          @to_state = to_state
+        end
+
+        # @rbs () -> void
+        def clear_conflicts
+          @not_selected = nil
+        end
+      end
+    end
+  end
+end

data/lib/lrama/state/action.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "action/goto"
+require_relative "action/reduce"
+require_relative "action/shift"

data/lib/lrama/state/inadequacy_annotation.rb

@@ -0,0 +1,140 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Lrama
+  class State
+    class InadequacyAnnotation
+      # @rbs!
+      #   type action = Action::Shift | Action::Reduce
+
+      attr_accessor :state #: State
+      attr_accessor :token #: Grammar::Symbol
+      attr_accessor :actions #: Array[action]
+      attr_accessor :contribution_matrix #: Hash[action, Hash[Item, bool]]
+
+      # @rbs (State state, Grammar::Symbol token, Array[action] actions, Hash[action, Hash[Item, bool]] contribution_matrix) -> void
+      def initialize(state, token, actions, contribution_matrix)
+        @state = state
+        @token = token
+        @actions = actions
+        @contribution_matrix = contribution_matrix
+      end
+
+      # @rbs (Item item) -> bool
+      def contributed?(item)
+        @contribution_matrix.any? {|action, contributions| !contributions.nil? && contributions[item] }
+      end
+
+      # @rbs (Array[Hash[action, Hash[Item, bool]]] another_matrixes) -> void
+      def merge_matrix(another_matrixes)
+        another_matrixes.each do |another_matrix|
+          @contribution_matrix.merge!(another_matrix) {|action, contributions, another_contributions|
+            next contributions if another_contributions.nil?
+            next another_contributions if contributions.nil?
+
+            contributions.merge!(another_contributions) {|_, contributed, another_contributed| contributed || another_contributed }
+          }
+        end
+      end
+
+      # Definition 3.42 (dominant_contribution)
+      #
+      # @rbs (State::lookahead_set lookaheads) -> Array[action]?
+      def dominant_contribution(lookaheads)
+        actions = @actions.select {|action|
+          contribution_matrix[action].nil? || contribution_matrix[action].any? {|item, contributed| contributed && lookaheads[item].include?(@token) }
+        }
+        return nil if actions.empty?
+
+        resolve_conflict(actions)
+      end
+
+      # @rbs (Array[action] actions) -> Array[action]
+      def resolve_conflict(actions)
+        # @type var shifts: Array[Action::Shift]
+        # @type var reduces: Array[Action::Reduce]
+        shifts = actions.select {|action| action.is_a?(Action::Shift)}
+        reduces = actions.select {|action| action.is_a?(Action::Reduce) }
+
+        shifts.each do |shift|
+          reduces.each do |reduce|
+            sym = shift.next_sym
+
+            shift_prec = sym.precedence
+            reduce_prec = reduce.item.rule.precedence
+
+            # Can resolve only when both have prec
+            unless shift_prec && reduce_prec
+              next
+            end
+
+            case
+            when shift_prec < reduce_prec
+              # Reduce is selected
+              actions.delete(shift)
+              next
+            when shift_prec > reduce_prec
+              # Shift is selected
+              actions.delete(reduce)
+              next
+            end
+
+            # shift_prec == reduce_prec, then check associativity
+            case sym.precedence&.type
+            when :precedence
+              # %precedence only specifies precedence and not specify associativity
+              # then a conflict is unresolved if precedence is same.
+              next
+            when :right
+              # Shift is selected
+              actions.delete(reduce)
+              next
+            when :left
+              # Reduce is selected
+              actions.delete(shift)
+              next
+            when :nonassoc
+              # Can not resolve
+              #
+              # nonassoc creates "run-time" error, precedence creates "compile-time" error.
+              # Then omit both the shift and reduce.
+              #
+              # https://www.gnu.org/software/bison/manual/html_node/Using-Precedence.html
+              actions.delete(shift)
+              actions.delete(reduce)
+            else
+              raise "Unknown precedence type. #{sym}"
+            end
+          end
+        end
+
+        actions
+      end
+
+      # @rbs () -> String
+      def to_s
+        "State: #{@state.id}, Token: #{@token.id.s_value}, Actions: #{actions_to_s}, Contributions: #{contribution_matrix_to_s}"
+      end
+
+      private
+
+      # @rbs () -> String
+      def actions_to_s
+        '[' + @actions.map {|action|
+          if action.is_a?(Action::Shift) || action.is_a?(Action::Goto)
+            action.class.name
+          elsif action.is_a?(Action::Reduce)
+            "#{action.class.name}: (#{action.item})"
+          end
+        }.join(', ') + ']'
+      end
+
+      # @rbs () -> String
+      def contribution_matrix_to_s
+        '[' + @contribution_matrix.map {|action, contributions|
+          "#{(action.is_a?(Action::Shift) || action.is_a?(Action::Goto)) ? action.class.name : "#{action.class.name}: (#{action.item})"}: " + contributions&.transform_keys(&:to_s).to_s
+        }.join(', ') + ']'
+      end
+    end
+  end
+end

data/lib/lrama/{states → state}/item.rb

@@ -1,3 +1,4 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 # TODO: Validate position is not over rule rhs
@@ -5,84 +6,112 @@
 require "forwardable"
 
 module Lrama
-  class States
+  class State
     class Item < Struct.new(:rule, :position, keyword_init: true)
+      # @rbs!
+      #   include Grammar::Rule::_DelegatedMethods
+      #
+      #   attr_accessor rule: Grammar::Rule
+      #   attr_accessor position: Integer
+      #
+      #   def initialize: (?rule: Grammar::Rule, ?position: Integer) -> void
+
       extend Forwardable
 
       def_delegators "rule", :lhs, :rhs
 
       # Optimization for States#setup_state
+      #
+      # @rbs () -> Integer
       def hash
         [rule_id, position].hash
       end
 
+      # @rbs () -> Integer
       def rule_id
         rule.id
       end
 
+      # @rbs () -> bool
       def empty_rule?
         rule.empty_rule?
       end
 
+      # @rbs () -> Integer
       def number_of_rest_symbols
-        rhs.count - position
+        @number_of_rest_symbols ||= rhs.count - position
       end
 
+      # @rbs () -> Grammar::Symbol
       def next_sym
         rhs[position]
       end
 
+      # @rbs () -> Grammar::Symbol
       def next_next_sym
-        rhs[position + 1]
+        @next_next_sym ||= rhs[position + 1]
       end
 
+      # @rbs () -> Grammar::Symbol
       def previous_sym
         rhs[position - 1]
       end
 
+      # @rbs () -> bool
       def end_of_rule?
         rhs.count == position
       end
 
+      # @rbs () -> bool
       def beginning_of_rule?
         position == 0
       end
 
+      # @rbs () -> bool
       def start_item?
         rule.initial_rule? && beginning_of_rule?
       end
 
+      # @rbs () -> State::Item
       def new_by_next_position
         Item.new(rule: rule, position: position + 1)
       end
 
+      # @rbs () -> Array[Grammar::Symbol]
       def symbols_before_dot # steep:ignore
         rhs[0...position]
       end
 
+      # @rbs () -> Array[Grammar::Symbol]
       def symbols_after_dot # steep:ignore
         rhs[position..-1]
       end
 
-      def symbols_after_transition
+      # @rbs () -> Array[Grammar::Symbol]
+      def symbols_after_transition # steep:ignore
         rhs[position+1..-1]
       end
 
+      # @rbs () -> ::String
       def to_s
         "#{lhs.id.s_value}: #{display_name}"
       end
 
+      # @rbs () -> ::String
       def display_name
         r = rhs.map(&:display_name).insert(position, "•").join(" ")
         "#{r}  (rule #{rule_id})"
       end
 
       # Right after position
+      #
+      # @rbs () -> ::String
       def display_rest
         r = symbols_after_dot.map(&:display_name).join(" ")
         ". #{r}  (rule #{rule_id})"
       end
 
+      # @rbs (State::Item other_item) -> bool
       def predecessor_item_of?(other_item)
         rule == other_item.rule && position == other_item.position - 1
       end

data/lib/lrama/state/reduce_reduce_conflict.rb

@@ -1,8 +1,21 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Lrama
   class State
-    class ReduceReduceConflict < Struct.new(:symbols, :reduce1, :reduce2, keyword_init: true)
+    class ReduceReduceConflict
+      attr_reader :symbols #: Array[Grammar::Symbol]
+      attr_reader :reduce1 #: State::Action::Reduce
+      attr_reader :reduce2 #: State::Action::Reduce
+
+      # @rbs (symbols: Array[Grammar::Symbol], reduce1: State::Action::Reduce, reduce2: State::Action::Reduce) -> void
+      def initialize(symbols:, reduce1:, reduce2:)
+        @symbols = symbols
+        @reduce1 = reduce1
+        @reduce2 = reduce2
+      end
+
+      # @rbs () -> :reduce_reduce
       def type
         :reduce_reduce
       end

data/lib/lrama/state/resolved_conflict.rb

@@ -1,20 +1,54 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Lrama
   class State
+    # * state: A state on which the conflct is resolved
     # * symbol: A symbol under discussion
     # * reduce: A reduce under discussion
     # * which: For which a conflict is resolved. :shift, :reduce or :error (for nonassociative)
-    class ResolvedConflict < Struct.new(:symbol, :reduce, :which, :same_prec, keyword_init: true)
+    # * resolved_by_precedence: If the conflict is resolved by precedence definition or not
+    class ResolvedConflict
+      # @rbs!
+      #   type which_enum = :reduce | :shift | :error
+
+      attr_reader :state #: State
+      attr_reader :symbol #: Grammar::Symbol
+      attr_reader :reduce #: State::Action::Reduce
+      attr_reader :which #: which_enum
+      attr_reader :resolved_by_precedence #: bool
+
+      # @rbs (state: State, symbol: Grammar::Symbol, reduce: State::Action::Reduce, which: which_enum, resolved_by_precedence: bool) -> void
+      def initialize(state:, symbol:, reduce:, which:, resolved_by_precedence:)
+        @state = state
+        @symbol = symbol
+        @reduce = reduce
+        @which = which
+        @resolved_by_precedence = resolved_by_precedence
+      end
+
+      # @rbs () -> (::String | bot)
       def report_message
+        "Conflict between rule #{reduce.rule.id} and token #{symbol.display_name} #{how_resolved}."
+      end
+
+      # @rbs () -> (::String | bot)
+      def report_precedences_message
+        "Conflict between reduce by \"#{reduce.rule.display_name}\" and shift #{symbol.display_name} #{how_resolved}."
+      end
+
+      private
+
+      # @rbs () -> (::String | bot)
+      def how_resolved
         s = symbol.display_name
         r = reduce.rule.precedence_sym&.display_name
         case
-        when which == :shift && same_prec
+        when which == :shift && resolved_by_precedence
           msg = "resolved as #{which} (%right #{s})"
         when which == :shift
           msg = "resolved as #{which} (#{r} < #{s})"
-        when which == :reduce && same_prec
+        when which == :reduce && resolved_by_precedence
           msg = "resolved as #{which} (%left #{s})"
         when which == :reduce
           msg = "resolved as #{which} (#{s} < #{r})"
@@ -24,7 +58,7 @@ module Lrama
           raise "Unknown direction. #{self}"
         end
 
-        "Conflict between rule #{reduce.rule.id} and token #{s} #{msg}."
+        msg
       end
     end
   end

data/lib/lrama/state/shift_reduce_conflict.rb

@@ -1,8 +1,21 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Lrama
   class State
-    class ShiftReduceConflict < Struct.new(:symbols, :shift, :reduce, keyword_init: true)
+    class ShiftReduceConflict
+      attr_reader :symbols #: Array[Grammar::Symbol]
+      attr_reader :shift #: State::Action::Shift
+      attr_reader :reduce #: State::Action::Reduce
+
+      # @rbs (symbols: Array[Grammar::Symbol], shift: State::Action::Shift, reduce: State::Action::Reduce) -> void
+      def initialize(symbols:, shift:, reduce:)
+        @symbols = symbols
+        @shift = shift
+        @reduce = reduce
+      end
+
+      # @rbs () -> :shift_reduce
       def type
         :shift_reduce
       end