ibex 0.1.0

data/lib/ibex/ir/grammar_ir.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module Ibex
+  module IR
+    SCHEMA_VERSION = 1
+
+    # @rbs (untyped value) -> untyped
+    def deep_freeze(value)
+      case value
+      when Array then value.each { |item| deep_freeze(item) }
+      when Hash
+        value.each do |key, item|
+          deep_freeze(key)
+          deep_freeze(item)
+        end
+      end
+      value.freeze
+    end
+    module_function :deep_freeze
+
+    # An interned terminal or nonterminal.
+    class GrammarSymbol
+      attr_reader :id #: Integer
+      attr_reader :name #: String
+      attr_reader :kind #: Symbol
+      attr_reader :reserved #: bool
+      attr_reader :precedence #: precedence?
+      attr_reader :location #: location?
+
+      # @rbs (id: Integer, name: String, kind: Symbol, ?reserved: bool, ?precedence: precedence?,
+      #   ?location: location?) -> void
+      def initialize(id:, name:, kind:, reserved: false, precedence: nil, location: nil)
+        @id = id
+        @name = name.freeze
+        @kind = kind.to_sym
+        @reserved = reserved
+        @precedence = IR.deep_freeze(precedence)
+        @location = IR.deep_freeze(location)
+        freeze
+      end
+
+      # @rbs () -> bool
+      def terminal? = @kind == :terminal
+      # @rbs () -> bool
+      def nonterminal? = @kind == :nonterminal
+
+      # @rbs () -> Hash[Symbol, untyped]
+      def to_h
+        { id: @id, name: @name, kind: @kind, reserved: @reserved, prec: @precedence, loc: @location }
+      end
+    end
+
+    # Opaque Ruby semantic action metadata.
+    class Action
+      attr_reader :code #: String
+      attr_reader :location #: location
+      attr_reader :named_refs #: Array[named_ref]
+      attr_reader :context_length #: Integer
+
+      # @rbs (code: String, location: location, ?named_refs: Array[named_ref], ?context_length: Integer) -> void
+      def initialize(code:, location:, named_refs: [], context_length: 0)
+        @code = code.freeze
+        @location = IR.deep_freeze(location)
+        @named_refs = IR.deep_freeze(named_refs)
+        @context_length = context_length
+        freeze
+      end
+
+      # @rbs () -> Hash[Symbol, untyped]
+      def to_h
+        { code: @code, loc: @location, named_refs: @named_refs, context_length: @context_length }
+      end
+    end
+
+    # A normalized BNF production using symbol ids.
+    class Production
+      attr_reader :id #: Integer
+      attr_reader :lhs #: Integer
+      attr_reader :rhs #: Array[Integer]
+      attr_reader :action #: Action?
+      attr_reader :precedence_override #: Integer?
+      attr_reader :origin #: Hash[Symbol, untyped]
+
+      # @rbs (id: Integer, lhs: Integer, rhs: Array[Integer], action: Action?, precedence_override: Integer?,
+      #   origin: Hash[Symbol, untyped]) -> void
+      def initialize(id:, lhs:, rhs:, action:, precedence_override:, origin:)
+        @id = id
+        @lhs = lhs
+        @rhs = rhs.freeze
+        @action = action
+        @precedence_override = precedence_override
+        @origin = IR.deep_freeze(origin)
+        freeze
+      end
+
+      # @rbs () -> Hash[Symbol, untyped]
+      def to_h
+        { id: @id, lhs: @lhs, rhs: @rhs, action: @action&.to_h, prec_override: @precedence_override,
+          origin: @origin }
+      end
+    end
+
+    # One opaque user-code block and the location of its first code line.
+    class UserCodeChunk
+      attr_reader :code #: String
+      attr_reader :location #: location
+
+      # @rbs (code: String, location: location) -> void
+      def initialize(code:, location:)
+        @code = code.freeze
+        @location = IR.deep_freeze(location)
+        freeze
+      end
+
+      # @rbs () -> Hash[Symbol, untyped]
+      def to_h
+        { code: @code, loc: @location }
+      end
+    end
+
+    # Immutable normalized grammar exchanged between pipeline stages.
+    class Grammar
+      attr_reader :class_name #: String
+      attr_reader :superclass #: String?
+      attr_reader :start #: String
+      attr_reader :expect #: Integer
+      attr_reader :options #: grammar_options
+      attr_reader :symbols #: Array[GrammarSymbol]
+      attr_reader :productions #: Array[Production]
+      attr_reader :user_code #: Hash[String, String]
+      attr_reader :user_code_chunks #: user_code_chunks
+      attr_reader :conversions #: Hash[String, String]
+      attr_reader :warnings #: Array[grammar_warning]
+      attr_reader :schema_version #: Integer
+
+      # @rbs (class_name: String, superclass: String?, start: String, expect: Integer, options: grammar_options,
+      #   symbols: Array[GrammarSymbol], productions: Array[Production], user_code: Hash[String, String],
+      #   conversions: Hash[String, String], warnings: Array[grammar_warning], ?user_code_chunks: user_code_chunks?,
+      #   ?schema_version: Integer) -> void
+      def initialize(class_name:, superclass:, start:, expect:, options:, symbols:, productions:, user_code:,
+                     conversions:, warnings:, user_code_chunks: nil, schema_version: SCHEMA_VERSION)
+        @class_name = class_name.freeze
+        @superclass = superclass&.freeze
+        @start = start.freeze
+        @expect = expect
+        @options = IR.deep_freeze(options)
+        @symbols = symbols.freeze
+        @productions = productions.freeze
+        @user_code = IR.deep_freeze(user_code)
+        @user_code_chunks = IR.deep_freeze(user_code_chunks || {})
+        validate_user_code_chunks
+        @conversions = IR.deep_freeze(conversions)
+        @warnings = IR.deep_freeze(warnings)
+        @schema_version = schema_version
+        @symbols_by_name = @symbols.to_h { |symbol| [symbol.name, symbol] }.freeze
+        @symbols_by_id = @symbols.to_h { |symbol| [symbol.id, symbol] }.freeze
+        freeze
+      end
+
+      # @rbs (String name) -> GrammarSymbol?
+      def symbol(name) = @symbols_by_name[name]
+      # @rbs (Integer? id) -> GrammarSymbol?
+      def symbol_by_id(id) = @symbols_by_id[id]
+      # @rbs () -> Array[GrammarSymbol]
+      def terminals = @symbols.select(&:terminal?)
+      # @rbs () -> Array[GrammarSymbol]
+      def nonterminals = @symbols.select(&:nonterminal?)
+
+      # @rbs () -> Hash[Symbol, untyped]
+      def to_h
+        value = { ibex_ir: "grammar", schema_version: @schema_version, class_name: @class_name, superclass: @superclass,
+                  start: @start, expect: @expect, options: @options, symbols: @symbols.map(&:to_h),
+                  productions: @productions.map(&:to_h), user_code: @user_code, conversions: @conversions,
+                  warnings: @warnings } #: Hash[Symbol, untyped]
+        value[:user_code_chunks] = @user_code_chunks.transform_values { |chunks| chunks.map(&:to_h) } \
+          unless @user_code_chunks.empty?
+        value
+      end
+
+      private
+
+      # @rbs () -> void
+      def validate_user_code_chunks
+        @user_code_chunks.each do |name, chunks|
+          next if chunks.map(&:code).join == @user_code.fetch(name, "")
+
+          raise Ibex::Error, "(ir):1:1: user-code chunks do not match the concatenated #{name} section"
+        end
+      end
+    end
+  end
+end

