ibex 0.1.0 → 0.3.0

data/lib/ibex/lalr/builder.rb

@@ -1,40 +1,112 @@
 # frozen_string_literal: true
+# rbs_inline: enabled
 
 require "set"
 
 module Ibex
   module LALR
-    # Builds canonical LR(1) states and merges states with equal LR(0) cores.
+    # Builds deterministic SLR, direct LALR(1), or canonical LR(1) automata.
+    # rubocop:disable Metrics/ClassLength -- collection strategies share one action/conflict construction path.
     class Builder
       AUGMENTED_PRODUCTION = -1 #: Integer
 
-      ALGORITHMS = %i[slr lalr lr1].freeze #: Array[Symbol]
+      ALGORITHMS = %i[slr lalr ielr lr1].freeze #: Array[Symbol]
+      LALR_STRATEGIES = %i[direct canonical_merge].freeze #: Array[Symbol]
+      IELR_STRATEGIES = %i[direct partition].freeze #: Array[Symbol]
 
       # @rbs @grammar: IR::Grammar
       # @rbs @algorithm: Symbol
+      # @rbs @lalr_strategy: Symbol
+      # @rbs @ielr_strategy: Symbol
       # @rbs @sets: Analysis::Sets
       # @rbs @productions_by_lhs: Hash[Integer, Array[IR::Production]]
       # @rbs @resolver: ConflictResolver
-
-      # @rbs (IR::Grammar grammar, ?algorithm: Symbol | String) -> void
-      def initialize(grammar, algorithm: :lalr)
+      # @rbs @metrics: BuildMetrics?
+      # @rbs @start_names: Array[String]
+      # @rbs @entry_isolation: bool
+      # @rbs @attribute_entries: bool
+      # @rbs @profile: bool
+      # @rbs @remove_unreachable: bool
+      # @rbs @canonical_suffix_lookahead_cache: Hash[Integer, Hash[Integer, Hash[Integer, Array[Integer]]]]
+      # @rbs @canonical_item_cache: Hash[Integer, Array[Array[lr_item?]?]]?
+      # @rbs @canonical_key_radices: [Integer, Integer, Integer]?
+
+      attr_reader :metrics #: BuildMetrics?
+
+      # @rbs (IR::Grammar grammar, ?algorithm: Symbol | String, ?lalr_strategy: Symbol | String,
+      #   ?ielr_strategy: Symbol | String,
+      #   ?entry_isolation: bool, ?starts: Array[String]?, ?attribute_entries: bool, ?profile: bool,
+      #   ?remove_unreachable: bool) -> void
+      def initialize(grammar, algorithm: :lalr, lalr_strategy: :direct, entry_isolation: false,
+                     ielr_strategy: :partition, starts: nil, attribute_entries: true, profile: false,
+                     remove_unreachable: false)
         unless ALGORITHMS.include?(algorithm.to_sym)
           raise ArgumentError, "unknown parser algorithm #{algorithm.inspect}"
         end
+        unless LALR_STRATEGIES.include?(lalr_strategy.to_sym)
+          raise ArgumentError, "unknown LALR construction strategy #{lalr_strategy.inspect}"
+        end
+        unless IELR_STRATEGIES.include?(ielr_strategy.to_sym)
+          raise ArgumentError, "unknown IELR construction strategy #{ielr_strategy.inspect}"
+        end
 
         @grammar = grammar
         @algorithm = algorithm.to_sym
+        @lalr_strategy = lalr_strategy.to_sym
+        @ielr_strategy = ielr_strategy.to_sym
         @sets = Analysis::Sets.new(grammar)
         @productions_by_lhs = grammar.productions.group_by(&:lhs)
         @resolver = ConflictResolver.new(grammar)
+        @metrics = nil
+        @canonical_suffix_lookahead_cache = {}
+        @canonical_item_cache = nil
+        @canonical_key_radices = nil
+        @start_names = starts || grammar.starts
+        if @start_names.empty? || (@start_names - grammar.starts).any?
+          raise ArgumentError, "starts must be a nonempty subset of grammar starts"
+        end
+
+        @entry_isolation = entry_isolation
+        @attribute_entries = attribute_entries
+        @profile = profile
+        @remove_unreachable = remove_unreachable
       end
 
       # @rbs () -> IR::Automaton
       def build
