ibex 0.1.0 → 0.2.0

data/lib/ibex/codegen/report.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../lalr"
 require_relative "symbol_labels"
 
 module Ibex
@@ -38,13 +39,22 @@ module Ibex
       #   private def self.symbol_name: (Hash[Integer, String] labels, Integer id) -> String
       #   private def tree_label: (IR::Grammar grammar, Hash[Integer, String] labels, untyped value) -> untyped
       #   private def self.tree_label: (IR::Grammar grammar, Hash[Integer, String] labels, untyped value) -> untyped
+      #   private def display_conflict: (IR::conflict conflict, IR::Grammar grammar,
+      #     Hash[Integer, String] labels) -> Hash[Symbol, untyped]
+      #   private def self.display_conflict: (IR::conflict conflict, IR::Grammar grammar,
+      #     Hash[Integer, String] labels) -> Hash[Symbol, untyped]
+      #   private def format_value: (untyped value) -> String
+      #   private def self.format_value: (untyped value) -> String
 
       # @rbs (IR::Automaton automaton, ?max_tokens: Integer, ?max_configurations: Integer) -> String
       def render(automaton, max_tokens: LALR::Counterexample::DEFAULT_MAX_TOKENS,
                  max_configurations: LALR::Counterexample::DEFAULT_MAX_CONFIGURATIONS)
         grammar = automaton.grammar
         labels = SymbolLabels.build(grammar)
-        lines = ["Algorithm: #{automaton.algorithm}", "States: #{automaton.states.length}", ""]
+        entries = automaton.entry_states.map { |name, state| "#{name}=#{state}" }.join(", ")
+        lines = ["Algorithm: #{automaton.algorithm}", "States: #{automaton.states.length}"]
+        lines << "Entries: #{entries}" if automaton.entry_states.length > 1
+        lines << ""
         examples = LALR::Counterexample.new(
           automaton, max_tokens: max_tokens, max_configurations: max_configurations
         ).all.group_by { |example| example[:state] }
@@ -69,7 +79,9 @@ module Ibex
         end
         lines << "  default: #{format_action(state.default_action)}" if state.default_action
         state.gotos.each { |symbol_id, target| lines << "  goto #{symbol_name(labels, symbol_id)}: #{target}" }
-        state.conflicts.each { |conflict| lines << "  conflict: #{conflict.inspect}" }
+        state.conflicts.each do |conflict|
+          lines << "  conflict: #{format_value(display_conflict(conflict, grammar, labels))}"
+        end
         examples.each { |example| append_counterexample(lines, example, grammar, labels) }
         lines << ""
       end
@@ -77,7 +89,8 @@ module Ibex
       # @rbs skip
       def append_counterexample(lines, example, grammar, labels)
         label = example[:unifying] ? "unifying counterexample" : "nonunifying witness"
-        sentence = example[:sentence].dup.insert(example[:lookahead_index], "•").join(" ")
+        sentence = example[:sentence].map { |name| tree_label(grammar, labels, name) }
+        sentence = sentence.dup.insert(example[:lookahead_index], "•").join(" ")
         lines << "  #{label}: #{sentence}"
         example[:interpretations].each do |interpretation|
           lines << "    #{interpretation[:kind]} derivation:"
@@ -106,7 +119,8 @@ module Ibex
       # @rbs skip
       def format_item(item, grammar, labels)
         if item.production == LALR::Builder::AUGMENTED_PRODUCTION
-          rhs = [grammar.start]
+          start = grammar.symbol(grammar.start)
+          rhs = [grammar.starts.one? && start ? symbol_name(labels, start.id) : "<entry>"]
           lhs = "$accept"
         else
           production = grammar.productions.fetch(item.production)
@@ -137,12 +151,38 @@ module Ibex
         symbol = grammar.symbol(value.to_s)
         symbol ? symbol_name(labels, symbol.id) : value
       end