data/lib/ibex/ir/serialize.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ibex
+  module IR
+    # Stable JSON serialization for versioned pipeline IR.
+    module Serialize
+      # @rbs!
+      #   private def validate_version: (untyped data) -> untyped
+      #   private def self.validate_version: (untyped data) -> untyped
+      #   private def load_grammar: (untyped data) -> untyped
+      #   private def self.load_grammar: (untyped data) -> untyped
+      #   private def load_automaton: (untyped data) -> untyped
+      #   private def self.load_automaton: (untyped data) -> untyped
+      #   private def load_state: (untyped state, untyped grammar) -> untyped
+      #   private def self.load_state: (untyped state, untyped grammar) -> untyped
+      #   private def symbol_keyed: (untyped values, untyped grammar, ?actions: untyped) -> untyped
+      #   private def self.symbol_keyed: (untyped values, untyped grammar, ?actions: untyped) -> untyped
+      #   private def normalize_action: (untyped value) -> untyped
+      #   private def self.normalize_action: (untyped value) -> untyped
+      #   private def load_production: (untyped production) -> untyped
+      #   private def self.load_production: (untyped production) -> untyped
+      #   private def load_user_code_chunks: (untyped chunks) -> untyped
+      #   private def self.load_user_code_chunks: (untyped chunks) -> untyped
+      #   private def symbolize: (untyped value) -> untyped
+      #   private def self.symbolize: (untyped value) -> untyped
+
+      # @rbs (Grammar | Automaton value) -> String
+      def dump(value)
+        "#{JSON.pretty_generate(value.to_h)}\n"
+      end
+      module_function :dump
+
+      # @rbs (String source) -> (Grammar | Automaton)
+      def load(source)
+        data = JSON.parse(source)
+        type = data.fetch("ibex_ir") { raise Ibex::Error, "(ir):1:1: missing ibex_ir discriminator" }
+        validate_version(data)
+        return load_grammar(data) if type == "grammar"
+        return load_automaton(data) if type == "automaton"
+
+        raise Ibex::Error, "(ir):1:1: unsupported IR type #{type.inspect}"
+      rescue JSON::ParserError => e
+        raise Ibex::Error, "(ir):1:1: invalid JSON: #{e.message}"
+      end
+      module_function :load
+
+      # @rbs skip
+      private
+
+      # @rbs skip
+      def validate_version(data)
+        version = data["schema_version"]
+        return if version == SCHEMA_VERSION
+
+        raise Ibex::Error, "(ir):1:1: unsupported schema_version #{version.inspect}; expected #{SCHEMA_VERSION}"
+      end
+
+      # @rbs skip
+      def load_grammar(data)
+        empty_chunks = {} #: Hash[String, untyped]
+        symbols = data.fetch("symbols").map do |symbol|
+          GrammarSymbol.new(id: symbol.fetch("id"), name: symbol.fetch("name"), kind: symbol.fetch("kind"),
+                            reserved: symbol.fetch("reserved"), precedence: symbolize(symbol["prec"]),
+                            location: symbolize(symbol["loc"]))
+        end
+        productions = data.fetch("productions").map { |production| load_production(production) }
+        Grammar.new(class_name: data.fetch("class_name"), superclass: data["superclass"], start: data.fetch("start"),
+                    expect: data.fetch("expect"), options: symbolize(data.fetch("options")), symbols: symbols,
+                    productions: productions, user_code: data.fetch("user_code"),
+                    conversions: data.fetch("conversions"), warnings: symbolize(data.fetch("warnings")),
+                    user_code_chunks: load_user_code_chunks(data.fetch("user_code_chunks", empty_chunks)))
+      end
+
+      # @rbs skip
+      def load_automaton(data)
+        grammar = load_grammar(data.fetch("grammar"))
+        states = data.fetch("states").map { |state| load_state(state, grammar) }
+        Automaton.new(grammar: grammar, states: states, conflict_summary: symbolize(data.fetch("conflict_summary")),
+                      algorithm: data.fetch("algorithm"), grammar_digest: data.fetch("grammar_digest"))
+      end
+
+      # @rbs skip
+      def load_state(state, grammar)
+        items = state.fetch("items").map do |item|
+          lookaheads = item.fetch("lookaheads").map { |name| grammar.symbol(name).id }
+          AutomatonItem.new(production: item.fetch("production"), dot: item.fetch("dot"), lookaheads: lookaheads)
+        end
+        AutomatonState.new(id: state.fetch("id"), items: items,
+                           transitions: symbol_keyed(state.fetch("transitions"), grammar),
+                           actions: symbol_keyed(state.fetch("actions"), grammar, actions: true),
+                           gotos: symbol_keyed(state.fetch("gotos"), grammar),
+                           default_action: normalize_action(state["default_action"]),
+                           conflicts: symbolize(state.fetch("conflicts")))
+      end
+
+      # @rbs skip
+      def symbol_keyed(values, grammar, actions: false)
+        values.to_h do |name, value|
+          [grammar.symbol(name).id, actions ? normalize_action(value) : value]
+        end
+      end
+
+      # @rbs skip
+      def normalize_action(value)
+        return nil unless value
+
+        action = symbolize(value)
+        action[:type] = action[:type].to_sym
+        action
+      end
+
+      # @rbs skip
+      def load_production(production)
+        action_data = production["action"]
+        action = if action_data
+                   Action.new(code: action_data.fetch("code"), location: symbolize(action_data["loc"]),
+                              named_refs: symbolize(action_data.fetch("named_refs")),
+                              context_length: action_data.fetch("context_length"))
+                 end
+        Production.new(id: production.fetch("id"), lhs: production.fetch("lhs"), rhs: production.fetch("rhs"),
+                       action: action, precedence_override: production["prec_override"],
+                       origin: symbolize(production.fetch("origin")))
+      end
+
+      # @rbs skip
+      def load_user_code_chunks(chunks)
+        chunks.to_h do |name, values|
+          loaded = values.map do |value|
+            UserCodeChunk.new(code: value.fetch("code"), location: symbolize(value.fetch("loc")))
+          end
+          [name, loaded]
+        end
+      end
+
+      # @rbs skip
+      def symbolize(value)
+        case value
+        when Array then value.map { |item| symbolize(item) }
+        when Hash then value.to_h { |key, item| [key.to_sym, symbolize(item)] }
+        else value
+        end
+      end
+      module_function :validate_version, :load_grammar, :load_automaton, :load_state, :symbol_keyed,
+                      :normalize_action, :load_production, :load_user_code_chunks, :symbolize
+
+      class << self
+        private :validate_version, :load_grammar, :load_automaton, :load_state, :symbol_keyed,
+                :normalize_action, :load_production, :load_user_code_chunks, :symbolize
+      end
+    end
+  end
+end

