ibex 0.2.0 → 0.3.0

data/lib/ibex/lalr/ielr/state_splitter.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+# steep:ignore:start
+
+require "set"
+require_relative "bits"
+require_relative "split_state"
+require_relative "annotator"
+require_relative "split_stability"
+
+module Ibex
+  module LALR
+    module IELR
+      # Splits LR(0) isocores only where an inadequacy would change the
+      # resolved action.  New states copy their transition arrays; no mutable
+      # transition table is shared between isocores.
+      class StateSplitter
+        attr_reader :annotations #: Array[Array[Annotation]]
+        attr_reader :states #: Array[SplitState]
+        attr_reader :lalr_isocores #: Array[Integer]
+        attr_reader :split_states #: Integer
+        attr_reader :inadequacies #: Array[Array[Inadequacy]]
+        attr_reader :split_stable_discarded #: Integer
+
+        # @rbs (IR::Grammar grammar, Array[core_set] states, transitions transitions,
+        #   Array[packed_items] items, GotoFollows goto_follows, ?resolver: ConflictResolver?) -> void
+        # rubocop:disable Metrics/AbcSize -- initialization wires the phase tables once.
+        def initialize(grammar, states, transitions, items, goto_follows, resolver: nil)
+          @grammar = grammar
+          @base_states = states
+          @base_transitions = transitions
+          @base_items = items
+          @goto_follows = goto_follows
+          @resolver = resolver || ConflictResolver.new(grammar)
+          @kernel_cores = states.map { |state| kernel_items(state) }
+          annotator = Annotator.new(grammar, states, transitions, items, goto_follows, resolver: @resolver)
+          @annotations = annotator.build
+          @inadequacies = annotator.inadequacies
+          @split_stable_discarded = annotator.split_stable_discarded
+          @item_lookaheads = annotator.item_lookaheads
+          @states = states.each_with_index.map do |_state, state_id|
+            SplitState.new(core: @kernel_cores.fetch(state_id),
+                           transitions: transitions.fetch(state_id).sort_by(&:first).map(&:dup),
+                           lalr_isocore: state_id)
+          end
+          @lalr_isocores = states.each_index.to_a
+          @isocore_nexts = states.each_index.to_a
+          @lookaheads_recomputed = Array.new(states.length, false)
+          @lookahead_sets = states.each_with_index.map do |_state, state_id|
+            @kernel_cores.fetch(state_id).each_index.map do |index|
+              @item_lookaheads.fetch(state_id, index)
+            end
+          end
+          @filters = {}
+          @split_states = 0
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        # @rbs () -> [Array[packed_items], transitions]
+        def build
+          state_id = 0
+          while state_id < @states.length
+            @states.fetch(state_id).transitions.each_index do |index|
+              target = @states.fetch(state_id).transitions.fetch(index).fetch(1)
+              compute_state(state_id, target, index)
+            end
+            state_id += 1
+          end
+          [pack_items, packed_transitions]
+        end
+
+        private
+
+        # @rbs (Integer from_id, Integer to_id, Integer transition_index) -> void
+        def compute_state(from_id, to_id, transition_index)
+          incoming = propagate_lookaheads(from_id, to_id)
+          target = to_id
+          found = false
+          loop do
+            if compatible?(target, incoming)
+              found = true
+              break
+            end
+            break if @isocore_nexts.fetch(target) == to_id
+
+            target = @isocore_nexts.fetch(target)
+          end
+
+          if !found
+            target = append_isocore(target, incoming)
+          elsif !@lookaheads_recomputed.fetch(target)
+            raise Ibex::Error, "IELR target changed before initial lookahead computation" unless target == to_id
+
+            @lookahead_sets[target] = incoming
+            @lookaheads_recomputed[target] = true
+          else
+            merge_lookaheads(target, incoming)
+          end
+          @states.fetch(from_id).transitions.fetch(transition_index)[1] = target
+        end
+
+        # @rbs (Integer from_id, Integer to_id) -> Array[Integer]
+        def propagate_lookaheads(from_id, to_id)
+          filters = lookahead_set_filters(to_id)
+          @kernel_cores.fetch(to_id).each_with_index.map do |(production_id, dot), index|
+            bits = if dot > 1
+                     previous = kernel_index_of(from_id, production_id, dot - 1)
+                     previous ? @lookahead_sets.fetch(from_id).fetch(previous) : 0
+                   elsif dot == 1
+                     compute_goto_follow_set(from_id, lhs_for(production_id))
+                   else
+                     raise Ibex::Error, "IELR transition produced a dot-zero kernel"
+                   end
+            bits & filters.fetch(index)
+          end
+        end
+
+        # @rbs (Integer state_id, Integer nonterminal_id) -> Integer
+        def compute_goto_follow_set(state_id, nonterminal_id)
+          goto_id = @goto_follows.goto_for(@lalr_isocores.fetch(state_id), nonterminal_id)
+          raise Ibex::Error, "missing GOTO for #{nonterminal_id} from #{state_id}" unless goto_id
+
+          bits = @goto_follows.always_follows.fetch(goto_id)
+          Bits.each_set_bit(@goto_follows.follow_kernel_items.fetch(goto_id)) do |index|
+            bits |= @lookahead_sets.fetch(state_id).fetch(index)
+          end
+          bits
+        end
+
+        # @rbs (Integer state_id) -> Array[Integer]
+        def lookahead_set_filters(state_id)
+          core_id = @lalr_isocores.fetch(state_id)
+          return @filters.fetch(core_id) if @filters.key?(core_id)
+
+          filters = Array.new(@kernel_cores.fetch(core_id).length, 0)
+          @annotations.fetch(core_id).each do |annotation|
+            token_bit = 1 << annotation.inadequacy.token
+            annotation.matrix.each do |row|
+              next if row.nil?
+
+              Bits.each_set_bit(row) { |index| filters[index] |= token_bit }
+            end
+          end
+          @filters[core_id] = filters
+        end
+
+        # @rbs (Integer state_id, Array[Integer]) -> bool
+        def compatible?(state_id, incoming)
+          return true unless @lookaheads_recomputed.fetch(state_id)
+
+          @annotations.fetch(@lalr_isocores.fetch(state_id)).all? do |annotation|
+            current = dominant_contribution(annotation, @lookahead_sets.fetch(state_id))
+            next true unless current
+
+            candidate = dominant_contribution(annotation, incoming)
+            !candidate || current == candidate
+          end
+        end
+
+        # @rbs (Annotation, Array[Integer]) -> Object?
+        def dominant_contribution(annotation, lookaheads)
+          token_bit = 1 << annotation.inadequacy.token
+          selected = annotation.inadequacy.contributions.each_index.select do |index|
+            row = annotation.matrix.fetch(index)
+            row.nil? || Bits.each_set_bit(row).any? { |kernel| lookaheads.fetch(kernel).anybits?(token_bit) }
+          end
+          return nil if selected.empty?
+
+          contributions = selected.map { |index| annotation.inadequacy.contributions.fetch(index) }
+          SplitStability.resolve(@resolver, annotation.inadequacy.token, contributions)
+        end
+
+        # @rbs (Integer after_id, Array[Integer]) -> Integer
+        def append_isocore(after_id, lookaheads)
+          source = @states.fetch(after_id)
+          @states << SplitState.new(
+            core: source.core.dup,
+            transitions: source.transitions.map(&:dup),
+            lalr_isocore: @lalr_isocores.fetch(after_id)
+          )
+          appended = @states.length - 1
+          @lalr_isocores << @lalr_isocores.fetch(after_id)
+          @isocore_nexts << @isocore_nexts.fetch(after_id)
+          @isocore_nexts[after_id] = appended
+          @lookaheads_recomputed << true
+          @lookahead_sets << lookaheads
+          @split_states += 1
+          appended
+        end
+
+        # @rbs (Integer state_id, Array[Integer]) -> void
+        def merge_lookaheads(state_id, incoming)
+          changed = false
+          incoming.each_with_index do |bits, index|
+            added = bits & ~@lookahead_sets.fetch(state_id).fetch(index)
+            next if added.zero?
+
+            @lookahead_sets.fetch(state_id)[index] |= added
+            changed = true
+          end
+          return unless changed
+
+          @states.fetch(state_id).transitions.each_index do |index|
+            target = @states.fetch(state_id).transitions.fetch(index).fetch(1)
+            break unless @lookaheads_recomputed.fetch(target)
+
+            compute_state(state_id, target, index)
+          end
+        end
+
+        # @rbs () -> Array[packed_items]
+        def pack_items
+          @states.each_with_index.map do |state, state_id|
+            packed = Hash.new { |hash, key| hash[key] = Set.new }
+            @base_items.fetch(state.lalr_isocore).each do |core, values|
+              packed[core].merge(values)
+            end
+            state.core.each_with_index do |core, index|
+              packed[core] = Set.new(Bits.each_set_bit(@lookahead_sets.fetch(state_id).fetch(index)).to_a)
+            end
+            packed
+          end
+        end
+
+        # @rbs () -> transitions
+        def packed_transitions
+          @states.map { |state| state.transitions.to_h { |symbol, target| [symbol, target] } }
+        end
+
+        # @rbs (core_set items) -> Array[item_core]
+        def kernel_items(items)
+          items.select { |production_id, dot| production_id.negative? || dot.positive? }.to_a.sort
+        end
+
+        # @rbs (Integer state_id, Integer production_id, Integer dot) -> Integer?
+        def kernel_index_of(state_id, production_id, dot)
+          @kernel_cores.fetch(@lalr_isocores.fetch(state_id)).index([production_id, dot])
+        end
+
+        # @rbs (Integer production_id) -> Integer
+        def lhs_for(production_id)
+          return @grammar.symbol(@grammar.starts.fetch(-production_id - 1)).id if production_id.negative?
+
+          @grammar.productions.fetch(production_id).lhs
+        end
+
+        # @rbs (Integer production_id) -> Array[Integer]
+        def rhs_for(production_id)
+          return [lhs_for(production_id)] if production_id.negative?
+
+          @grammar.productions.fetch(production_id).rhs
+        end
+      end
+    end
+  end
+end
+# steep:ignore:end