+
+      # @rbs skip
+      def display_conflict(conflict, grammar, labels)
+        symbol = grammar.symbol(conflict[:symbol])
+        return conflict unless symbol
+
+        conflict.merge(symbol: symbol_name(labels, symbol.id))
+      end
+
+      # Keep reports byte-identical across Ruby versions whose Hash#inspect
+      # formatting differs for symbol keys.
+      # @rbs skip
+      def format_value(value)
+        case value
+        when Hash
+          entries = value.map do |key, item|
+            label = key.is_a?(Symbol) ? "#{key}:" : "#{format_value(key)} =>"
+            "#{label} #{format_value(item)}"
+          end
+          "{#{entries.join(', ')}}"
+        when Array
+          "[#{value.map { |item| format_value(item) }.join(', ')}]"
+        else
+          value.inspect
+        end
+      end
       module_function :append_state, :append_counterexample, :append_tree, :format_item, :format_action, :symbol_name,
-                      :tree_label
+                      :tree_label, :display_conflict, :format_value
 
       class << self
         private :append_state, :append_counterexample, :append_tree, :format_item, :format_action, :symbol_name,
-                :tree_label
+                :tree_label, :display_conflict, :format_value
       end
     end
   end

data/lib/ibex/codegen/ruby.rb

@@ -1,11 +1,81 @@
 # frozen_string_literal: true
 
-require_relative "../runtime/parser"
+require "ibex/runtime/table_format"
+require_relative "cst_metadata"
+require_relative "generated_action_abi"
+require_relative "ruby_actions"
+require_relative "ruby_error_messages"
+require_relative "ruby_table_metadata"
+require_relative "ruby_value_printers"
+require_relative "ruby_lexer"
+require_relative "ruby_ast"
+require_relative "ruby_syntax"
 
 module Ibex
   module Codegen
     # Generates a standalone Ruby parser class from Automaton IR.
+    # rubocop:disable Metrics/ClassLength -- generation stages are split into focused mixins.
     class Ruby
+      include RubyActions
+      include RubyErrorMessages
+      include RubyTableMetadata
+      include RubyValuePrinters
+      include RubyLexer
+      include RubyAST
+      include RubySyntax
+
+      EMBEDDED_RUNTIME_SOURCES = %w[
+        ../runtime/version.rb
+        ../runtime/table_format.rb
+        ../runtime/location_span.rb
+        ../runtime/cst/kind.rb
+        ../runtime/cst/annotation.rb
+        ../runtime/cst/green/trivia.rb
+        ../runtime/cst/green/token.rb
+        ../runtime/cst/green/node.rb
+        ../runtime/cst/green/cache.rb
+        ../runtime/cst/green/builder.rb
+        ../runtime/cst/source_text.rb
+        ../runtime/cst/syntax_token.rb
+        ../runtime/cst/syntax_node.rb
+        ../runtime/cst/cursor.rb
+        ../runtime/cst/typed_node.rb
+        ../runtime/cst/parse_result.rb
+        ../runtime/cst/editing.rb
+        ../runtime/cst/text_edit.rb
+        ../runtime/cst/rewriter.rb
+        ../runtime/cst/editor.rb
+        ../runtime/cst/diff.rb
+        ../runtime/cst/serialized_tree.rb
+        ../runtime/cst/validator.rb
+        ../runtime/cst/serialize.rb
+        ../runtime/cst/incremental/token_memo.rb
+        ../runtime/cst/incremental/relexer.rb
+        ../runtime/cst/incremental/parse_memo.rb
+        ../runtime/cst/incremental/lexed_syntax.rb
+        ../runtime/cst/incremental/blender.rb
+        ../runtime/cst/incremental/session.rb
+        ../runtime/cst.rb
+        ../runtime/ast_data.rb
+        ../runtime/resource_limits.rb
+        ../runtime/event_sanitizer.rb
+        ../runtime/event.rb
+        ../runtime/observation.rb
+        ../runtime/repair.rb
+        ../runtime/repair_priority_queue.rb
+        ../runtime/repair_search.rb
+        ../runtime/parser_sync_recovery.rb
+        ../runtime/parser.rb
+        ../runtime/lexer_input.rb
+        ../runtime/generated_lexer.rb
+        ../runtime/jsonl_tracer.rb
+        ../runtime/event_jsonl_tracer.rb
+        ../tables/compact.rb
+        ../tables/compact_actions.rb
+        ../tables/compact_productions.rb
+      ].freeze #: Array[String]
+      private_constant :EMBEDDED_RUNTIME_SOURCES
+
       # @rbs @automaton: IR::Automaton
       # @rbs @grammar: IR::Grammar
       # @rbs @table_format: Symbol