-        canonical_states, canonical_transitions = canonical_collection
-        merged_items, merged_transitions = automaton_items(canonical_states, canonical_transitions)
+        return build_isolated_automaton if @entry_isolation && @start_names.length > 1
+
+        merged_items, merged_transitions, collection = automaton_collection
         states = build_states(merged_items, merged_transitions)
+        states = OnErrorReductions.apply(@grammar, states)
         states = DefaultReductions.apply(states, terminal_ids: @grammar.terminals.map(&:id))
+        entry_states = entry_states_for(merged_items)
+        if @remove_unreachable
+          states, mapping = UnreachableStates.remove(states, entry_states.values.uniq)
+          entry_states = entry_states.transform_values { |state_id| mapping.fetch(state_id) }
+          collection[:ielr_unreachable_removed] = mapping.length - states.length if collection.respond_to?(:[]=)
+        end
+        states = attribute_entry_conflicts(states, entry_states) if @attribute_entries && @start_names.length > 1
+        summary = conflict_summary(states)
+        final_items, final_lookahead_items = profiled_final_item_counts(merged_items)
+        @metrics = build_metrics(collection, states.length, final_items, final_lookahead_items)
+        build_output_automaton(states: states, conflict_summary: summary, entry_states: entry_states)
+      end
+
+      private
+
+      # @rbs (states: Array[IR::AutomatonState], conflict_summary: IR::conflict_summary,
+      #   entry_states: Hash[String, Integer]) -> IR::Automaton
+      def build_output_automaton(states:, conflict_summary:, entry_states:)
+        IR::Automaton.new(
+          grammar: @grammar, states: states, conflict_summary: conflict_summary,
+          algorithm: algorithm_name, entry_states: entry_states,
+          entry_construction: output_entry_construction || raise(Ibex::Error, "missing entry construction")
+        )
+      end
+
+      # @rbs (Array[IR::AutomatonState] states) -> IR::conflict_summary
+      def conflict_summary(states)
         conflicts = states.flat_map(&:conflicts)
         shift_reduce = conflicts.select { |item| item[:type] == :shift_reduce }
         counted_shift_reduce = shift_reduce.count { |item| item.dig(:resolution, :by) == :default_shift }
@@ -43,23 +115,142 @@ module Ibex
                     rr: conflicts.count { |item| item[:type] == :reduce_reduce },
                     expected_sr: @grammar.expect,
                     expectation_met: counted_shift_reduce == @grammar.expect } #: IR::conflict_summary
-        IR::Automaton.new(grammar: @grammar, states: states, conflict_summary: summary,
-                          algorithm: @algorithm == :lalr ? "lalr1" : @algorithm.to_s)
+        expected_rr = @grammar.expect_rr
+        if expected_rr
+          summary[:expected_rr] = expected_rr
+          summary[:rr_expectation_met] = summary[:rr] == expected_rr
+        end
+        summary
       end
 
