lrama 0.7.0 → 0.7.1

data/lib/lrama/state.rb

@@ -1,17 +1,62 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
-require_relative "state/reduce"
+require_relative "state/action"
+require_relative "state/inadequacy_annotation"
+require_relative "state/item"
 require_relative "state/reduce_reduce_conflict"
 require_relative "state/resolved_conflict"
-require_relative "state/shift"
 require_relative "state/shift_reduce_conflict"
 
 module Lrama
   class State
-    attr_reader :id, :accessing_symbol, :kernels, :conflicts, :resolved_conflicts,
-                :default_reduction_rule, :closure, :items
-    attr_accessor :shifts, :reduces, :ielr_isocores, :lalr_isocore
-
+    # 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!
+    #   type conflict = State::ShiftReduceConflict | State::ReduceReduceConflict
+    #   type transition = Action::Shift | Action::Goto
+    #   type lookahead_set = Hash[Item, Array[Grammar::Symbol]]
+    #
+    #   @id: Integer
+    #   @accessing_symbol: Grammar::Symbol
+    #   @kernels: Array[Item]
+    #   @items: Array[Item]
+    #   @items_to_state: Hash[Array[Item], State]
+    #   @conflicts: Array[conflict]
+    #   @resolved_conflicts: Array[ResolvedConflict]
+    #   @default_reduction_rule: Grammar::Rule?
+    #   @closure: Array[Item]
+    #   @nterm_transitions: Array[Action::Goto]
+    #   @term_transitions: Array[Action::Shift]
+    #   @transitions: Array[transition]
+    #   @internal_dependencies: Hash[Action::Goto, Array[Action::Goto]]
+    #   @successor_dependencies: Hash[Action::Goto, Array[Action::Goto]]
+
+    attr_reader :id #: Integer
+    attr_reader :accessing_symbol #: Grammar::Symbol
+    attr_reader :kernels #: Array[Item]
+    attr_reader :conflicts #: Array[conflict]
+    attr_reader :resolved_conflicts #: Array[ResolvedConflict]
+    attr_reader :default_reduction_rule #: Grammar::Rule?
+    attr_reader :closure #: Array[Item]
+    attr_reader :items #: Array[Item]
+    attr_reader :annotation_list #: Array[InadequacyAnnotation]
+    attr_reader :predecessors #: Array[State]
+    attr_reader :items_to_state #: Hash[Array[Item], State]
+    attr_reader :lane_items #: Hash[State, Array[[Item, Item]]]
+
+    attr_accessor :_transitions #: Array[[Grammar::Symbol, Array[Item]]]
+    attr_accessor :reduces #: Array[Action::Reduce]
+    attr_accessor :ielr_isocores #: Array[State]
+    attr_accessor :lalr_isocore #: State
+    attr_accessor :lookaheads_recomputed #: bool
+    attr_accessor :follow_kernel_items #: Hash[Action::Goto, Hash[Item, bool]]
+    attr_accessor :always_follows #: Hash[Action::Goto, Array[Grammar::Symbol]]
+    attr_accessor :goto_follows #: Hash[Action::Goto, Array[Grammar::Symbol]]
+
+    # @rbs (Integer id, Grammar::Symbol accessing_symbol, Array[Item] kernels) -> void
     def initialize(id, accessing_symbol, kernels)
       @id = id
       @accessing_symbol = accessing_symbol
@@ -28,48 +73,72 @@ module Lrama
       @ielr_isocores = [self]
       @internal_dependencies = {}
       @successor_dependencies = {}
+      @annotation_list = []
+      @lookaheads_recomputed = false
+      @follow_kernel_items = {}
       @always_follows = {}
+      @goto_follows = {}
+      @lhs_contributions = {}
+      @lane_items = {}
+    end
+
+    # @rbs (State other) -> bool
+    def ==(other)
+      self.id == other.id
     end
 
+    # @rbs (Array[Item] closure) -> void
     def closure=(closure)
       @closure = closure
       @items = @kernels + @closure
     end
 