@@ -16,12 +86,18 @@ module Ibex
       # @rbs @omit_action_call: bool
       # @rbs @superclass: String
       # @rbs @executable: String?
+      # @rbs @cst_trivia: Symbol
+      # @rbs @error_messages: Hash[Integer, String | { id: String, message: String }]
+      # @rbs @generated_action_abi: GeneratedActionABI::Cache
+      # @rbs @runtime_require: String?
 
       # @rbs (IR::Automaton automaton, ?table: Symbol | String, ?embedded: bool, ?line_convert: bool,
       #   ?line_convert_all: bool, ?debug: bool, ?omit_action_call: bool?, ?superclass: String?,
-      #   ?executable: String?) -> void
+      #   ?executable: String?, ?cst_trivia: Symbol | String, ?runtime_require: String?,
+      #   ?error_messages: Hash[Integer, String | { id: String, message: String }]) -> void
       def initialize(automaton, table: :compact, embedded: false, line_convert: true, debug: false,
-                     line_convert_all: false, omit_action_call: nil, superclass: nil, executable: nil)
+                     line_convert_all: false, omit_action_call: nil, superclass: nil, executable: nil,
+                     cst_trivia: :leading, runtime_require: "ibex/runtime", error_messages: {})
         @automaton = automaton
         @grammar = automaton.grammar
         @table_format = table.to_sym
@@ -32,6 +108,15 @@ module Ibex
         @omit_action_call = omit_action_call.nil? ? @grammar.options[:omit_action_call] : omit_action_call
         @superclass = superclass || @grammar.superclass || "Ibex::Runtime::Parser"
         @executable = executable
+        @cst_trivia = cst_trivia.to_sym
+        @generated_action_abi = GeneratedActionABI::Cache.new
+        @runtime_require = runtime_require
+        @cst_trivia = :leading if @cst_trivia == :attach
+        unless %i[leading balanced drop].include?(@cst_trivia)
+          raise ArgumentError, "cst_trivia must be :leading, :balanced, or :drop"
+        end
+
+        @error_messages = error_messages.sort.to_h.freeze
       end
 
       # @rbs () -> String
@@ -44,7 +129,13 @@ module Ibex
         modules, class_name = class_parts
         modules.each { |name| lines << "module #{name}" }
         lines << "class #{class_name} < #{@superclass}"
+        append_ast(lines)
+        append_syntax(lines)
         append_tables(lines)
+        append_parameter_initializer(lines)
+        append_entry_methods(lines)
+        append_lexer(lines)
+        append_value_printers(lines)
         append_actions(lines)
         append_user_code(lines, "inner", indent: 2)
         lines << "end"
@@ -58,11 +149,9 @@ module Ibex
       # @rbs (Array[String] lines) -> void
       def append_runtime(lines)
         if @embedded
-          lines << embedded_source("../runtime/parser.rb")
-          lines << embedded_source("../../ibex/tables.rb")
-        else
-          lines << 'require "ibex/runtime"'
-          lines << 'require "ibex/tables"' if @table_format == :compact
+          EMBEDDED_RUNTIME_SOURCES.each { |path| lines << embedded_source(path) }
+        elsif @runtime_require
+          lines << "require #{@runtime_require.inspect}"
         end
         lines << ""
       end
@@ -77,28 +166,134 @@ module Ibex
       def append_tables(lines)
         table_set = Tables.build(@automaton, format: @table_format)
         indent = "  "
-        lines << "#{indent}PARSER_TABLE_FORMAT_VERSION = #{Runtime::PARSER_TABLE_FORMAT_VERSION}"
+        append_table_metadata(lines, indent)
         lines << "#{indent}TOKEN_IDS = #{token_ids_literal}.freeze"
         lines << "#{indent}TOKEN_NAMES = #{token_names_literal}.freeze"