-      private
+      # @rbs () -> [Array[packed_items], transitions, build_collection]
+      def automaton_collection
+        return ielr_collection if @algorithm == :ielr
+        return canonical_lr1_collection if @algorithm == :lr1
+        return merged_canonical_collection(:canonical_merge) if @lalr_strategy == :canonical_merge
+        return merged_canonical_collection(:canonical_merge_multi_entry) if @grammar.starts.length > 1
+
+        direct_collection
+      ensure
+        @canonical_item_cache = nil
+      end
+
+      # @rbs () -> [Array[packed_items], transitions, build_collection]
+      def ielr_collection
+        return ielr_direct_collection if @ielr_strategy == :direct
+
+        states, transitions = canonical_collection
+        partition = IELRPartition.new(@grammar, states, transitions, profile: @profile)
+        items, merged_transitions = partition.build
+        profile = canonical_profile(states, strategy: :ielr_partition)
+        profile[:ielr_initial_partitions] = partition.initial_partition_count
+        profile[:ielr_final_partitions] = partition.final_partition_count
+        [items, merged_transitions, profile]
+      end
+
+      # @rbs () -> [Array[packed_items], transitions, build_collection]
+      def ielr_direct_collection
+        pipeline = IELR::Pipeline.new(@grammar, @sets, starts: @start_names, profile: @profile)
+        pipeline.build
+      end
+
+      # @rbs () -> [Array[packed_items], transitions, build_collection]
+      def canonical_lr1_collection
+        states, transitions = canonical_collection
+        [pack_canonical_items(states), transitions, canonical_profile(states, strategy: :canonical_lr1)]
+      end
+
+      # @rbs (Symbol strategy) -> [Array[packed_items], transitions, build_collection]
+      def merged_canonical_collection(strategy)
+        states, transitions = canonical_collection
+        items, merged_transitions = merge_lalr(states, transitions)
+        apply_slr_lookaheads(items) if @algorithm == :slr
+        [items, merged_transitions, canonical_profile(states, strategy: strategy)]
+      end
+
+      # @rbs () -> untyped
+      def direct_collection
+        direct = DirectLookaheads.new(@grammar, @sets, profile: @profile)
+        items, transitions = direct.build
+        apply_slr_lookaheads(items) if @algorithm == :slr
+        profile = {
+          construction_states: items.length, canonical_states: nil, strategy: :direct_lalr,
+          lr0_states: direct.lr0_state_count, lr0_items: direct.lr0_item_count, canonical_items: nil,
+          propagation_edges: direct.propagation_edge_count,
+          ielr_initial_partitions: nil, ielr_final_partitions: nil,
+          ielr_annotations: nil, ielr_annotated_states: nil, ielr_inadequacies: nil,
+          ielr_split_stable_discarded: nil, ielr_lalr_states: nil, ielr_split_states: nil,
+          ielr_unreachable_removed: nil, ielr_remergeable_candidates: nil
+        }
+        [items, transitions, profile]
+      end
+
+      # @rbs (Array[item_set] states, strategy: Symbol) -> build_collection
+      def canonical_profile(states, strategy:)
+        cores = states.to_h { |items| [core_key(items), true] }.keys if @profile
+        {
+          construction_states: states.length, canonical_states: states.length, strategy: strategy,
+          lr0_states: cores&.length, lr0_items: cores&.sum(&:length),
+          canonical_items: @profile ? states.sum(&:length) : nil,
+          propagation_edges: nil, ielr_initial_partitions: nil, ielr_final_partitions: nil,
+          ielr_annotations: nil, ielr_annotated_states: nil, ielr_inadequacies: nil,
+          ielr_split_stable_discarded: nil, ielr_lalr_states: nil, ielr_split_states: nil,
+          ielr_unreachable_removed: nil, ielr_remergeable_candidates: nil
+        }
+      end
+
+      # @rbs (Array[packed_items] items) -> [Integer?, Integer?]
+      def profiled_final_item_counts(items)
+        return [nil, nil] unless @profile
+
+        [items.sum(&:length), items.sum { |state| state.values.sum(&:length) }]
+      end
+
+      # @rbs (build_collection collection, Integer final_states, Integer? final_items,
+      #   Integer? final_lookahead_items) -> BuildMetrics
+      def build_metrics(collection, final_states, final_items, final_lookahead_items)
+        BuildMetrics.new(
+          construction_states: collection.fetch(:construction_states),
+          canonical_states: collection.fetch(:canonical_states),
+          strategy: collection.fetch(:strategy),
+          lr0_states: collection.fetch(:lr0_states),
+          lr0_items: collection.fetch(:lr0_items),
+          canonical_items: collection.fetch(:canonical_items),
+          propagation_edges: collection.fetch(:propagation_edges),
+          ielr_initial_partitions: collection.fetch(:ielr_initial_partitions),
+          ielr_final_partitions: collection.fetch(:ielr_final_partitions),
+          ielr_annotations: collection.fetch(:ielr_annotations, nil),
+          ielr_annotated_states: collection.fetch(:ielr_annotated_states, nil),
+          ielr_inadequacies: collection.fetch(:ielr_inadequacies, nil),
+          ielr_split_stable_discarded: collection.fetch(:ielr_split_stable_discarded, nil),
+          ielr_lalr_states: collection.fetch(:ielr_lalr_states, nil),
+          ielr_split_states: collection.fetch(:ielr_split_states, nil),
+          ielr_unreachable_removed: collection.fetch(:ielr_unreachable_removed, nil),
+          ielr_remergeable_candidates: collection.fetch(:ielr_remergeable_candidates, nil),
+          final_states: final_states, final_items: final_items, final_lookahead_items: final_lookahead_items
+        )
+      end
+
+      # @rbs () -> String
+      def algorithm_name
+        { lalr: "lalr1", ielr: "ielr1" }.fetch(@algorithm, @algorithm.to_s)
+      end
 
       # @rbs () -> [Array[item_set], transitions]
       def canonical_collection
