ibex 0.1.0 → 0.3.0

data/lib/ibex/codegen/ruby.rb

@@ -1,11 +1,29 @@
 # 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
+
       # @rbs @automaton: IR::Automaton
       # @rbs @grammar: IR::Grammar
       # @rbs @table_format: Symbol
@@ -16,14 +34,21 @@ 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
+        reject_foreign_actions
         @table_format = table.to_sym
         @embedded = embedded
         @line_convert = line_convert
@@ -32,6 +57,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 +78,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"
@@ -55,50 +95,169 @@ module Ibex
 
       private
 
+      # @rbs () -> void
+      def reject_foreign_actions
+        production = @grammar.productions.find do |entry|
+          entry.action&.code&.include?(foreign_action_sentinel)
+        end
+        return unless production
+
+        location = production.action&.location
+        rendered = location ? "#{location[:file]}:#{location[:line]}:#{location[:column]}" : "(codegen):1:1"
+        raise Ibex::Error,
+              "#{rendered}: cannot generate Ruby from imported C semantic actions; use analysis commands only"
+      end
+
+      # Kept local so the generic generator does not load the optional Bison
+      # importer and its IR validation graph.
+      # @rbs () -> String
+      def foreign_action_sentinel
+        "__ibex_foreign_action_c__"
+      end
+
       # @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
+          require "ibex/runtime/embedded_source"
+          lines << Runtime::EmbeddedSource.render
+        elsif @runtime_require
+          lines << "require #{@runtime_require.inspect}"
         end
         lines << ""
       end
 
-      # @rbs (String relative_path) -> String
-      def embedded_source(relative_path)
-        path = File.expand_path(relative_path, File.dirname(__FILE__))
-        File.read(path).lines.reject { |line| line.start_with?("# frozen_string_literal:") }.join.rstrip
-      end
-
       # @rbs (Array[String] lines) -> void
       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
 
-      # @rbs (untyped table) -> String
+      # 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 () -> CSTMetadata::metadata
+      def cst_metadata
+        @cst_metadata ||= CSTMetadata.new(@grammar, trivia_policy: @cst_trivia).build
+      end
+
+      # @rbs (Object? 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 (Object? 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[untyped] values) -> String
+      def packed_integers_literal(values)
+        Tables::PackedIntegers.encode(values).inspect
+      end
+
+      # @rbs (Array[untyped] values) -> String
+      def packed_signed_integers_literal(values)
+        Tables::PackedIntegers.encode_signed(values).inspect
       end
 
       # @rbs () -> String
@@ -122,77 +281,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 +469,6 @@ module Ibex
         @automaton.grammar_digest.delete_prefix("sha256:").chars.first(12).join
       end
     end
+    # rubocop:enable Metrics/ClassLength
   end
 end