+        append_cst_metadata(lines, indent)
         lines << "#{indent}ACTIONS = #{table_literal(table_set.actions)}"
         lines << "#{indent}GOTOS = #{table_literal(table_set.gotos)}"
         lines << "#{indent}DEFAULT_ACTIONS = #{table_set.default_actions.inspect}.freeze"
+        eager_type = "Hash[Integer, [:reduce, Integer]]"
+        lines << "#{indent}eager_reductions = #{eager_reductions_literal} # @type var eager_reductions: #{eager_type}"
+        lines << "#{indent}EAGER_REDUCTIONS = eager_reductions.freeze #: #{eager_type}"
         lines << "#{indent}PRODUCTIONS = #{productions_literal}.freeze"
+        append_value_printer_table(lines, indent)
+        declaration = "#{indent}error_messages = #{error_messages_literal}"
+        type = "Hash[Integer, String | { id: String, message: String }]"
+        lines << "#{declaration} # @type var error_messages: #{type}"
+        lines << "#{indent}ERROR_MESSAGES = error_messages.freeze #: #{type}"
+        append_parser_tables(lines, indent, table_set)
+        lines << "#{indent}def self.parser_tables = PARSER_TABLES"
+        lines << "#{indent}DEBUG_ENABLED = #{@debug}"
+        lines << ""
+      end
+
+      # @rbs (Array[String] lines, String indent) -> void
+      def append_cst_metadata(lines, indent)
+        return unless cst?
+
+        lines << "#{indent}SYMBOL_NAMES = #{symbol_names_literal}.freeze"
+        lines << "#{indent}CST_METADATA = #{deep_frozen_literal(cst_metadata)}"
+        lines << "#{indent}CST_KIND_MODEL = Ibex::Runtime::CST::Kind.new("
+        lines << "#{indent}  CST_METADATA.fetch(:kinds), slots: CST_METADATA.fetch(:slots)"
+        lines << "#{indent})"
+      end
+
+      # @rbs (Array[String] lines, String indent, Tables::TableSet table_set) -> void
+      def append_parser_tables(lines, indent, table_set)
         lines << "#{indent}PARSER_TABLES = { format_version: PARSER_TABLE_FORMAT_VERSION,"
+        lines << "#{indent}                  grammar_digest: GRAMMAR_DIGEST,"
+        lines << "#{indent}                  state_count: STATE_COUNT, production_count: PRODUCTION_COUNT,"
+        lines << "#{indent}                  uses_locations: #{uses_locations?},"
+        if @table_format == :compact
+          default_codes = table_set.default_actions.map { |action| Tables::CompactActions.pack(action) }
+          lines << "#{indent}                  compact_fast_driver: true, " \
+                   "compact_action_encoding: :signed, compact_default_actions: #{default_codes.inspect}.freeze,"
+        end
+        lines << "#{indent}                  cst: CST_METADATA, cst_kinds: CST_KIND_MODEL," if cst?
+        lines << "#{indent}                  exact_expected_tokens: true," if @grammar.mode == :extended
         lines << "#{indent}                  tokens: TOKEN_IDS, token_names: TOKEN_NAMES, actions: ACTIONS,"
         lines << "#{indent}                  gotos: GOTOS, default_actions: DEFAULT_ACTIONS,"
-        lines << "#{indent}                  productions: PRODUCTIONS }.freeze"
-        lines << "#{indent}def self.parser_tables = PARSER_TABLES"
-        lines << "#{indent}DEBUG_ENABLED = #{@debug}"
+        entries = entry_table_fields
+        recovery = recovery_table_fields
+        value_printers = @grammar.value_printers.empty? ? "" : " value_printers: VALUE_PRINTERS,"
+        lines << "#{indent}                  productions: PRODUCTIONS,#{entries}#{value_printers} " \
+                 "#{recovery} eager_reductions: EAGER_REDUCTIONS, error_messages: ERROR_MESSAGES }.freeze"
+        return unless shareable_parser_tables?
+
+        lines << "#{indent}Ractor.make_shareable(PARSER_TABLES) " \
+                 "if defined?(Ractor) && Ractor.respond_to?(:make_shareable)"
+      end
+
+      # @rbs (Array[String] lines) -> void
+      def append_parameter_initializer(lines)
+        parameters = @grammar.parser_parameters
+        return if parameters.empty?
+
+        keywords = parameters.map { |parameter| "#{parameter[:name]}:" }.join(", ")
+        lines << "  IBEX_PARAMETER_INITIALIZER = Module.new do"
+        lines << "    def initialize(#{keywords}, **_ibex_super_arguments)"
+        parameters.each { |parameter| lines << "      @#{parameter[:name]} = #{parameter[:name]}" }
+        lines << "      super(**_ibex_super_arguments)"
+        lines << "    end"
+        lines << "  end"
+        lines << "  prepend IBEX_PARAMETER_INITIALIZER"
+        lines << "  private_constant :IBEX_PARAMETER_INITIALIZER"
         lines << ""
       end
 