+    # @rbs () -> Array[Action::Reduce]
     def non_default_reduces
       reduces.reject do |reduce|
         reduce.rule == @default_reduction_rule
       end
     end
 
-    def compute_shifts_reduces
-      _shifts = {}
+    # @rbs () -> void
+    def compute_transitions_and_reduces
+      _transitions = {}
+      @_lane_items ||= {}
       reduces = []
       items.each do |item|
         # TODO: Consider what should be pushed
         if item.end_of_rule?
-          reduces << Reduce.new(item)
+          reduces << Action::Reduce.new(item)
         else
           key = item.next_sym
-          _shifts[key] ||= []
-          _shifts[key] << item.new_by_next_position
+          _transitions[key] ||= []
+          @_lane_items[key] ||= []
+          next_item = item.new_by_next_position
+          _transitions[key] << next_item
+          @_lane_items[key] << [item, next_item]
         end
       end
 
       # It seems Bison 3.8.2 iterates transitions order by symbol number
-      shifts = _shifts.sort_by do |next_sym, new_items|
+      transitions = _transitions.sort_by do |next_sym, to_items|
         next_sym.number
-      end.map do |next_sym, new_items|
-        Shift.new(next_sym, new_items.flatten)
       end
-      self.shifts = shifts.freeze
+
+      self._transitions = transitions.freeze
       self.reduces = reduces.freeze
     end
 
+    # @rbs (Grammar::Symbol next_sym, State next_state) -> void
+    def set_lane_items(next_sym, next_state)
+      @lane_items[next_state] = @_lane_items[next_sym]
+    end
+
+    # @rbs (Array[Item] items, State next_state) -> void
     def set_items_to_state(items, next_state)
       @items_to_state[items] = next_state
     end
 
+    # @rbs (Grammar::Rule rule, Array[Grammar::Symbol] look_ahead) -> void
     def set_look_ahead(rule, look_ahead)
       reduce = reduces.find do |r|
         r.rule == rule
@@ -78,50 +147,78 @@ module Lrama
       reduce.look_ahead = look_ahead
     end
 
-    def nterm_transitions
-      @nterm_transitions ||= transitions.select {|shift, _| shift.next_sym.nterm? }
+    # @rbs (Grammar::Rule rule, Hash[Grammar::Symbol, Array[Action::Goto]] sources) -> void
+    def set_look_ahead_sources(rule, sources)
+      reduce = reduces.find do |r|
+        r.rule == rule
+      end
+
+      reduce.look_ahead_sources = sources
+    end
+
+    # @rbs () -> Array[Action::Goto]
+    def nterm_transitions # steep:ignore
+      @nterm_transitions ||= transitions.select {|transition| transition.is_a?(Action::Goto) }
     end
 
-    def term_transitions
-      @term_transitions ||= transitions.select {|shift, _| shift.next_sym.term? }
+    # @rbs () -> Array[Action::Shift]
+    def term_transitions # steep:ignore
+      @term_transitions ||= transitions.select {|transition| transition.is_a?(Action::Shift) }
     end
 
+    # @rbs () -> Array[transition]
     def transitions
-      @transitions ||= shifts.map {|shift| [shift, @items_to_state[shift.next_items]] }
+      @transitions ||= _transitions.map do |next_sym, to_items|
+        if next_sym.term?
+          Action::Shift.new(self, next_sym, to_items.flatten, @items_to_state[to_items])
+        else
+          Action::Goto.new(self, next_sym, to_items.flatten, @items_to_state[to_items])
+        end
+      end
     end
 
-    def update_transition(shift, next_state)
-      set_items_to_state(shift.next_items, next_state)
+    # @rbs (transition transition, State next_state) -> void
+    def update_transition(transition, next_state)
+      set_items_to_state(transition.to_items, next_state)
       next_state.append_predecessor(self)
-      clear_transitions_cache
+      update_transitions_caches(transition)
     end
 
-    def clear_transitions_cache
+    # @rbs () -> void
+    def update_transitions_caches(transition)
+      new_transition =
+        if transition.next_sym.term?
+          Action::Shift.new(self, transition.next_sym, transition.to_items, @items_to_state[transition.to_items])
+        else
+          Action::Goto.new(self, transition.next_sym, transition.to_items, @items_to_state[transition.to_items])
+        end
+
+      @transitions.delete(transition)
+      @transitions << new_transition
       @nterm_transitions = nil
       @term_transitions = nil