data/lib/ibex/lalr/ielr_partition.rb

@@ -8,24 +8,38 @@ module Ibex
     # Deterministically merges compatible canonical LR(1) states and splits
     # partitions until their outgoing transitions are congruent.
     class IELRPartition
+      # @rbs! type contribution_action = [:shift] | [:reduce, Integer] | [:accept]
+
       AUGMENTED_PRODUCTION = -1 #: Integer
 
       # @rbs @grammar: IR::Grammar
       # @rbs @states: Array[item_set]
       # @rbs @transitions: transitions
-      # @rbs @contributions: Array[Hash[Integer, Set[Array[untyped]]]]
+      # @rbs @contributions: Array[Hash[Integer, Set[contribution_action]]]
+      # @rbs @initial_partition_count: Integer?
+      # @rbs @final_partition_count: Integer?
+      # @rbs @profile: bool
+
+      attr_reader :initial_partition_count #: Integer?
+      attr_reader :final_partition_count #: Integer?
 
-      # @rbs (IR::Grammar grammar, Array[item_set] states, transitions transitions) -> void
-      def initialize(grammar, states, transitions)
+      # @rbs (IR::Grammar grammar, Array[item_set] states, transitions transitions, ?profile: bool) -> void
+      def initialize(grammar, states, transitions, profile: false)
         @grammar = grammar
         @states = states
         @transitions = transitions
         @contributions = Array.new(states.length) { |state_id| action_contributions(state_id) }