-        seed = Set[[AUGMENTED_PRODUCTION, 0, 0]] #: item_set
-        states = [closure(seed)]
+        states = @start_names.map do |name|
+          seed = Set[canonical_item(augmented_production(name), 0, 0)] #: item_set
+          closure(seed)
+        end
         transitions = [] #: transitions
-        indexes = { item_key(states.first) => 0 }
+        indexes = {} #: Hash[Array[Integer], Integer]
+        states.each_with_index { |items, index| indexes[item_key(items)] = index }
         cursor = 0
         while cursor < states.length
           transitions[cursor] = {}
-          next_symbols(states[cursor]).each do |symbol_id|
-            target = go_to(states[cursor], symbol_id)
+          kernels = shifted_kernels(states[cursor])
+          kernels.keys.sort.each do |symbol_id|
+            target = closure(kernels.fetch(symbol_id))
             key = item_key(target)
             target_id = indexes[key] ||= begin
               states << target
@@ -74,18 +265,27 @@ module Ibex
 
       # @rbs (item_set seed) -> item_set
       def closure(seed)
+        cache = (@canonical_item_cache ||= {}) #: Hash[Integer, Array[Array[lr_item?]?]]
         items = seed.dup
         queue = seed.to_a
-        until queue.empty?
-          production_id, dot, lookahead = queue.shift
+        cursor = 0
+        while cursor < queue.length
+          production_id, dot, lookahead = queue.fetch(cursor)
+          cursor += 1
           rhs = rhs_for(production_id)
           grammar_symbol = @grammar.symbol_by_id(rhs[dot])
           next unless grammar_symbol&.nonterminal?
 
-          lookaheads = suffix_lookaheads(rhs.drop(dot + 1), lookahead)
+          lookaheads = canonical_suffix_lookaheads(production_id, dot, lookahead)
           @productions_by_lhs.fetch(grammar_symbol.id, Array.new(0)).each do |production|
+            production_cache = (cache[production.id] ||= []) #: Array[Array[lr_item?]?]
+            item_cache = (production_cache[0] ||= []) #: Array[lr_item?]
             lookaheads.each do |token_id|
-              item = [production.id, 0, token_id] #: lr_item
+              item = item_cache[token_id]
+              unless item
+                item = [production.id, 0, token_id].freeze #: lr_item
+                item_cache[token_id] = item
+              end
               enqueue_item(items, queue, item)
             end
           end
@@ -100,32 +300,57 @@ module Ibex
         @grammar.terminals.filter_map { |terminal| terminal.id if bits.anybits?(1 << terminal.id) }
       end
 
-      # @rbs (item_set items, Array[lr_item] queue, lr_item item) -> void
-      def enqueue_item(items, queue, item)
-        return if items.include?(item)
+      # @rbs (Integer production_id, Integer dot, Integer inherited) -> Array[Integer]
+      def canonical_suffix_lookaheads(production_id, dot, inherited)
+        production_cache = (@canonical_suffix_lookahead_cache[production_id] ||= {})
+        inherited_cache = (production_cache[dot] ||= {})
+        return inherited_cache.fetch(inherited) if inherited_cache.key?(inherited)
 
-        items << item
-        queue << item
+        suffix = rhs_for(production_id).drop(dot + 1)
+        inherited_cache[inherited] = suffix_lookaheads(suffix, inherited).freeze
       end
 