-      @transitions = nil
+
+      @follow_kernel_items[new_transition] = @follow_kernel_items.delete(transition)
+      @always_follows[new_transition] = @always_follows.delete(transition)
     end
 
+    # @rbs () -> Array[Action::Shift]
     def selected_term_transitions
-      term_transitions.reject do |shift, next_state|
+      term_transitions.reject do |shift|
         shift.not_selected
       end
     end
 
     # Move to next state by sym
+    #
+    # @rbs (Grammar::Symbol sym) -> State
     def transition(sym)
       result = nil
 
       if sym.term?
-        term_transitions.each do |shift, next_state|
-          term = shift.next_sym
-          result = next_state if term == sym
-        end
+        result = term_transitions.find {|shift| shift.next_sym == sym }.to_state
       else
-        nterm_transitions.each do |shift, next_state|
-          nterm = shift.next_sym
-          result = next_state if nterm == sym
-        end
+        result = nterm_transitions.find {|goto| goto.next_sym == sym }.to_state
       end
 
       raise "Can not transit by #{sym} #{self}" if result.nil?
@@ -129,12 +226,14 @@ module Lrama
       result
     end
 
+    # @rbs (Item item) -> Action::Reduce
     def find_reduce_by_item!(item)
       reduces.find do |r|
         r.item == item
       end || (raise "reduce is not found. #{item}")
     end
 
+    # @rbs (Grammar::Rule default_reduction_rule) -> void
     def default_reduction_rule=(default_reduction_rule)
       @default_reduction_rule = default_reduction_rule
 
@@ -145,200 +244,219 @@ module Lrama
       end
     end
 
+    # @rbs () -> bool
     def has_conflicts?
       !@conflicts.empty?
     end
 
+    # @rbs () -> Array[conflict]
     def sr_conflicts
       @conflicts.select do |conflict|
         conflict.type == :shift_reduce
       end
     end
 
+    # @rbs () -> Array[conflict]
     def rr_conflicts
       @conflicts.select do |conflict|
         conflict.type == :reduce_reduce
       end
     end
 
+    # Clear information related to conflicts.
+    # IELR computation re-calculates conflicts and default reduction of states
+    # after LALR computation.
+    # Call this method before IELR computation to avoid duplicated conflicts information
+    # is stored.
+    #
+    # @rbs () -> void
+    def clear_conflicts
+      @conflicts = []
+      @resolved_conflicts = []
+      @default_reduction_rule = nil
+
+      term_transitions.each(&:clear_conflicts)
+      reduces.each(&:clear_conflicts)
+    end
+
+    # @rbs () -> bool
+    def split_state?
+      @lalr_isocore != self
+    end
+
+    # Definition 3.40 (propagate_lookaheads)
+    #
+    # @rbs (State next_state) -> lookahead_set
     def propagate_lookaheads(next_state)