+        @initial_partition_count = nil
+        @final_partition_count = nil
+        @profile = profile
       end
 
       # @rbs () -> [Array[packed_items], transitions]
       def build
-        partitions = refine_transitions(initial_partitions)
+        partitions = initial_partitions
+        @initial_partition_count = partitions.length if @profile
+        partitions = refine_transitions(partitions)
+        @final_partition_count = partitions.length if @profile
         indexes = partition_indexes(partitions)
         items = partitions.map { |members| merge_items(members) }
         transitions = partitions.map do |members|
@@ -62,7 +76,7 @@ module Ibex
       # action. Every nonempty member cell must equal the merged cell.
       # @rbs (state_partition members) -> bool
       def compatible?(members)
-        merged = Hash.new { |hash, key| hash[key] = Set.new } #: Hash[Integer, Set[Array[untyped]]]
+        merged = Hash.new { |hash, key| hash[key] = Set.new } #: Hash[Integer, Set[contribution_action]]
         members.each do |state_id|
           @contributions.fetch(state_id).each { |token_id, actions| merged[token_id].merge(actions) }
         end
@@ -114,9 +128,9 @@ module Ibex
         merged
       end
 
-      # @rbs (Integer state_id) -> Hash[Integer, Set[Array[untyped]]]
+      # @rbs (Integer state_id) -> Hash[Integer, Set[contribution_action]]
       def action_contributions(state_id)