-      # @rbs (item_set items) -> Array[Integer]
-      def next_symbols(items)
-        items.filter_map { |production_id, dot, _lookahead| rhs_for(production_id)[dot] }.uniq.sort
+      # @rbs (Integer production_id, Integer dot, Integer lookahead) -> lr_item
+      def canonical_item(production_id, dot, lookahead)
+        cache = (@canonical_item_cache ||= {}) #: Hash[Integer, Array[Array[lr_item?]?]]
+        production_cache = (cache[production_id] ||= []) #: Array[Array[lr_item?]?]
+        dot_cache = (production_cache[dot] ||= []) #: Array[lr_item?]
+        cached = dot_cache[lookahead]
+        return cached if cached
+
+        item = [production_id, dot, lookahead].freeze #: lr_item
+        dot_cache[lookahead] = item
       end
 
-      # @rbs (item_set items, Integer symbol_id) -> item_set
-      def go_to(items, symbol_id)
-        moved = items.filter_map do |production_id, dot, lookahead|
-          next unless rhs_for(production_id)[dot] == symbol_id
+      # @rbs (item_set items, Array[lr_item] queue, lr_item item) -> void
+      def enqueue_item(items, queue, item)
+        queue << item if items.add?(item)
+      end
 
-          [production_id, dot + 1, lookahead] #: lr_item
+      # @rbs (item_set items) -> Hash[Integer, item_set]
+      def shifted_kernels(items)
+        cache = (@canonical_item_cache ||= {}) #: Hash[Integer, Array[Array[lr_item?]?]]
+        kernels = {} #: Hash[Integer, item_set]
+        items.each do |production_id, dot, lookahead|
+          symbol_id = rhs_for(production_id)[dot]
+          next unless symbol_id
+
+          production_cache = (cache[production_id] ||= []) #: Array[Array[lr_item?]?]
+          shifted_dot = dot + 1
+          item_cache = (production_cache[shifted_dot] ||= []) #: Array[lr_item?]
+          item = item_cache[lookahead]
+          unless item
+            item = [production_id, shifted_dot, lookahead].freeze #: lr_item
+            item_cache[lookahead] = item
+          end
+          (kernels[symbol_id] ||= Set.new) << item
         end
-        closure(Set.new(moved))
+        kernels
       end
 
       # @rbs (Array[item_set] states, transitions transitions) -> [Array[packed_items], transitions]
       def merge_lalr(states, transitions)
-        groups = {} #: Hash[Array[item_core], Integer]
+        groups = {} #: Hash[Array[Integer], Integer]
         state_groups = states.map do |items|
           core = core_key(items)
           groups[core] ||= groups.length
@@ -145,15 +370,6 @@ module Ibex
         [merged, merged_transitions]
       end
 
-      # @rbs (Array[item_set] canonical_states, transitions canonical_transitions) -> [Array[packed_items], transitions]
-      def automaton_items(canonical_states, canonical_transitions)
-        return [pack_canonical_items(canonical_states), canonical_transitions] if @algorithm == :lr1
-
-        items, transitions = merge_lalr(canonical_states, canonical_transitions)
-        apply_slr_lookaheads(items) if @algorithm == :slr
-        [items, transitions]
-      end
-
       # @rbs (Array[item_set] states) -> Array[packed_items]
       def pack_canonical_items(states)
         states.map do |items|
@@ -176,7 +392,7 @@ module Ibex
 
       # @rbs (Integer production_id) -> Array[Integer]
       def slr_lookaheads(production_id)
-        return [0] if production_id == AUGMENTED_PRODUCTION
+        return [0] if production_id.negative?
 
         lhs = @grammar.productions.fetch(production_id).lhs
         bits = @sets.follow_bits.fetch(lhs)
@@ -187,7 +403,8 @@ module Ibex
       def build_states(merged_items, transitions)
         merged_items.each_with_index.map do |item_map, state_id|
           items = item_map.sort.map do |(production, dot), lookaheads|
-            IR::AutomatonItem.new(production: production, dot: dot, lookaheads: lookaheads.to_a)
+            visible_production = production.negative? ? AUGMENTED_PRODUCTION : production
+            IR::AutomatonItem.new(production: visible_production, dot: dot, lookaheads: lookaheads.to_a)
           end
           build_state(state_id, items, transitions[state_id])
         end
@@ -209,17 +426,36 @@ module Ibex
         end
         add_completed_actions(items, candidates)
         actions, conflicts = resolve_actions(candidates)