-      next_state.kernels.map {|item|
+      next_state.kernels.map {|next_kernel|
         lookahead_sets =
-          if item.position == 1
-            goto_follow_set(item.lhs)
-          else
-            kernel = kernels.find {|k| k.predecessor_item_of?(item) }
+          if next_kernel.position > 1
+            kernel = kernels.find {|k| k.predecessor_item_of?(next_kernel) }
             item_lookahead_set[kernel]
+          else
+            goto_follow_set(next_kernel.lhs)
           end
 
-        [item, lookahead_sets & next_state.lookahead_set_filters[item]]
+        [next_kernel, lookahead_sets & next_state.lookahead_set_filters[next_kernel]]
       }.to_h
     end
 
-    def lookaheads_recomputed
-      !@item_lookahead_set.nil?
-    end
-
-    def compatible_lookahead?(filtered_lookahead)
+    # Definition 3.43 (is_compatible)
+    #
+    # @rbs (lookahead_set filtered_lookahead) -> bool
+    def is_compatible?(filtered_lookahead)
       !lookaheads_recomputed ||
-        @lalr_isocore.annotation_list.all? {|token, actions|
-          a = dominant_contribution(token, actions, item_lookahead_set)
-          b = dominant_contribution(token, actions, filtered_lookahead)
+        @lalr_isocore.annotation_list.all? {|annotation|
+          a = annotation.dominant_contribution(item_lookahead_set)
+          b = annotation.dominant_contribution(filtered_lookahead)
           a.nil? || b.nil? || a == b
         }
     end
 
+    # Definition 3.38 (lookahead_set_filters)
+    #
+    # @rbs () -> lookahead_set
     def lookahead_set_filters
-      kernels.map {|kernel|
-        [kernel,
-         @lalr_isocore.annotation_list.select {|token, actions|
-           token.term? && actions.any? {|action, contributions|
-             !contributions.nil? && contributions.key?(kernel) && contributions[kernel]
-           }
-         }.map {|token, _| token }
-        ]
+      @lookahead_set_filters ||= kernels.map {|kernel|
+        [kernel, @lalr_isocore.annotation_list.select {|annotation| annotation.contributed?(kernel) }.map(&:token)]
       }.to_h
     end
 
-    def dominant_contribution(token, actions, lookaheads)
-      a = actions.select {|action, contributions|
-        contributions.nil? || contributions.any? {|item, contributed| contributed && lookaheads[item].include?(token) }
-      }.map {|action, _| action }
-      return nil if a.empty?
-      a.reject {|action|
-        if action.is_a?(State::Shift)
-          action.not_selected
-        elsif action.is_a?(State::Reduce)
-          action.not_selected_symbols.include?(token)
-        end
-      }
-    end
-
+    # Definition 3.27 (inadequacy_lists)
+    #
+    # @rbs () -> Hash[Grammar::Symbol, Array[Action::Shift | Action::Reduce]]
     def inadequacy_list
       return @inadequacy_list if @inadequacy_list
 
-      shift_contributions = shifts.map {|shift|
-        [shift.next_sym, [shift]]
-      }.to_h
-      reduce_contributions = reduces.map {|reduce|
-        (reduce.look_ahead || []).map {|sym|
-          [sym, [reduce]]
-        }.to_h
-      }.reduce(Hash.new([])) {|hash, cont|
-        hash.merge(cont) {|_, a, b| a | b }
-      }
+      inadequacy_list = {}
 
-      list = shift_contributions.merge(reduce_contributions) {|_, a, b| a | b }
-      @inadequacy_list = list.select {|token, actions| token.term? && actions.size > 1 }
-    end
-
-    def annotation_list
-      return @annotation_list if @annotation_list
-
-      @annotation_list = annotate_manifestation
-      @annotation_list = @items_to_state.values.map {|next_state| next_state.annotate_predecessor(self) }
-        .reduce(@annotation_list) {|result, annotations|
-          result.merge(annotations) {|_, actions_a, actions_b|
-            if actions_a.nil? || actions_b.nil?
-              actions_a || actions_b
-            else
-              actions_a.merge(actions_b) {|_, contributions_a, contributions_b|
-                if contributions_a.nil? || contributions_b.nil?
-                  next contributions_a || contributions_b
-                end
-
-                contributions_a.merge(contributions_b) {|_, contributed_a, contributed_b|
-                  contributed_a || contributed_b
-                }
-              }
-            end
-          }
-        }
+      term_transitions.each do |shift|
+        inadequacy_list[shift.next_sym] ||= []
+        inadequacy_list[shift.next_sym] << shift.dup
+      end
+      reduces.each do |reduce|
+        next if reduce.look_ahead.nil?
+
+        reduce.look_ahead.each do |token|
+          inadequacy_list[token] ||= []
+          inadequacy_list[token] << reduce.dup
+        end
+      end
+
+      @inadequacy_list = inadequacy_list.select {|token, actions| actions.size > 1 }
     end
 
+    # Definition 3.30 (annotate_manifestation)
+    #
+    # @rbs () -> void
     def annotate_manifestation
-      inadequacy_list.transform_values {|actions|
-        actions.map {|action|
-          if action.is_a?(Shift)
+      inadequacy_list.each {|token, actions|
+        contribution_matrix = actions.map {|action|
+          if action.is_a?(Action::Shift)
             [action, nil]
-          elsif action.is_a?(Reduce)
-            if action.rule.empty_rule?
-              [action, lhs_contributions(action.rule.lhs, inadequacy_list.key(actions))]
-            else
-              contributions = kernels.map {|kernel| [kernel, kernel.rule == action.rule && kernel.end_of_rule?] }.to_h
-              [action, contributions]
-            end
+          else
+            [action, action.rule.empty_rule? ? lhs_contributions(action.rule.lhs, token) : kernels.map {|k| [k, k.rule == action.item.rule && k.end_of_rule?] }.to_h]
           end
         }.to_h
+        @annotation_list << InadequacyAnnotation.new(self, token, actions, contribution_matrix)
       }
     end
 
+    # Definition 3.32 (annotate_predecessor)
+    #
+    # @rbs (State predecessor) -> void
     def annotate_predecessor(predecessor)
-      annotation_list.transform_values {|actions|
-        token = annotation_list.key(actions)
-        actions.transform_values {|inadequacy|
-          next nil if inadequacy.nil?
-          lhs_adequacy = kernels.any? {|kernel|
-            inadequacy[kernel] && kernel.position == 1 && predecessor.lhs_contributions(kernel.lhs, token).nil?
-          }
-          if lhs_adequacy
-            next nil
+      propagating_list = annotation_list.map {|annotation|
+        contribution_matrix = annotation.contribution_matrix.map {|action, contributions|
+          if contributions.nil?
+            [action, nil]
+          elsif first_kernels.any? {|kernel| contributions[kernel] && predecessor.lhs_contributions(kernel.lhs, annotation.token).empty? }
+            [action, nil]
           else
-            predecessor.kernels.map {|pred_k|
-              [pred_k, kernels.any? {|k|
-                inadequacy[k] && (
-                  pred_k.predecessor_item_of?(k) && predecessor.item_lookahead_set[pred_k].include?(token) ||
-                  k.position == 1 && predecessor.lhs_contributions(k.lhs, token)[pred_k]
-                )
-              }]
+            cs = predecessor.lane_items[self].map {|pred_kernel, kernel|
+              c = contributions[kernel] && (
+                (kernel.position > 1 && predecessor.item_lookahead_set[pred_kernel].include?(annotation.token)) ||
+                (kernel.position == 1 && predecessor.lhs_contributions(kernel.lhs, annotation.token)[pred_kernel])
+              )
+              [pred_kernel, c]
             }.to_h
+            [action, cs]
           end
-        }
-      }
+        }.to_h
+
+        # Observation 3.33 (Simple Split-Stable Dominance)
+        #
+        # If all of contributions in the contribution_matrix are
+        # always contribution or never contribution, we can stop annotate propagations
+        # to the predecessor state.
+        next nil if contribution_matrix.all? {|_, contributions| contributions.nil? || contributions.all? {|_, contributed| !contributed } }
+
+        InadequacyAnnotation.new(annotation.state, annotation.token, annotation.actions, contribution_matrix)
+      }.compact
+      predecessor.append_annotation_list(propagating_list)
     end
 
-    def lhs_contributions(sym, token)
-      shift, next_state = nterm_transitions.find {|sh, _| sh.next_sym == sym }
-      if always_follows(shift, next_state).include?(token)
-        nil
-      else
-        kernels.map {|kernel| [kernel, follow_kernel_items(shift, next_state, kernel) && item_lookahead_set[kernel].include?(token)] }.to_h
-      end
+    # @rbs () -> Array[Item]
+    def first_kernels
+      @first_kernels ||= kernels.select {|kernel| kernel.position == 1 }
     end
 
-    def follow_kernel_items(shift, next_state, kernel)
-      queue = [[self, shift, next_state]]
-      until queue.empty?
-        st, sh, next_st = queue.pop
-        return true if kernel.next_sym == sh.next_sym && kernel.symbols_after_transition.all?(&:nullable)
-        st.internal_dependencies(sh, next_st).each {|v| queue << v }
+    # @rbs (Array[InadequacyAnnotation] propagating_list) -> void
+    def append_annotation_list(propagating_list)
+      annotation_list.each do |annotation|
+        merging_list = propagating_list.select {|a| a.state == annotation.state && a.token == annotation.token && a.actions == annotation.actions }
+        annotation.merge_matrix(merging_list.map(&:contribution_matrix))
+        propagating_list -= merging_list
       end
-      false
+
+      @annotation_list += propagating_list
     end
 
+    # Definition 3.31 (compute_lhs_contributions)
+    #
+    # @rbs (Grammar::Symbol sym, Grammar::Symbol token) -> (nil | Hash[Item, bool])
+    def lhs_contributions(sym, token)
+      return @lhs_contributions[sym][token] unless @lhs_contributions.dig(sym, token).nil?
+
+      transition = nterm_transitions.find {|goto| goto.next_sym == sym }
+      @lhs_contributions[sym] ||= {}
+      @lhs_contributions[sym][token] =
+        if always_follows[transition].include?(token)
+          {}
+        else
+          kernels.map {|kernel| [kernel, follow_kernel_items[transition][kernel] && item_lookahead_set[kernel].include?(token)] }.to_h
+        end
+    end
+
+    # Definition 3.26 (item_lookahead_sets)
+    #
+    # @rbs () -> lookahead_set
     def item_lookahead_set
       return @item_lookahead_set if @item_lookahead_set
 
-      kernels.map {|item|
+      @item_lookahead_set = kernels.map {|k| [k, []] }.to_h
+      @item_lookahead_set = kernels.map {|kernel|
         value =
-          if item.lhs.accept_symbol?
+          if kernel.lhs.accept_symbol?
             []
-          elsif item.position > 1
-            prev_items = predecessors_with_item(item)
+          elsif kernel.position > 1
+            prev_items = predecessors_with_item(kernel)
             prev_items.map {|st, i| st.item_lookahead_set[i] }.reduce([]) {|acc, syms| acc |= syms }
-          elsif item.position == 1
-            prev_state = @predecessors.find {|p| p.shifts.any? {|shift| shift.next_sym == item.lhs } }
-            shift, next_state = prev_state.nterm_transitions.find {|shift, _| shift.next_sym == item.lhs }
-            prev_state.goto_follows(shift, next_state)
+          elsif kernel.position == 1
+            prev_state = @predecessors.find {|p| p.transitions.any? {|transition| transition.next_sym == kernel.lhs } }
+            goto = prev_state.nterm_transitions.find {|goto| goto.next_sym == kernel.lhs }
+            prev_state.goto_follows[goto]
           end
-        [item, value]
+        [kernel, value]
       }.to_h
     end
 
+    # @rbs (lookahead_set k) -> void
     def item_lookahead_set=(k)
       @item_lookahead_set = k
     end
 
+    # @rbs (Item item) -> Array[[State, Item]]
     def predecessors_with_item(item)
       result = []
       @predecessors.each do |pre|
@@ -349,69 +467,53 @@ module Lrama
       result
     end
 
+    # @rbs (State prev_state) -> void
     def append_predecessor(prev_state)
       @predecessors << prev_state
       @predecessors.uniq!
     end
 
+    # Definition 3.39 (compute_goto_follow_set)
+    #
+    # @rbs (Grammar::Symbol nterm_token) -> Array[Grammar::Symbol]
     def goto_follow_set(nterm_token)
       return [] if nterm_token.accept_symbol?
-      shift, next_state = @lalr_isocore.nterm_transitions.find {|sh, _| sh.next_sym == nterm_token }
+      goto = @lalr_isocore.nterm_transitions.find {|g| g.next_sym == nterm_token }
 
       @kernels
-        .select {|kernel| follow_kernel_items(shift, next_state, kernel) }
+        .select {|kernel| @lalr_isocore.follow_kernel_items[goto][kernel] }
         .map {|kernel| item_lookahead_set[kernel] }
-        .reduce(always_follows(shift, next_state)) {|result, terms| result |= terms }
-    end
-
-    def goto_follows(shift, next_state)
-      queue = internal_dependencies(shift, next_state) + predecessor_dependencies(shift, next_state)
-      terms = always_follows(shift, next_state)
-      until queue.empty?
-        st, sh, next_st = queue.pop
-        terms |= st.always_follows(sh, next_st)
-        st.internal_dependencies(sh, next_st).each {|v| queue << v }
-        st.predecessor_dependencies(sh, next_st).each {|v| queue << v }
-      end
-      terms
-    end
-
-    def always_follows(shift, next_state)
-      return @always_follows[[shift, next_state]] if @always_follows[[shift, next_state]]
-
-      queue = internal_dependencies(shift, next_state) + successor_dependencies(shift, next_state)
-      terms = []
-      until queue.empty?
-        st, sh, next_st = queue.pop
-        terms |= next_st.term_transitions.map {|sh, _| sh.next_sym }
-        st.internal_dependencies(sh, next_st).each {|v| queue << v }
-        st.successor_dependencies(sh, next_st).each {|v| queue << v }
-      end
-      @always_follows[[shift, next_state]] = terms
+        .reduce(@lalr_isocore.always_follows[goto]) {|result, terms| result |= terms }
     end
 
-    def internal_dependencies(shift, next_state)
-      return @internal_dependencies[[shift, next_state]] if @internal_dependencies[[shift, next_state]]
+    # Definition 3.8 (Goto Follows Internal Relation)
+    #
+    # @rbs (Action::Goto goto) -> Array[Action::Goto]
+    def internal_dependencies(goto)
+      return @internal_dependencies[goto] if @internal_dependencies[goto]
 
       syms = @items.select {|i|
-        i.next_sym == shift.next_sym && i.symbols_after_transition.all?(&:nullable) && i.position == 0
+        i.next_sym == goto.next_sym && i.symbols_after_transition.all?(&:nullable) && i.position == 0
       }.map(&:lhs).uniq
-      @internal_dependencies[[shift, next_state]] = nterm_transitions.select {|sh, _| syms.include?(sh.next_sym) }.map {|goto| [self, *goto] }
+      @internal_dependencies[goto] = nterm_transitions.select {|goto2| syms.include?(goto2.next_sym) }
     end
 
-    def successor_dependencies(shift, next_state)
-      return @successor_dependencies[[shift, next_state]] if @successor_dependencies[[shift, next_state]]
+    # Definition 3.5 (Goto Follows Successor Relation)
+    #
+    # @rbs (Action::Goto goto) -> Array[Action::Goto]
+    def successor_dependencies(goto)
+      return @successor_dependencies[goto] if @successor_dependencies[goto]
 
-      @successor_dependencies[[shift, next_state]] =
-        next_state.nterm_transitions
-        .select {|next_shift, _| next_shift.next_sym.nullable }
-        .map {|transition| [next_state, *transition] }
+      @successor_dependencies[goto] = goto.to_state.nterm_transitions.select {|next_goto| next_goto.next_sym.nullable }
     end
 
-    def predecessor_dependencies(shift, next_state)
+    # Definition 3.9 (Goto Follows Predecessor Relation)
+    #
+    # @rbs (Action::Goto goto) -> Array[Action::Goto]
+    def predecessor_dependencies(goto)
       state_items = []
       @kernels.select {|kernel|
-        kernel.next_sym == shift.next_sym && kernel.symbols_after_transition.all?(&:nullable)
+        kernel.next_sym == goto.next_sym && kernel.symbols_after_transition.all?(&:nullable)
       }.each do |item|
         queue = predecessors_with_item(item)
         until queue.empty?
@@ -425,8 +527,7 @@ module Lrama
       end
 
       state_items.map {|state, item|
-        sh, next_st = state.nterm_transitions.find {|shi, _| shi.next_sym == item.lhs }
-        [state, sh, next_st]
+        state.nterm_transitions.find {|goto2| goto2.next_sym == item.lhs }
       }
     end
   end