+      # Custom conversion expressions can return caller-owned mutable or
+      # inherently unshareable objects, so only standard token mappings are
+      # safe to freeze transitively.
+      # @rbs () -> bool
+      def shareable_parser_tables?
+        @grammar.conversions.empty?
+      end
+
+      # @rbs () -> Hash[Symbol, untyped]
+      def cst_metadata
+        @cst_metadata ||= CSTMetadata.new(@grammar, trivia_policy: @cst_trivia).build
+      end
+
+      # @rbs (untyped value) -> String
+      def deep_frozen_literal(value)
+        case value
+        when Array
+          "[#{value.map { |item| deep_frozen_literal(item) }.join(', ')}].freeze"
+        when Hash
+          entries = value.map do |key, item|
+            "#{deep_frozen_literal(key)} => #{deep_frozen_literal(item)}"
+          end
+          "{ #{entries.join(', ')} }.freeze"
+        when String
+          "#{value.inspect}.freeze"
+        else
+          value.inspect
+        end
+      end
+
       # @rbs (untyped table) -> String
       def table_literal(table)
+        if table.is_a?(Tables::CompactActions)
+          return "Ibex::Tables::CompactActions.packed(#{packed_integers_literal(table.offsets)}, " \
+                 "#{packed_signed_integers_literal(table.codes)}, #{packed_integers_literal(table.checks)}, " \
+                 "row_count: #{table.row_count}, encoding: :signed, column_count: #{table.column_count})"
+        end
         return "#{table.inspect}.freeze" unless table.is_a?(Tables::Compact)
 
-        "Ibex::Tables::Compact.new(offsets: #{table.offsets.inspect}, values: #{table.values.inspect}, " \
-          "checks: #{table.checks.inspect}, row_count: #{table.row_count})"
+        "Ibex::Tables::Compact.packed(#{packed_integers_literal(table.offsets)}, " \
+          "#{packed_integers_literal(table.values)}, #{packed_integers_literal(table.checks)}, " \
+          "row_count: #{table.row_count}, dense_width: #{table.dense_width})"
+      end
+
+      # @rbs (Array[Integer?] values) -> String
+      def packed_integers_literal(values)
+        Tables::PackedIntegers.encode(values).inspect
+      end
+
+      # @rbs (Array[Integer?] values) -> String
+      def packed_signed_integers_literal(values)
+        Tables::PackedIntegers.encode_signed(values).inspect
       end
 
       # @rbs () -> String
@@ -122,77 +317,156 @@ module Ibex
 
       # @rbs () -> String
       def token_names_literal
-        entries = @grammar.terminals.map { |terminal| "#{terminal.id} => #{terminal.name.inspect}" }
+        entries = @grammar.terminals.map do |terminal|
+          "#{terminal.id} => #{(terminal.display_name || terminal.name).inspect}"
+        end
+        "{ #{entries.join(', ')} }"
+      end
+
+      # @rbs () -> String
+      def symbol_names_literal
+        entries = @grammar.symbols.map { |symbol| "#{symbol.id} => #{symbol.name.inspect}" }
         "{ #{entries.join(', ')} }"
       end
 
       # @rbs () -> String
       def productions_literal