+        conflicts = conflicts.map { |conflict| attribute_midrule_conflict(conflict) }
         IR::AutomatonState.new(id: state_id, items: items, transitions: transitions, actions: actions,
                                gotos: gotos, conflicts: conflicts)
       end
 
+      # Conflict hashes are produced locally immediately before this boundary.
+      # Both conflict variants carry the same optional midrule provenance field.
+      # @rbs (IR::conflict conflict) -> IR::conflict
+      def attribute_midrule_conflict(conflict)
+        production_ids = if conflict[:type] == :shift_reduce
+                           [conflict[:reduce]]
+                         else
+                           conflict[:reductions]
+                         end #: Array[Integer]
+        origins = production_ids.filter_map do |production_id|
+          production = @grammar.productions.fetch(production_id)
+          production.origin[:loc] if production.origin[:kind] == :inline_action
+        end
+        result = conflict.dup #: Hash[Symbol, untyped]
+        result[:midrule_origins] = origins.uniq unless origins.empty?
+        result #: IR::conflict
+      end
+
       # @rbs (Array[IR::AutomatonItem] items, Hash[Integer, Array[IR::parser_action]] candidates) -> void
       def add_completed_actions(items, candidates)
         items.each do |item|
           next unless item.dot == rhs_for(item.production).length
 
           item.lookaheads.each do |lookahead|
-            action = if item.production == AUGMENTED_PRODUCTION
+            action = if item.production.negative?
                        { type: :accept } #: IR::accept_action
                      else
                        { type: :reduce, production: item.production } #: IR::reduce_action
@@ -246,25 +482,251 @@ module Ibex
 
       # @rbs (Integer production_id) -> Array[Integer]
       def rhs_for(production_id)
-        if production_id == AUGMENTED_PRODUCTION
-          start = @grammar.symbol(@grammar.start) || raise(Ibex::Error, "missing start symbol")
+        if production_id.negative?
+          name = start_name_for_augmented(production_id)
+          start = @grammar.symbol(name) || raise(Ibex::Error, "missing start symbol #{name}")
           return [start.id]
         end
 
         @grammar.productions.fetch(production_id).rhs
       end
 
-      # @rbs (item_set items) -> Array[item_core]
+      # @rbs () -> [Integer, Integer, Integer]
+      def canonical_key_radices
+        cached = @canonical_key_radices
+        return cached if cached
+
+        longest_rhs = @grammar.productions.map { |production| production.rhs.length }.max || 0
+        highest_terminal_id = @grammar.terminals.map(&:id).max || 0
+        radices = [
+          @grammar.starts.length,
+          [longest_rhs, 1].max + 1,
+          highest_terminal_id + 1
+        ] #: [Integer, Integer, Integer]
+        @canonical_key_radices = radices.freeze
+      end
+
+      # @rbs (item_set items) -> Array[Integer]
       def core_key(items)
+        production_offset, dot_radix, = canonical_key_radices
         items.map do |production, dot, _lookahead|
-          [production, dot] #: item_core
+          ((production + production_offset) * dot_radix) + dot
         end.uniq.sort
       end
 
-      # @rbs (item_set items) -> Array[lr_item]
+      # @rbs (item_set items) -> Array[Integer]
       def item_key(items)