data/lib/ibex/ir.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "ir/grammar_ir"
+require_relative "ir/automaton_ir"
+require_relative "ir/serialize"
+
+module Ibex
+  module IR
+    # Shared static shapes used across analysis, automaton construction, and code generation.
+    # @rbs!
+    #   type location = { file: String, line: Integer, column: Integer }
+    #   type precedence = { associativity: Symbol, level: Integer }
+    #   type named_ref = { name: String, index: Integer }
+    #   type user_code_chunks = Hash[String, Array[UserCodeChunk]]
+    #   type grammar_options = { result_var: bool, omit_action_call: bool }
+    #   type grammar_warning = {
+    #     type: Symbol,
+    #     ?symbol: String,
+    #     ?production: Integer,
+    #     ?original: Integer,
+    #     loc: location?
+    #   }
+    #   type shift_action = { type: :shift, state: Integer }
+    #   type reduce_action = { type: :reduce, production: Integer }
+    #   type accept_action = { type: :accept }
+    #   type error_action = { type: :error }
+    #   type parser_action = shift_action | reduce_action | accept_action | error_action
+    #   type runtime_action = [:shift, Integer] | [:reduce, Integer] | [:accept] | [:error]
+    #   type conflict_resolution = { by: Symbol, chose: Symbol | Integer, ?associativity: Symbol }
+    #   type shift_reduce_conflict =
+    #     { type: :shift_reduce, symbol: String, shift_to: Integer, reduce: Integer, resolution: conflict_resolution }
+    #   type reduce_reduce_conflict =
+    #     { type: :reduce_reduce, symbol: String, reductions: Array[Integer], resolution: conflict_resolution }
+    #   type conflict = shift_reduce_conflict | reduce_reduce_conflict
+    #   type conflict_summary = {
+    #     sr: Integer,
+    #     resolved_sr: Integer,
+    #     rr: Integer,
+    #     expected_sr: Integer,
+    #     expectation_met: bool
+    #   }
+    #   type interpretation = Hash[Symbol, untyped]
+    #   type counterexample = {
+    #     state: Integer,
+    #     type: Symbol,
+    #     symbol_path: Array[String],
+    #     sentence: Array[String],
+    #     lookahead_index: Integer,
+    #     unifying: bool,
+    #     interpretations: Array[interpretation]
+    #   }
+  end
+end