-        actions = Hash.new { |hash, key| hash[key] = Set.new } #: Hash[Integer, Set[Array[untyped]]]
+        actions = Hash.new { |hash, key| hash[key] = Set.new } #: Hash[Integer, Set[contribution_action]]
         @transitions.fetch(state_id).each_key do |symbol_id|
           symbol = @grammar.symbol_by_id(symbol_id)
           actions[symbol_id] << [:shift] if symbol&.terminal?
@@ -124,7 +138,7 @@ module Ibex
         @states.fetch(state_id).each do |production_id, dot, lookahead|
           next unless dot == rhs_for(production_id).length
 
-          action = production_id.negative? ? [:accept] : [:reduce, production_id]
+          action = production_id.negative? ? [:accept] : [:reduce, production_id] #: contribution_action
           actions[lookahead] << action
         end
         actions

data/lib/ibex/lalr/inadequacy_report.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+# steep:ignore:start
+
+require "json"
+require_relative "../verify/action_correspondence"
+
+module Ibex
+  module LALR
+    # @rbs! type report_value = String | Symbol | Integer | bool | nil | IR::parser_action |
+    #   Array[report_value] | Hash[Symbol, report_value]
+
+    # Diagnostic-only report for canonical-vs-LALR action differences.  It is
+    # intentionally separate from normal construction because it enumerates a
+    # canonical LR(1) reference.
+    class InadequacyReport
+      # @rbs (IR::Automaton canonical, IR::Automaton target, ?max_pairs: Integer) -> void
+      def initialize(canonical, target, max_pairs: nil)
+        @canonical = canonical
+        @target = target
+        @max_pairs = max_pairs
+      end
+
+      # @rbs () -> Hash[Symbol, report_value]
+      def to_h
+        result = Verify::ActionCorrespondence.new(@canonical, @target, max_pairs: @max_pairs).verify
+        {
+          algorithm: @target.algorithm,
+          canonical_algorithm: @canonical.algorithm,
+          explored_pairs: result.explored,
+          truncated: result.truncated,
+          differences: result.differences.map do |difference|
+            {
+              kind: difference.kind, canonical_state: difference.canonical_state,
+              target_state: difference.target_state, symbol: difference.symbol,
+              canonical: difference.canonical, target: difference.target
+            }
+          end
+        }
+      end
+
+      # @rbs () -> String
+      def to_json(*)
+        "#{JSON.pretty_generate(to_h)}\n"
+      end
+    end
+  end
+end
+# steep:ignore:end