+        return compact_productions_literal if @table_format == :compact
+
+        plain_productions_literal
+      end
+
+      # @rbs () -> String
+      def plain_productions_literal
         entries = @grammar.productions.map do |production|
-          action = action_method?(production) ? ":_ibex_action_#{production.id}" : "nil"
-          "{ lhs: #{production.lhs}, length: #{production.rhs.length}, action: #{action} }"
+          generated_action = action_method?(production)
+          action = generated_action ? ":_ibex_action_#{production.id}" : "nil"
+          action_abi = production_action_abi_literal(production, generated_action)
+          composition_action = composed_action?(production) ? ", composition_action: true" : ""
+          cst_rhs = cst? ? ", rhs: #{production.rhs.inspect}.freeze" : ""
+          location_context, named_locations = production_location_metadata(production.action)
+          "{ lhs: #{production.lhs}, length: #{production.rhs.length}, action: #{action}" \
+            "#{action_abi}#{composition_action}#{cst_rhs}#{location_context}#{named_locations} }"
         end
         "[#{entries.join(', ')}]"
       end
 
-      # @rbs (Array[String] lines) -> void
-      def append_actions(lines)
-        @grammar.productions.each do |production|
-          next unless action_method?(production)
+      # @rbs (IR::Production production, bool generated_action) -> String
+      def production_action_abi_literal(production, generated_action)
+        return "" unless generated_action
+        return ", location_action: true" unless @generated_action_abi.values_only?(production)
+        return ", positional_action: true" if @generated_action_abi.positional_values?(production)
+
+        borrowed = if @generated_action_abi.borrowed_values?(production)
+                     ", borrowed_values_action: true"
+                   else
+                     ""
+                   end
+        ", values_action: true#{borrowed}"
+      end
+
+      # @rbs () -> String
+      def compact_productions_literal
+        lhs_ids = @grammar.productions.map(&:lhs)
+        lengths = @grammar.productions.map { |production| production.rhs.length }
+        flags = @grammar.productions.map { |production| compact_production_flags(production) }
+        metadata = compact_production_metadata_literal
+        "Ibex::Tables::CompactProductions.packed(#{packed_integers_literal(lhs_ids)}, " \
+          "#{packed_integers_literal(lengths)}, #{packed_integers_literal(flags)}, metadata: #{metadata})"
+      end
+
+      # @rbs (IR::Production production) -> Integer
+      def compact_production_flags(production)
+        return 0 unless action_method?(production)
 
-          append_action_constant(lines, production)
-          append_action_method(lines, production)
+        value = 0
+        if @generated_action_abi.positional_values?(production)
+          value |= Tables::CompactProductions::POSITIONAL_ACTION
+        elsif @generated_action_abi.values_only?(production)
+          value |= Tables::CompactProductions::VALUES_ACTION
+          value |= Tables::CompactProductions::BORROWED_VALUES_ACTION if
+            @generated_action_abi.borrowed_values?(production)
+        else
+          value |= Tables::CompactProductions::LOCATION_ACTION
         end
+        value |= Tables::CompactProductions::COMPOSITION_ACTION if composed_action?(production)
+        value
       end
 
-      # @rbs (Array[String] lines, IR::Production production) -> void
-      def append_action_constant(lines, production)
-        return unless production.action && @line_convert
+      # @rbs () -> String
+      def compact_production_metadata_literal
+        entries = @grammar.productions.filter_map do |production|
+          fields = [] #: Array[String]
+          fields << "rhs: #{production.rhs.inspect}.freeze" if cst?
+          action = production.action
+          if action
+            fields << "location_context_length: #{action.context_length}" if action.context_length.positive?
+            names = action.named_refs.to_h { |reference| [reference[:name].to_sym, reference[:index]] }
+            fields << "location_names: #{names.inspect}.freeze" unless names.empty?
+          end
+          next if fields.empty?
 
-        lines << "  ACTION_CODE_#{production.id} = #{production.action.code.inspect}.freeze"
+          "#{production.id} => { #{fields.join(', ')} }.freeze"
+        end
+        entries.empty? ? "Hash.new.freeze" : "{ #{entries.join(', ')} }.freeze"
       end
 