data/lib/ibex/lalr/builder.rb

@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Ibex
+  module LALR
+    # Builds canonical LR(1) states and merges states with equal LR(0) cores.
+    class Builder
+      AUGMENTED_PRODUCTION = -1 #: Integer
+
+      ALGORITHMS = %i[slr lalr lr1].freeze #: Array[Symbol]
+
+      # @rbs @grammar: IR::Grammar
+      # @rbs @algorithm: 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)
+        unless ALGORITHMS.include?(algorithm.to_sym)
+          raise ArgumentError, "unknown parser algorithm #{algorithm.inspect}"
+        end
+
+        @grammar = grammar
+        @algorithm = algorithm.to_sym
+        @sets = Analysis::Sets.new(grammar)
+        @productions_by_lhs = grammar.productions.group_by(&:lhs)
+        @resolver = ConflictResolver.new(grammar)
+      end
+
+      # @rbs () -> IR::Automaton
+      def build
+        canonical_states, canonical_transitions = canonical_collection
+        merged_items, merged_transitions = automaton_items(canonical_states, canonical_transitions)
+        states = build_states(merged_items, merged_transitions)
+        states = DefaultReductions.apply(states, terminal_ids: @grammar.terminals.map(&:id))
+        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 }
+        summary = { sr: counted_shift_reduce,
+                    resolved_sr: shift_reduce.length - counted_shift_reduce,
+                    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)
+      end
+
+      private
+
+      # @rbs () -> [Array[item_set], transitions]
+      def canonical_collection
+        seed = Set[[AUGMENTED_PRODUCTION, 0, 0]] #: item_set
+        states = [closure(seed)]
+        transitions = [] #: transitions
+        indexes = { item_key(states.first) => 0 }
+        cursor = 0
+        while cursor < states.length
+          transitions[cursor] = {}
+          next_symbols(states[cursor]).each do |symbol_id|
+            target = go_to(states[cursor], symbol_id)
+            key = item_key(target)
+            target_id = indexes[key] ||= begin
+              states << target
+              states.length - 1
+            end
+            transitions[cursor][symbol_id] = target_id
+          end
+          cursor += 1
+        end
+        [states, transitions]
+      end
+
+      # @rbs (item_set seed) -> item_set
+      def closure(seed)
+        items = seed.dup
+        queue = seed.to_a
+        until queue.empty?
+          production_id, dot, lookahead = queue.shift
+          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)
+          @productions_by_lhs.fetch(grammar_symbol.id, Array.new(0)).each do |production|
+            lookaheads.each do |token_id|
+              item = [production.id, 0, token_id] #: lr_item
+              enqueue_item(items, queue, item)
+            end
+          end
+        end
+        items
+      end
+
+      # @rbs (Array[Integer] suffix, Integer inherited) -> Array[Integer]
+      def suffix_lookaheads(suffix, inherited)
+        bits = @sets.first_of_sequence(suffix)
+        bits |= (1 << inherited) if @sets.sequence_nullable?(suffix)
+        @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)
+
+        items << item
+        queue << item
+      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
+      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
+
+          [production_id, dot + 1, lookahead] #: lr_item
+        end
+        closure(Set.new(moved))
+      end
+
+      # @rbs (Array[item_set] states, transitions transitions) -> [Array[packed_items], transitions]
+      def merge_lalr(states, transitions)
+        groups = {} #: Hash[Array[item_core], Integer]
+        state_groups = states.map do |items|
+          core = core_key(items)
+          groups[core] ||= groups.length
+        end
+        merged = Array.new(groups.length) do
+          Hash.new { |hash, key| hash[key] = Set.new } #: packed_items
+        end
+        states.each_with_index do |items, state_id|
+          items.each { |production, dot, lookahead| merged[state_groups[state_id]][[production, dot]] << lookahead }
+        end
+        merged_transitions = Array.new(groups.length) do
+          {} #: Hash[Integer, Integer]
+        end
+        transitions.each_with_index do |edges, state_id|
+          edges.each { |symbol, target| merged_transitions[state_groups[state_id]][symbol] = state_groups[target] }
+        end
+        [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|
+          packed = Hash.new { |hash, key| hash[key] = Set.new } #: packed_items
+          items.each { |production, dot, lookahead| packed[[production, dot]] << lookahead }
+          packed
+        end
+      end
+
+      # @rbs (Array[packed_items] states) -> void
+      def apply_slr_lookaheads(states)
+        states.each do |items|
+          items.each do |(production_id, dot), lookaheads|
+            next unless dot == rhs_for(production_id).length
+
+            lookaheads.replace(slr_lookaheads(production_id))
+          end
+        end
+      end
+
+      # @rbs (Integer production_id) -> Array[Integer]
+      def slr_lookaheads(production_id)
+        return [0] if production_id == AUGMENTED_PRODUCTION
+
+        lhs = @grammar.productions.fetch(production_id).lhs
+        bits = @sets.follow_bits.fetch(lhs)
+        @grammar.terminals.filter_map { |terminal| terminal.id if bits.anybits?(1 << terminal.id) }
+      end
+
+      # @rbs (Array[packed_items] merged_items, transitions transitions) -> Array[IR::AutomatonState]
+      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)
+          end
+          build_state(state_id, items, transitions[state_id])
+        end
+      end
+
+      # @rbs (Integer state_id, Array[IR::AutomatonItem] items, Hash[Integer, Integer] transitions) -> IR::AutomatonState
+      def build_state(state_id, items, transitions)
+        candidates = Hash.new { |hash, key| hash[key] = Array.new(0) } #: Hash[Integer, Array[IR::parser_action]]
+        gotos = {} #: Hash[Integer, Integer]
+        transitions.each do |symbol_id, target|
+          grammar_symbol = @grammar.symbol_by_id(symbol_id)
+          raise Ibex::Error, "missing grammar symbol id #{symbol_id}" unless grammar_symbol
+
+          if grammar_symbol.terminal?
+            candidates[symbol_id] << { type: :shift, state: target }
+          else
+            gotos[symbol_id] = target
+          end
+        end
+        add_completed_actions(items, candidates)
+        actions, conflicts = resolve_actions(candidates)
+        IR::AutomatonState.new(id: state_id, items: items, transitions: transitions, actions: actions,
+                               gotos: gotos, conflicts: conflicts)
+      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
+                       { type: :accept } #: IR::accept_action
+                     else
+                       { type: :reduce, production: item.production } #: IR::reduce_action
+                     end
+            candidates[lookahead] << action
+          end
+        end
+      end
+
+      # @rbs (Hash[Integer, Array[IR::parser_action]] candidates) ->
+      #   [Hash[Integer, IR::parser_action], Array[IR::conflict]]
+      def resolve_actions(candidates)
+        actions = {} #: Hash[Integer, IR::parser_action]
+        conflicts = [] #: Array[IR::conflict]
+        candidates.keys.sort.each do |token_id|
+          action, found = @resolver.resolve(token_id, candidates[token_id])
+          raise Ibex::Error, "empty parser action candidates" unless action
+
+          actions[token_id] = action
+          conflicts.concat(found)
+        end
+        [actions, conflicts]
+      end
+
+      # @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")
+          return [start.id]
+        end
+
+        @grammar.productions.fetch(production_id).rhs
+      end
+
+      # @rbs (item_set items) -> Array[item_core]
+      def core_key(items)
+        items.map do |production, dot, _lookahead|
+          [production, dot] #: item_core
+        end.uniq.sort
+      end
+
+      # @rbs (item_set items) -> Array[lr_item]
+      def item_key(items)
+        items.to_a.sort
+      end
+    end
+  end
+end