data/lib/ibex/lalr/lookahead_propagation.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+# steep:ignore:start
+
+require "set"
+
+module Ibex
+  module LALR
+    # Recomputes item lookaheads on an already-built LR(0) automaton.  This is
+    # Phase 4 of direct IELR and is also useful as an independent cross-check
+    # for DirectLookaheads.
+    class LookaheadPropagation
+      EMPTY = Array.new(0).freeze #: Array[Integer]
+
+      attr_reader :propagation_edge_count #: Integer
+
+      # @rbs (IR::Grammar grammar, Analysis::Sets sets, Array[core_set] states, transitions transitions,
+      #   seeds: Array[[Integer, item_core, Integer]]) -> Array[packed_items]
+      def initialize(grammar, sets, states, transitions, seeds:)
+        @grammar = grammar
+        @sets = sets
+        @states = states
+        @transitions = transitions
+        @seeds = seeds
+        @productions_by_lhs = grammar.productions.group_by(&:lhs)
+      end
+
+      # @rbs () -> Array[packed_items]
+      def build
+        lookaheads = @states.map { |items| items.to_h { |item| [item, Set.new] } }
+        edges = Hash.new { |hash, key| hash[key] = [] }
+        @states.each_with_index do |items, state_id|
+          items.each do |production_id, dot|
+            add_transition(edges, state_id, production_id, dot)
+            add_closure(edges, lookaheads, state_id, production_id, dot)
+          end
+        end
+        @seeds.each { |state_id, item, token| lookaheads.fetch(state_id).fetch(item) << token }
+        @propagation_edge_count = edges.values.sum(&:length)
+        propagate(lookaheads, edges)
+        lookaheads
+      end
+
+      private
+
+      # @rbs (Hash[Object, Array[Object]], Integer, Integer, Integer) -> void
+      def add_transition(edges, state_id, production_id, dot)
+        symbol_id = rhs_for(production_id)[dot]
+        return unless symbol_id
+
+        target = @transitions.fetch(state_id).fetch(symbol_id)
+        edges[[state_id, production_id, dot]] << [target, production_id, dot + 1]
+      end
+
+      # @rbs (Hash[Object, Array[Object]], Array[packed_items], Integer, Integer, Integer) -> void
+      def add_closure(edges, lookaheads, state_id, production_id, dot)
+        rhs = rhs_for(production_id)
+        symbol = @grammar.symbol_by_id(rhs[dot])
+        return unless symbol&.nonterminal?
+
+        suffix = rhs.drop(dot + 1)
+        spontaneous = terminal_ids(@sets.first_of_sequence(suffix))
+        @productions_by_lhs.fetch(symbol.id, []).each do |production|
+          item = [production.id, 0].freeze
+          lookaheads.fetch(state_id).fetch(item).merge(spontaneous)
+          edges[[state_id, production_id, dot]] << [state_id, production.id, 0] if
+            @sets.sequence_nullable?(suffix)
+        end
+      end
+
+      # @rbs (Array[packed_items], Hash[Object, Array[Object]]) -> void
+      def propagate(lookaheads, edges)
+        queue = @seeds.map { |state_id, (production_id, dot), _token| [state_id, production_id, dot] }
+        queue.concat(lookaheads.each_with_index.flat_map do |items, state_id|
+          items.filter_map { |(production_id, dot), values| [state_id, production_id, dot] unless values.empty? }
+        end)
+        queued = queue.to_h { |node| [node, true] }
+        cursor = 0
+        while cursor < queue.length
+          source = queue.fetch(cursor)
+          cursor += 1
+          queued.delete(source)
+          source_set = lookaheads.fetch(source[0]).fetch([source[1], source[2]])
+          edges.fetch(source, EMPTY).each do |target|
+            target_set = lookaheads.fetch(target[0]).fetch([target[1], target[2]])
+            previous_size = target_set.size
+            target_set.merge(source_set)
+            next if target_set.size == previous_size || queued[target]
+
+            queue << target
+            queued[target] = true
+          end
+        end
+      end
+
+      # @rbs (Integer bits) -> Array[Integer]
+      def terminal_ids(bits)
+        @grammar.terminals.filter_map { |terminal| terminal.id if bits.anybits?(1 << terminal.id) }
+      end
+
+      # @rbs (Integer production_id) -> Array[Integer]
+      def rhs_for(production_id)
+        return [@grammar.symbol(@grammar.starts.fetch(-production_id - 1)).id] if production_id.negative?
+
+        @grammar.productions.fetch(production_id).rhs
+      end
+    end
+  end
+end
+# steep:ignore:end