-        items.to_a.sort
+        production_offset, dot_radix, lookahead_radix = canonical_key_radices
+        items.map do |production, dot, lookahead|
+          core = ((production + production_offset) * dot_radix) + dot
+          (core * lookahead_radix) + lookahead
+        end.sort
+      end
+
+      # @rbs (String name) -> Integer
+      def augmented_production(name)
+        index = @grammar.starts.index(name)
+        raise Ibex::Error, "missing start symbol #{name}" unless index
+
+        AUGMENTED_PRODUCTION - index
+      end
+
+      # @rbs (Integer production_id) -> String
+      def start_name_for_augmented(production_id)
+        @grammar.starts.fetch(-production_id - 1)
+      end
+
+      # @rbs (Array[packed_items] items) -> Hash[String, Integer]
+      def entry_states_for(items)
+        @start_names.to_h do |name|
+          production = augmented_production(name)
+          state = items.index { |item_map| item_map.key?([production, 0]) }
+          raise Ibex::Error, "missing initial state for start symbol #{name}" unless state
+
+          [name, state]
+        end
+      end
+
+      # @rbs () -> IR::Automaton
+      def build_isolated_automaton
+        entries = @start_names.map { |name| isolated_entry(name) }
+        states = [] #: Array[IR::AutomatonState]
+        entry_states = {} #: Hash[String, Integer]
+        construction_states = 0
+        canonical_counts = [] #: Array[Integer?]
+        entries.each do |name, automaton, metrics|
+          offset = states.length
+          entry_states[name] = offset + automaton.entry_states.fetch(name)
+          states.concat(automaton.states.map { |state| offset_state(state, offset, name) })
+          construction_states += metrics.construction_states
+          canonical_counts << metrics.canonical_states
+        end
+        canonical_states = canonical_counts.compact.sum if canonical_counts.none?(&:nil?)
+        @metrics = isolated_metrics(entries, construction_states, canonical_states, states.length)
+        build_output_automaton(
+          states: states, conflict_summary: conflict_summary(states), entry_states: entry_states
+        )
+      end
+
+      # @rbs (Array[[String, IR::Automaton, BuildMetrics]] entries, Integer construction_states,
+      #   Integer? canonical_states, Integer final_states) -> BuildMetrics
+      def isolated_metrics(entries, construction_states, canonical_states, final_states)
+        BuildMetrics.new(
+          construction_states: construction_states, canonical_states: canonical_states,
+          final_states: final_states, strategy: :entry_isolation,
+          lr0_states: sum_optional_metric(entries, :lr0_states),
+          lr0_items: sum_optional_metric(entries, :lr0_items),
+          canonical_items: sum_optional_metric(entries, :canonical_items),
+          final_items: sum_optional_metric(entries, :final_items),
+          final_lookahead_items: sum_optional_metric(entries, :final_lookahead_items),
+          propagation_edges: sum_optional_metric(entries, :propagation_edges),
+          ielr_initial_partitions: sum_optional_metric(entries, :ielr_initial_partitions),
+          ielr_final_partitions: sum_optional_metric(entries, :ielr_final_partitions),
+          ielr_annotations: sum_optional_metric(entries, :ielr_annotations),
+          ielr_annotated_states: sum_optional_metric(entries, :ielr_annotated_states),
+          ielr_inadequacies: sum_optional_metric(entries, :ielr_inadequacies),
+          ielr_split_stable_discarded: sum_optional_metric(entries, :ielr_split_stable_discarded),
+          ielr_lalr_states: sum_optional_metric(entries, :ielr_lalr_states),
+          ielr_split_states: sum_optional_metric(entries, :ielr_split_states),
+          ielr_unreachable_removed: sum_optional_metric(entries, :ielr_unreachable_removed),
+          ielr_remergeable_candidates: sum_optional_metric(entries, :ielr_remergeable_candidates)
+        )
+      end
+
+      # @rbs (Array[[String, IR::Automaton, BuildMetrics]] entries, Symbol method) -> Integer?
+      def sum_optional_metric(entries, method)
+        values = entries.map { |_name, _automaton, metrics| metrics.public_send(method) }
+        values.compact.sum if values.none?(&:nil?)
+      end
+
+      # @rbs () -> Integer
+      def output_schema_version
+        IR::SCHEMA_VERSION
+      end
+
+      # @rbs () -> String?
+      def output_entry_construction
+        @entry_isolation ? "isolated" : "shared"
+      end
+
+      # @rbs (String name) -> [String, IR::Automaton, BuildMetrics]
+      def isolated_entry(name)
+        builder = self.class.new(
+          @grammar, algorithm: @algorithm, lalr_strategy: @lalr_strategy,
+                    ielr_strategy: @ielr_strategy,
+                    starts: [name], entry_isolation: true, attribute_entries: false, profile: @profile,
+                    remove_unreachable: @remove_unreachable
+        )
+        automaton = builder.build
+        metrics = builder.metrics
+        raise Ibex::Error, "missing build metrics for start symbol #{name}" unless metrics
+
+        [name, automaton, metrics]
+      end
+
+      # @rbs (IR::AutomatonState state, Integer offset, String entry) -> IR::AutomatonState
+      def offset_state(state, offset, entry)
+        actions = state.actions.transform_values { |action| offset_action(action, offset) }
+        conflicts = state.conflicts.map { |conflict| offset_conflict(conflict, offset, entry) }
+        IR::AutomatonState.new(
+          id: state.id + offset, items: state.items,
+          transitions: state.transitions.transform_values { |target| target + offset },
+          actions: actions, gotos: state.gotos.transform_values { |target| target + offset },
+          default_action: offset_default_action(state.default_action, offset), conflicts: conflicts
+        )
+      end
+
+      # @rbs (IR::parser_action action, Integer offset) -> IR::parser_action
+      def offset_action(action, offset)
+        return action unless action[:type] == :shift
+
+        shift = action #: IR::shift_action
+        { type: :shift, state: shift[:state] + offset }
+      end
+
+      # @rbs (IR::parser_action? action, Integer offset) -> IR::parser_action?
+      def offset_default_action(action, offset)
+        action && offset_action(action, offset)
+      end
+
+      # @rbs (IR::conflict conflict, Integer offset, String entry) -> IR::conflict
+      def offset_conflict(conflict, offset, entry)
+        if conflict[:type] == :shift_reduce
+          shift_reduce = conflict #: IR::shift_reduce_conflict
+          shifted = shift_reduce.dup #: IR::shift_reduce_conflict
+          shifted[:shift_to] = shift_reduce[:shift_to] + offset
+          shifted[:entries] = [entry]
+          return shifted
+        end
+
+        reduce_reduce = conflict #: IR::reduce_reduce_conflict
+        shifted = reduce_reduce.dup #: IR::reduce_reduce_conflict
+        shifted[:entries] = [entry]
+        shifted
+      end
+
+      # @rbs (Array[IR::AutomatonState] states, Hash[String, Integer] entry_states) ->
+      #   Array[IR::AutomatonState]
+      def attribute_entry_conflicts(states, entry_states)
+        reachability = entry_reachability(states, entry_states)
+        isolated = isolated_conflict_fingerprints
+        states.map do |state|
+          conflicts = state.conflicts.map do |conflict| # @type var conflict: IR::conflict
+            entries = @start_names.select { |name| reachability.fetch(state.id).include?(name) }
+            attributed = conflict.dup #: IR::conflict
+            attributed[:entries] = entries
+            attributed[:composite] = true unless isolated.include?(conflict_fingerprint(conflict))
+            attributed
+          end #: Array[IR::conflict]
+          IR::AutomatonState.new(
+            id: state.id, items: state.items, transitions: state.transitions, actions: state.actions,
+            gotos: state.gotos, default_action: state.default_action, conflicts: conflicts
+          )
+        end
+      end
+
+      # @rbs (Array[IR::AutomatonState] states, Hash[String, Integer] entry_states) -> Array[Array[String]]
+      def entry_reachability(states, entry_states)
+        reachable = Array.new(states.length) { [] } #: Array[Array[String]]
+        entry_states.each do |name, initial|
+          queue = [initial]
+          visited = {} #: Hash[Integer, bool]
+          until queue.empty?
+            state_id = queue.shift
+            next if visited[state_id]
+
+            visited[state_id] = true
+            reachable.fetch(state_id) << name
+            states.fetch(state_id).transitions.each_value { |target| queue << target }
+          end
+        end
+        reachable
+      end
+
+      # @rbs () -> Set[conflict_fingerprint]
+      def isolated_conflict_fingerprints
+        @start_names.each_with_object(Set.new) do |name, fingerprints|
+          isolated = self.class.new(
+            @grammar, algorithm: @algorithm, lalr_strategy: @lalr_strategy,
+                      ielr_strategy: @ielr_strategy,
+                      starts: [name], attribute_entries: false
+          ).build
+          isolated.states.each do |state|
+            state.conflicts.each { |conflict| fingerprints << conflict_fingerprint(conflict) }
+          end
+        end
+      end
+
+      # @rbs (IR::conflict conflict) -> conflict_fingerprint
+      def conflict_fingerprint(conflict)
+        reductions = if conflict[:type] == :shift_reduce
+                       [conflict[:reduce]]
+                     else
+                       conflict[:reductions]
+                     end #: Array[Integer]
+        [conflict[:type], conflict[:symbol], reductions]
       end
     end
+    # rubocop:enable Metrics/ClassLength
   end
 end