-      # @rbs (Array[String] lines, IR::Production production) -> void
-      def append_action_method(lines, production)
-        action = production.action
-        lines << "  private def _ibex_action_#{production.id}(val, _values)"
-        lines << "    val = _values.last(#{action.context_length})" if action&.context_length&.positive?
-        append_named_bindings(lines, action)
-        if action
-          append_semantic_code(lines, production)
-        else
-          lines << "    val[0]"
+      # Reductions that are the sole non-error behavior of a state may run
+      # before requesting another lexer token. This enables parser actions to
+      # select lexer_state without speculative lookahead.
+      # @rbs () -> String
+      def eager_reductions_literal
+        return "{}" unless @grammar.lexer
+
+        entries = @automaton.states.filter_map do |state|
+          action = eager_lexer_feedback_reduction(state)
+          next unless action
+
+          "#{state.id} => [:reduce, #{action.fetch(:production)}].freeze"
         end
-        lines << "  end"
-        lines << ""
+        "{ #{entries.join(', ')} }"
       end
 
-      # @rbs (Array[String] lines, IR::Action? action) -> void
-      def append_named_bindings(lines, action)
-        return unless action&.named_refs&.any?
+      # @rbs (IR::AutomatonState state) -> IR::reduce_action?
+      def eager_lexer_feedback_reduction(state)
+        candidates = state.actions.values
+        candidates += [state.default_action] if state.default_action
+        actions = candidates.reject { |action| action[:type] == :error }.uniq
+        return unless actions.one?
+        return unless actions.first[:type] == :reduce
 
-        action.named_refs.each { |reference| lines << "    #{reference[:name]} = val[#{reference[:index]}]" }
-        names = action.named_refs.map { |reference| reference[:name] }
-        lines << "    _ibex_named_values = [#{names.join(', ')}]"
+        reduction = actions.first #: IR::reduce_action
+        production = @grammar.productions.fetch(reduction.fetch(:production))
+        reduction if production.action&.code&.match?(/\blexer_state\s*=/)
       end
 
-      # @rbs (Array[String] lines, IR::Production production) -> void
-      def append_semantic_code(lines, production)
-        action = production.action || raise(Ibex::Error, "missing semantic action")
-        lines << "    result = val[0]" if @grammar.options[:result_var]
-        if @line_convert
-          evaluation = "eval(ACTION_CODE_#{production.id}, binding, #{action.location[:file].inspect}, " \
-                       "#{action.location[:line]})"
-          lines << "    #{@grammar.options[:result_var] ? evaluation : "return #{evaluation}"}"
-        else
-          action.code.lines.each { |line| lines << "    #{line.rstrip}" }
+      # @rbs (IR::Action? action) -> [String, String]
+      def production_location_metadata(action)
+        return ["", ""] unless action
+
+        context = action.context_length.positive? ? ", location_context_length: #{action.context_length}" : ""
+        names = action.named_refs.to_h { |reference| [reference[:name].to_sym, reference[:index]] }
+        named = names.empty? ? "" : ", location_names: #{names.inspect}.freeze"
+        [context, named]
+      end
+
+      # @rbs () -> bool
+      def uses_locations?
+        cst? || @grammar.productions.any? do |production|
+          action = production.action
+          action && (!action.composition.nil? || action_references_locations?(production, action))
         end
-        lines << "    result" if @grammar.options[:result_var]
       end
 
-      # @rbs (IR::Production production) -> bool
-      def action_method?(production)
-        !!(production.action || !@omit_action_call)
+      # @rbs (IR::Production production, IR::Action action) -> bool
+      def action_references_locations?(production, action)
+        maximum = action.context_length.positive? ? action.context_length : production.rhs.length
+        ActionLocations.new(action.code, maximum: maximum, location: action.location).references?
+      end
+
+      # @rbs () -> bool
+      def cst?
+        @grammar.options[:cst] == true
       end
 
       # @rbs (Array[String] lines, String name, ?indent: Integer) -> void
@@ -231,5 +505,6 @@ module Ibex
         @automaton.grammar_digest.delete_prefix("sha256:").chars.first(12).join
       end
     end
+    # rubocop:enable Metrics/ClassLength
   end
 end