data/lib/ibex/lalr/lr0_collection.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+# steep:ignore:start
+
+require "set"
+
+module Ibex
+  module LALR
+    # Constructs only the LR(0) core collection.  Keeping this separate from
+    # lookahead propagation makes the direct IELR phases reusable and gives
+    # them a stable, canonical-free input representation.
+    class LR0Collection
+      AUGMENTED_PRODUCTION = -1 #: Integer
+
+      # @rbs @grammar: IR::Grammar
+      # @rbs @productions_by_lhs: Hash[Integer, Array[IR::Production]]
+      # @rbs @starts: Array[String]
+      # @rbs @augmented_rhs: Hash[Integer, Array[Integer]]
+      # @rbs @production_rhs: Array[Array[Integer]]
+      # @rbs @item_key_stride: Integer
+
+      # @rbs (IR::Grammar grammar, ?starts: Array[String]?) -> void
+      def initialize(grammar, starts: nil)
+        @grammar = grammar
+        @starts = (starts || grammar.starts).dup
+        raise ArgumentError, "starts must be a nonempty subset of grammar starts" if
+          @starts.empty? || (@starts - grammar.starts).any?
+
+        @productions_by_lhs = grammar.productions.group_by(&:lhs)
+        @production_rhs = grammar.productions.map(&:rhs).freeze
+        @augmented_production_ids = @starts.map { |name| AUGMENTED_PRODUCTION - grammar.starts.index(name) }
+        @augmented_rhs = @starts.each_with_index.to_h do |name, index|
+          symbol = grammar.symbol(name) || raise(Ibex::Error, "missing start symbol #{name}")
+          [@augmented_production_ids.fetch(index), [symbol.id].freeze]
+        end.freeze
+        @item_key_stride = [*@production_rhs, *@augmented_rhs.values].map(&:length).max.to_i + 1
+      end
+
+      # @rbs () -> [Array[core_set], transitions]
+      def build
+        states = @starts.map { |name| closure(Set[[augmented_production(@starts.index(name)), 0]]) }
+        transitions = [] #: transitions
+        indexes = {}
+        states.each_with_index { |items, index| indexes[item_key(items)] = index }
+        cursor = 0
+        while cursor < states.length
+          transitions[cursor] = {}
+          shifted_kernels(states.fetch(cursor)).keys.sort.each do |symbol_id|
+            target = closure(shifted_kernels(states.fetch(cursor)).fetch(symbol_id))
+            target_id = indexes[item_key(target)] ||= begin
+              states << target
+              states.length - 1
+            end
+            transitions.fetch(cursor)[symbol_id] = target_id
+          end
+          cursor += 1
+        end
+        [states, transitions]
+      end
+
+      # @rbs (Integer index) -> Integer
+      def augmented_production(index)
+        @augmented_production_ids.fetch(index)
+      end
+
+      # @rbs (Integer production_id) -> Array[Integer]
+      def rhs_for(production_id)
+        return @augmented_rhs.fetch(production_id) if production_id.negative?
+
+        @production_rhs.fetch(production_id)
+      end
+
+      # @rbs (Integer production_id) -> Integer
+      def lhs_for(production_id)
+        return rhs_for(production_id).fetch(0) if production_id.negative?
+
+        @grammar.productions.fetch(production_id).lhs
+      end
+
+      # @rbs (core_set items) -> Hash[Integer, core_set]
+      def shifted_kernels(items)
+        kernels = Hash.new { |hash, key| hash[key] = Set.new } #: Hash[Integer, core_set]
+        items.each do |production_id, dot|
+          symbol_id = rhs_for(production_id)[dot]
+          kernels[symbol_id] << [production_id, dot + 1].freeze if symbol_id
+        end
+        kernels
+      end
+
+      private
+
+      # @rbs (core_set seed) -> core_set
+      def closure(seed)
+        items = seed.dup
+        queue = seed.to_a
+        cursor = 0
+        while cursor < queue.length
+          production_id, dot = queue.fetch(cursor)
+          cursor += 1
+          symbol = @grammar.symbol_by_id(rhs_for(production_id)[dot])
+          next unless symbol&.nonterminal?
+
+          @productions_by_lhs.fetch(symbol.id, []).each do |production|
+            item = [production.id, 0].freeze
+            queue << item if items.add?(item)
+          end
+        end
+        items
+      end
+
+      # @rbs (core_set items) -> Array[Integer]
+      def item_key(items)
+        items.map do |production_id, dot|
+          ((production_id + @grammar.starts.length) * @item_key_stride) + dot
+        end.sort
+      end
+    end
+  end
+end
+# steep:ignore:end