data/lib/ibex/codegen/ruby_actions.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require_relative "action_method_source"
+require_relative "ruby_ast"
+
+module Ibex
+  module Codegen
+    # Semantic-action method generation shared by direct and source-mapped
+    # Ruby output.
+    module RubyActions
+      include RubyAST
+
+      # @rbs @grammar: IR::Grammar
+      # @rbs @line_convert: bool
+      # @rbs @omit_action_call: bool
+      # @rbs @action_method_source: ActionMethodSource?
+
+      private
+
+      # @rbs (Array[String] lines) -> void
+      def append_actions(lines)
+        @grammar.productions.each do |production|
+          next unless action_method?(production)
+
+          if production.node
+            source = ast_node_action_source(production)
+            source.lines.each { |line| lines << "  #{line.rstrip}" }
+            lines << ""
+          elsif composed_action?(production)
+            append_composed_action_method(lines, production)
+          elsif production.action && @line_convert
+            append_compiled_action_method(lines, production)
+          else
+            append_action_method(lines, production)
+          end
+        end
+      end
+
+      # @rbs (Array[String] lines, IR::Production production) -> void
+      def append_composed_action_method(lines, production)
+        action = production.action || raise(Ibex::Error, "missing composed semantic action")
+        plan = action.composition&.dig(:plan) || raise(Ibex::Error, "missing action composition plan")
+        steps = plan.fetch(:steps)
+        steps.each_with_index do |step, index|
+          append_composed_fragment_method(lines, production, step, index) if step[:code]
+        end
+        append_composed_orchestrator(lines, production, plan)
+      end
+
+      # @rbs (Array[String] lines, IR::Production production, IR::action_composition_step step, Integer index) -> void
+      def append_composed_fragment_method(lines, production, step, index)
+        source = action_method_source.composed_fragment_method_source(production, step, index)
+        if @line_convert
+          location = step.fetch(:loc)
+          lines << "  class_eval(#{source.dump}, #{location[:file].inspect}, #{location[:line]})"
+        else
+          code = step.fetch(:code) #: String
+          if action_method_source.column_sensitive?(code)
+            lines << source
+          else
+            source.lines.each { |line| lines << "  #{line.rstrip}" }
+          end
+        end
+        lines << ""
+      end
+
+      # @rbs (IR::Production production, Integer index) -> String
+      def composed_fragment_name(production, index)
+        action_method_source.composed_fragment_name(production, index)
+      end
+
+      # @rbs (Array[String] lines, IR::Production production, IR::action_composition_plan plan) -> void
+      def append_composed_orchestrator(lines, production, plan)
+        lines << "  private def _ibex_action_#{production.id}" \
+                 "(val, _values, _ibex_locations, _ibex_location_stack, _ibex_location, " \
+                 "_ibex_lookahead_location)"
+        lines << "    _ibex_composed_values = val.dup"
+        lines << "    _ibex_composed_locations = _ibex_locations.dup"
+        plan.fetch(:steps).each_with_index do |step, index|
+          append_composed_step(lines, production, step, index)
+        end
+        lines.push("    _ibex_composed_values.last", "  end", "")
+      end
+
+      # @rbs (Array[String] lines, IR::Production production, IR::action_composition_step step, Integer index) -> void
+      def append_composed_step(lines, production, step, index)
+        inputs = step.fetch(:inputs)
+        lines << "    _ibex_step_values = _ibex_composed_values.values_at(#{inputs.join(', ')})"
+        lines << "    _ibex_step_locations = _ibex_composed_locations.values_at(#{inputs.join(', ')})"
+        lookahead = step[:lookahead]
+        boundary = lookahead ? "_ibex_locations[#{lookahead}]" : "_ibex_lookahead_location"
+        lines << "    _ibex_step_location = Ibex::Runtime::LocationSpan.for_reduction(" \
+                 "_ibex_step_locations, lookahead: #{boundary})"
+        result = if step[:code]
+                   stack_inputs = step.fetch(:stack_inputs)
+                   "#{composed_fragment_name(production, index)}(" \
+                     "_ibex_step_values, _values + _ibex_composed_values.values_at(#{stack_inputs.join(', ')}), " \
+                     "_ibex_step_locations, _ibex_location_stack + " \
+                     "_ibex_composed_locations.values_at(#{stack_inputs.join(', ')}), _ibex_step_location)"
+                 else
+                   "_ibex_step_values[0]"
+                 end
+        lines << "    _ibex_composed_values << #{result}"
+        lines << "    _ibex_composed_locations << _ibex_step_location"
+        lines << "    return _ibex_composed_values.last if @accept_requested || @semantic_error"
+      end
+
+      # @rbs (Array[String] lines, IR::Production production) -> void
+      def append_compiled_action_method(lines, production)
+        action = production.action || raise(Ibex::Error, "missing semantic action")
+        source = action_method_source.compiled_action_method_source(production)
+        lines << "  class_eval(#{source.dump}, #{action.location[:file].inspect}, #{action.location[:line]})"
+        lines << ""
+      end
+
+      # @rbs (Array[String] lines, IR::Production production) -> void
+      def append_action_method(lines, production)
+        source = action_method_source.direct_action_method_source(production)
+        if production.action && action_method_source.column_sensitive?(production.action.code)
+          lines << source
+        else
+          source.lines.each { |line| lines << "  #{line.rstrip}" }
+        end
+        lines << ""
+      end
+
+      # @rbs (IR::Production production) -> bool
+      def action_method?(production)
+        !!(production.node || production.action || !@omit_action_call)
+      end
+
+      # @rbs (IR::Production production) -> bool
+      def composed_action?(production)
+        production.action&.composition&.dig(:plan, :version) == 1
+      end
+
+      # @rbs () -> ActionMethodSource
+      def action_method_source
+        @action_method_source ||= ActionMethodSource.new(
+          @grammar, generated_action_abi: @generated_action_abi
+        )
+      end
+    end
+  end
+end