data/lib/ibex/lalr/unreachable_states.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+# steep:ignore:start
+
+module Ibex
+  module LALR
+    # Optional post-resolution compaction.  It is intentionally off by
+    # default because state numbers are part of diagnostics and golden output.
+    module UnreachableStates
+      module_function
+
+      # @rbs (Array[IR::AutomatonState] states, Array[Integer] start_states) ->
+      #   [Array[IR::AutomatonState], Hash[Integer, Integer]]
+      def remove(states, start_states)
+        reachable = reachable_states(states, start_states)
+        mapping = reachable.each_with_index.to_h { |old_id, new_id| [old_id, new_id] }
+        return [states, mapping] if reachable.length == states.length
+
+        compacted = reachable.map do |old_id|
+          state = states.fetch(old_id)
+          transitions = remap_edges(state.transitions, mapping)
+          gotos = remap_edges(state.gotos, mapping)
+          actions = state.actions.transform_values { |action| remap_action(action, mapping) }
+          default_action = remap_action(state.default_action, mapping)
+          conflicts = state.conflicts.map { |conflict| remap_conflict(conflict, mapping) }
+          IR::AutomatonState.new(
+            id: mapping.fetch(old_id), items: state.items, transitions: transitions,
+            actions: actions, gotos: gotos, default_action: default_action, conflicts: conflicts
+          )
+        end
+        [compacted, mapping]
+      end
+
+      # @rbs (Array[IR::AutomatonState], Array[Integer]) -> Array[Integer]
+      def reachable_states(states, start_states)
+        visited = {}
+        queue = start_states.dup
+        until queue.empty?
+          state_id = queue.shift
+          next if visited[state_id]
+
+          visited[state_id] = true
+          state = states.fetch(state_id)
+          state.gotos.each_value { |target| queue << target }
+          state.actions.each_value do |action|
+            queue << action[:state] if action[:type] == :shift
+          end
+        end
+        visited.keys.sort
+      end
+
+      # @rbs (Hash[Integer, Integer], Hash[Integer, Integer]) -> Hash[Integer, Integer]
+      def remap_edges(edges, mapping)
+        edges.each_with_object({}) do |(symbol_id, target), result|
+          result[symbol_id] = mapping[target] if mapping.key?(target)
+        end
+      end
+
+      # @rbs (IR::parser_action?, Hash[Integer, Integer]) -> IR::parser_action?
+      def remap_action(action, mapping)
+        return nil unless action
+        return action unless action[:type] == :shift
+        return { type: :shift, state: mapping.fetch(action[:state]) } if mapping.key?(action[:state])
+
+        { type: :error }
+      end
+
+      # @rbs (IR::conflict, Hash[Integer, Integer]) -> IR::conflict
+      def remap_conflict(conflict, mapping)
+        result = conflict.dup
+        if result[:type] == :shift_reduce && mapping.key?(result[:shift_to])
+          result[:shift_to] = mapping.fetch(result[:shift_to])
+        end
+        result
+      end
+    end
+  end
+end
+# steep:ignore:end