arpaka 0.1.1 → 2.0.0

data/lib/arpaka/ruby/class_name_parser.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Arpaka::Ruby
+  class ClassName
+    attr_reader :components
+
+    def initialize(components)
+      @components = components.freeze
+      freeze
+    end
+
+    def namespaces
+      components[0...-1]
+    end
+
+    def constant
+      components.last
+    end
+
+    def resolve(root)
+      components.reduce(root) { |namespace, name| namespace.const_get(name, false) }
+    end
+
+    def to_s
+      components.join("::")
+    end
+  end
+
+  class ClassNameParser
+    def self.parse(value)
+      new(value).parse
+    end
+
+    def initialize(value)
+      @value = value
+      @index = 0
+      @components = []
+    end
+
+    def parse
+      unless @value.is_a?(String)
+        invalid("must be a String")
+      end
+
+      parse_component
+      until end_of_input?
+        parse_separator
+        parse_component
+      end
+      ClassName.new(@components)
+    end
+
+    private
+
+    def parse_component
+      component_number = @components.length + 1
+      if end_of_input? || current_byte == 58
+        invalid("component #{component_number} is empty")
+      end
+      unless uppercase_byte?(current_byte)
+        invalid("component #{component_number} must start with an uppercase letter")
+      end
+
+      start = @index
+      @index += 1
+      @index += 1 while identifier_byte?(current_byte)
+      @components << @value.byteslice(start, @index - start)
+    end
+
+    def parse_separator
+      unless current_byte == 58 && @value.getbyte(@index + 1) == 58
+        invalid("expected `::` after component #{@components.length}")
+      end
+      @index += 2
+    end
+
+    def end_of_input?
+      @index >= @value.bytesize
+    end
+
+    def current_byte
+      @value.getbyte(@index)
+    end
+
+    def uppercase_byte?(byte)
+      byte && byte.between?(65, 90)
+    end
+
+    def identifier_byte?(byte)
+      byte && (uppercase_byte?(byte) || byte.between?(97, 122) || byte.between?(48, 57) || byte == 95)
+    end
+
+    def invalid(message)
+      raise ::Arpaka::Error, "invalid class_name: #{message}"
+    end
+  end
+end

data/lib/arpaka/ruby/cli.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "optparse"
+require "tempfile"
+require_relative "../../arpaka"
+
+module Arpaka::Ruby
+  class CLI
+    def self.run(argv, out: $stdout, err: $stderr)
+      options = { class_name: "RubyParser" }
+      force = false
+      help = false
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: arpaka generate (--ruby-source DIR | --parse-y FILE) --output FILE [--class-name NAME] [--ast-type detailed|structured] [--force]"
+        opts.on("--ruby-source DIR", "Ruby source tree (provided by the user)") { |v| options[:ruby_source] = v }
+        opts.on("--parse-y FILE", "parse.y file (use Arpaka's token definitions)") { |v| options[:parse_y] = v }
+        opts.on("--output FILE", "Write a standalone Ruby frontend") { |v| options[:output] = v }
+        opts.on("--class-name NAME", "Generated class name (default: RubyParser)") { |v| options[:class_name] = v }
+        opts.on("--ast-type TYPE", %w[detailed structured], "AST output type (default: detailed)") { |v| options[:ast_type] = v }
+        opts.on("--force", "Replace an existing output file") { force = true }
+        opts.on("-h", "--help", "Show usage") { help = true }
+      end
+      args = argv.dup
+      command = args.shift
+      if ["--help", "-h"].include?(command)
+        out.puts(parser)
+        return 0
+      end
+      raise OptionParser::InvalidArgument, "expected generate" unless command == "generate"
+      parser.parse!(args)
+      if help
+        out.puts(parser)
+        return 0
+      end
+      raise OptionParser::InvalidArgument, args.join(" ") unless args.empty?
+      raise OptionParser::InvalidArgument, "specify exactly one of --ruby-source or --parse-y" if options[:ruby_source] == options[:parse_y]
+      raise OptionParser::MissingArgument, "--output" unless options[:output]
+      %i[output].each do |key|
+        raise OptionParser::MissingArgument, "--#{key.to_s.tr('_', '-')}" unless options[key]
+      end
+      output = File.expand_path(options.delete(:output))
+      if !force && (File.exist?(output) || File.symlink?(output))
+        raise ::Arpaka::Error, "Output already exists: #{output}; use --force to replace it"
+      end
+      source = Arpaka::Ruby.generate(**options)
+      Tempfile.create([".arpaka-", ".rb"], File.dirname(output)) do |file|
+        file.write(source)
+        file.flush
+        file.chmod(0o644)
+        if force
+          File.rename(file.path, output)
+        else
+          # Publish only the complete file, without overwriting a concurrent writer.
+          File.link(file.path, output)
+        end
+      end
+      out.puts("Generated #{output}")
+      0
+    rescue OptionParser::ParseError, Lrama::Ruby::Error, SystemCallError => error
+      err.puts("arpaka: #{error.message}")
+      1
+    end
+  end
+end

data/lib/arpaka/ruby/frontend_emitter.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "digest"
+require "erb"
+require "json"
+
+module Arpaka::Ruby
+  class FrontendEmitter
+    RuntimeBundle = Data.define(:templates)
+    DETAILED_RUNTIME_BUNDLE = RuntimeBundle.new(
+      %w[frontend detailed/ast detailed/builder lexer].freeze
+    ).freeze
+    STRUCTURED_RUNTIME_BUNDLE = RuntimeBundle.new(
+      %w[frontend detailed/ast detailed/builder lexer structured].freeze
+    ).freeze
+
+    def emit(parser:, artifacts:, class_name:, grammar_filename:, ruby_source:,
+      runtime_bundle: DETAILED_RUNTIME_BUNDLE, ast_type: :detailed)
+      rules = JSON.parse(artifacts.fetch("rules.json"))
+      runtime_options = artifacts.fetch("runtime", {})
+      runtime = runtime_bundle.templates.map do |template_name|
+        template = File.read(File.join(__dir__, "runtime", "#{template_name}.rb.erb"))
+        ERB.new(template, trim_mode: "-").result_with_hash(rules: rules, runtime: runtime_options,
+          ast_type: ast_type)
+      end.join("\n")
+      notices = [File.read(File.expand_path("../../../LICENSE.txt", __dir__))]
+      %w[COPYING BSDL].each do |name|
+        path = ruby_source ? File.join(ruby_source, name) : File.join(__dir__, name)
+        notices << File.read(path)
+      end
+      source = "# frozen_string_literal: true\n" \
+        "# Generated by Arpaka #{Lrama::Ruby::VERSION}. Do not edit.\n" \
+        "# Ruby source profile: #{ruby_source ? artifacts.fetch('source_profile') : 'parse.y only'}\n" \
+        "# parse.y SHA256: #{Digest::SHA256.file(grammar_filename).hexdigest}\n" \
+        "#{notices.join("\n").lines.map { |line| "# #{line}" }.join}\n"
+      source << wrap_class(class_name, parser, runtime)
+      validate(source)
+      source
+    rescue SyntaxError => error
+      raise ::Arpaka::Error, "Invalid generated frontend: #{error.message}"
+    end
+
+    private
+
+    def validate(source)
+      # Compile in an isolated box to validate syntax without executing actions.
+      ::Ruby::Box.new.eval(source)
+    end
+
+    def wrap_class(class_name, parser, runtime)
+      definition = "class #{class_name.constant}\n#{parser}\n#{runtime}\nend\n"
+      class_name.namespaces.reverse_each do |namespace|
+        body = definition.lines.map { |line| "  #{line}" }.join
+        definition = "module #{namespace}\n#{body}end\n"
+      end
+      definition
+    end
+  end
+end

data/lib/arpaka/ruby/generator.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "grammar"
+require_relative "class_name_parser"
+require_relative "frontend_emitter"
+
+module Arpaka::Ruby
+  class Generator
+    def generate(ruby_source: nil, parse_y: nil, class_name:, ast_type: :detailed,
+      runtime_bundle: nil)
+      if ruby_source.nil? == parse_y.nil?
+        raise ::Arpaka::Error, "specify exactly one of ruby_source or parse_y"
+      end
+      ast_type = case ast_type.to_s
+      when "detailed" then :detailed
+      when "structured" then :structured
+      else
+        raise ::Arpaka::Error, "ast_type must be detailed or structured"
+      end
+      runtime_bundle ||= ast_type == :structured ?
+        FrontendEmitter::STRUCTURED_RUNTIME_BUNDLE : FrontendEmitter::DETAILED_RUNTIME_BUNDLE
+      class_name = ClassNameParser.parse(class_name)
+      unless ::Ruby::Box.enabled?
+        raise ::Arpaka::Error, "Ruby Box is required for generation. Start Ruby with RUBY_BOX=1."
+      end
+      artifacts = Grammar.artifacts(ruby_source: ruby_source, parse_y: parse_y)
+      grammar_filename = parse_y || File.join(ruby_source, "parse.y")
+      parser = Lrama::Ruby.generate(artifacts.fetch("parse.y"),
+        filename: grammar_filename, class_name: "Parser", allow_error_rules: true)
+      parser = parser.delete_prefix("# frozen_string_literal: true\n")
+      FrontendEmitter.new.emit(parser: parser, artifacts: artifacts, class_name: class_name,
+        grammar_filename: grammar_filename, ruby_source: ruby_source, runtime_bundle: runtime_bundle,
+        ast_type: ast_type)
+    rescue SyntaxError => error
+      raise ::Arpaka::Error, "Invalid generated frontend: #{error.message}"
+    rescue SystemCallError => error
+      raise ::Arpaka::Error, "Cannot read Ruby frontend inputs: #{error.message}"
+    end
+
+  end
+end

data/lib/arpaka/{ruby_grammar.rb → ruby/grammar.rb}

@@ -3,16 +3,10 @@
 require "lrama"
 require "json"
 require "digest"
-require "open3"
-require "rbconfig"
-require_relative "actions"
+require_relative "grammar_emitter"
 
-module Arpaka::RubyGrammar
+module Arpaka::Ruby::Grammar
   REVISION = "37d60dd3241d5fdb10ca43f36077f5d556ae1b8d"
-  EXTENDED_RULES = {
-    ["value_expr_command", ["command"]] => "tLBRACE_ARG"
-  }.freeze
-
   def self.parse(source, filename)
     grammar = Lrama::Parser.new(source, filename).parse
     unless grammar.no_stdlib
@@ -35,10 +29,20 @@ module Arpaka::RubyGrammar
       warn "Arpaka: Ruby source differs from the recorded profile: #{path}; " \
         "expected SHA256 #{digest}, got #{actual}."
     end
-    source, error, result = Open3.capture3(RbConfig.ruby,
-      File.join(vendor, "tool/id2token.rb"), File.join(vendor, "parse.y"))
-    raise ::Arpaka::Error, "Ruby preprocessing failed: #{error}" unless result.success?
+    source = preprocess(File.read(File.join(vendor, "parse.y")),
+      File.join(vendor, "defs/id.def"))
     grammar = parse(source, File.join(vendor, "parse.y"))
+    [grammar, inventory(grammar)]
+  end
+
+  def self.load_parse_y(parse_y)
+    path = File.expand_path(parse_y)
+    source = preprocess_names(File.read(path))
+    grammar = parse(source, path)
+    [grammar, inventory(grammar)]
+  end
+
+  def self.inventory(grammar)
     inventory = grammar.rules.reject(&:initial_rule?).map do |rule|
       { "id" => rule.id, "lhs" => rule.lhs.id.s_value,
         "rhs" => rule.rhs.map { |symbol| symbol.id.s_value },
@@ -47,9 +51,34 @@ module Arpaka::RubyGrammar
         "midrule_position" => rule.position_in_original_rule_rhs,
         "precedence" => rule.precedence_sym&.id&.s_value }
     end
-    unknown = ::Arpaka::RubyGrammarActions::ACTIONS.keys - inventory.map { |rule| rule.fetch("id") }
-    warn "Arpaka: Unknown action IDs: #{unknown.inspect}" unless unknown.empty?
-    [grammar, inventory]
+    inventory
+  end
+
+  # Ruby's id.def is Ruby code. Evaluate it in a Box so its temporary locals,
+  # methods and constants cannot affect Arpaka or Lrama's process.
+  def self.preprocess(source, id_def)
+    box = ::Ruby::Box.new
+    ids = box.eval(File.read(id_def))
+    tokens = ids.fetch(:token_op).each_with_object({}) do |(_id, _op, token, id), result|
+      result[token] = id if token
+    end
+    return source unless tokens.any?
+
+    names = tokens.keys.map { |name| Regexp.escape(name) }.join("|")
+    token_pattern = /\bRUBY_TOKEN\((#{names})\)\s*(?=\s)/
+    source.lines.map do |line|
+      if line.start_with?("%token")
+        line.gsub(token_pattern) { tokens.fetch(Regexp.last_match(1)).to_s }
+      else
+        line
+      end
+    end.join
+  rescue KeyError, TypeError, SyntaxError => error
+    raise ::Arpaka::Error, "Ruby id.def preprocessing failed: #{error.message}"
+  end
+
+  def self.preprocess_names(source)
+    source.gsub(/\bRUBY_TOKEN\(([A-Za-z_][A-Za-z0-9_]*)\)/, '\\1')
   end
 
   def self.symbol_names(grammar)
@@ -69,52 +98,17 @@ module Arpaka::RubyGrammar
     end
   end
 
-  def self.artifacts(ruby_source:)
-    grammar, inventory = load_upstream(ruby_source)
-    names = symbol_names(grammar)
-    name = ->(symbol) { symbol.term ? symbol.id.s_value : names.fetch(symbol.id.s_value) }
-    lines = ["/* Generated from ruby/ruby #{REVISION}. See Arpaka Action mappings. */",
-      "%no-stdlib", "%expect #{grammar.expect || 0}"]
-    lines << "%define lr.type ielr" if grammar.ielr_defined?
-    grammar.terms.each do |symbol|
-      next if symbol.error_symbol? || symbol.undef_symbol?
-      declaration = "%token #{name.call(symbol)} #{symbol.token_id}"
-      declaration += " #{symbol.alias_name}" if symbol.alias_name
-      lines << declaration
-    end
-    grammar.precedences.group_by(&:precedence).sort.each do |_level, group|
-      lines << "%#{group.first.type} #{group.map(&:s_value).join(' ')}"
+  def self.artifacts(ruby_source: nil, parse_y: nil)
+    grammar, inventory = if ruby_source
+      load_upstream(ruby_source)
+    else
+      load_parse_y(parse_y)
     end
-    lines << "%left keyword_do_block"
-    lines << "%start #{name.call(grammar.rules.first.rhs.first)}"
-    lines << "%%"
-    metadata = inventory.to_h { |rule| [rule.fetch("id"), rule] }
-    rules = grammar.rules.reject(&:initial_rule?)
-    rules.each do |rule|
-      rhs = rule.rhs.empty? ? "%empty" : rule.rhs.map(&name).join(" ")
-      extended_precedence = EXTENDED_RULES[[rule.lhs.id.s_value, rule.rhs.map { |symbol| symbol.id.s_value }]]
-      precedence = if rule.precedence_sym
-        " %prec #{name.call(rule.precedence_sym)}"
-      elsif extended_precedence
-        " %prec #{extended_precedence}"
-      else
-        ""
-      end
-      expression = ::Arpaka::RubyGrammarActions::ACTIONS[rule.id]&.last || "@builder.unsupported(#{rule.id})"
-      lines << "/* upstream parse.y:#{metadata.fetch(rule.id).fetch('line')}: #{rule.as_comment} */"
-      lines << "#{name.call(rule.lhs)}: #{rhs}#{precedence} { $$ = #{expression} };"
-    end
-    lines << "/* arpaka extension: block call as a parenthesized argument */"
-    lines << "call_args: block_call { $$ = [$1].freeze };"
-    lines << "call_args: args ',' block_call %prec tLOWEST { $$ = ($1 + [$3]).freeze };"
-    source = lines.join("\n") + "\n"
+    names = symbol_names(grammar)
+    artifacts = ::Arpaka::Ruby::GrammarEmitter.new(grammar: grammar, inventory: inventory, names: names).emit
+    source = artifacts.fetch("parse.y")
     verify_structure(grammar, source, names)
-    compact = rules.map do |rule|
-      { id: rule.id, rule: rule.as_comment,
-        line: metadata.fetch(rule.id).fetch("line"),
-        status: ::Arpaka::RubyGrammarActions::ACTIONS[rule.id]&.first || "unsupported" }
-    end
-    { "parse.y" => source, "rules.json" => JSON.pretty_generate(compact) + "\n" }
+    artifacts
   end
 
   def self.verify_structure(original, source, names)
@@ -127,7 +121,7 @@ module Arpaka::RubyGrammar
       end.sort_by(&:inspect)
     end
     expected_rules = signature.call(original, names).map do |rule|
-      if rule[0] == names.fetch("value_expr_command") && rule[1] == [names.fetch("command")]
+      if names.key?("value_expr_command") && rule[0] == names.fetch("value_expr_command") && rule[1] == [names.fetch("command")]
         rule[0, 2] + ["tLBRACE_ARG"]
       else
         rule

data/lib/arpaka/ruby/grammar_emitter.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "actions"
+require_relative "profile"
+
+module Arpaka::Ruby
+  class GrammarEmitter
+    EXTENDED_RULES = {
+      ["value_expr_command", ["command"]] => "tLBRACE_ARG"
+    }.freeze
+
+    def initialize(grammar:, inventory:, names:)
+      @grammar = grammar
+      @inventory = inventory
+      @names = names
+    end
+
+    def emit
+      name = ->(symbol) { symbol.term ? symbol.id.s_value : @names.fetch(symbol.id.s_value) }
+      profile = ::Arpaka::Ruby::Profile.select(@grammar)
+      expected_conflicts = (@grammar.expect || 0) + profile.fetch("additional_expected_conflicts", 0)
+      lines = ["/* Generated from ruby/ruby #{Arpaka::Ruby::Grammar::REVISION}. See Arpaka Action mappings. */",
+        "%no-stdlib", "%expect #{expected_conflicts}"]
+      lines << "%define lr.type ielr" if @grammar.ielr_defined?
+      @grammar.terms.each do |symbol|
+        next if symbol.error_symbol? || symbol.undef_symbol?
+        declaration = "%token #{name.call(symbol)} #{symbol.token_id}"
+        declaration += " #{symbol.alias_name}" if symbol.alias_name
+        lines << declaration
+      end
+      @grammar.precedences.group_by(&:precedence).sort.each do |_level, group|
+        lines << "%#{group.first.type} #{group.map(&:s_value).join(' ')}"
+      end
+      lines << "%left keyword_do_block"
+      lines << "%start #{name.call(@grammar.rules.first.rhs.first)}"
+      lines << "%%"
+      metadata = @inventory.to_h { |rule| [rule.fetch("id"), rule] }
+      rules = @grammar.rules.reject(&:initial_rule?)
+      rules.each do |rule|
+        rhs = rule.rhs.empty? ? "%empty" : rule.rhs.map(&name).join(" ")
+        extended_precedence = EXTENDED_RULES[[rule.lhs.id.s_value, rule.rhs.map { |symbol| symbol.id.s_value }]]
+        precedence = if rule.precedence_sym
+          " %prec #{name.call(rule.precedence_sym)}"
+        elsif extended_precedence
+          " %prec #{extended_precedence}"
+        else
+          ""
+        end
+        key = [rule.lhs.id.s_value, rule.rhs.map { |symbol| symbol.id.s_value }]
+        action = profile.fetch("compatibility_actions", {})[key] || profile.fetch("actions")[rule.id]
+        expression = action&.last || "@builder.unsupported(#{rule.id})"
+        lines << "/* upstream parse.y:#{metadata.fetch(rule.id).fetch('line')}: #{rule.as_comment} */"
+        lines << "#{name.call(rule.lhs)}: #{rhs}#{precedence} { $$ = #{expression} };"
+      end
+      lines << "/* arpaka extension: block call as a parenthesized argument */"
+      lines << "call_args: block_call { $$ = [$1].freeze };"
+      lines << "call_args: args ',' block_call %prec tLOWEST { $$ = ($1 + [$3]).freeze };"
+      source = lines.join("\n") + "\n"
+      compact = rules.map do |rule|
+        { id: rule.id, rule: rule.as_comment,
+          line: metadata.fetch(rule.id).fetch("line"),
+          status: (profile.fetch("compatibility_actions", {})[[rule.lhs.id.s_value,
+              rule.rhs.map { |symbol| symbol.id.s_value }]] || profile.fetch("actions")[rule.id])&.first || "unsupported" }
+      end
+      { "parse.y" => source, "rules.json" => JSON.pretty_generate(compact) + "\n",
+        "runtime" => profile.fetch("runtime", {}),
+        "source_profile" => profile.fetch("source_tag", Arpaka::Ruby::Grammar::REVISION) }
+    end
+  end
+end

data/lib/arpaka/ruby/profile.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Arpaka
+  module Ruby
+    module Profile
+      CURRENT = {
+        "name" => "ruby-4.0",
+        "actions" => ::Arpaka::Ruby::Actions::ACTIONS,
+        # Rule numbers are stable only within one parse.y revision.  Keep
+        # this Ruby 4.0-specific reduction keyed by its grammar signature so
+        # the shared action table cannot accidentally apply the old action to
+        # a shifted rule number.
+        "compatibility_actions" => {
+          ["top_stmt", ["keyword_BEGIN", "begin_block"]] =>
+            ["ported", "@builder.begin_block($2)"],
+          ["stmt_or_begin", ["keyword_BEGIN", "$@5", "begin_block"]] =>
+            ["ported", "@builder.begin_block($3)"],
+          ["def_endless_method_endless_command", ["defn_head", "f_opt_paren_args", "'='", "endless_command"]] =>
+            ["ported", "@builder.def_node($1, $2, @builder.body_nodes($4))"],
+          ["def_endless_method_endless_command", ["defs_head", "f_opt_paren_args", "'='", "endless_command"]] =>
+            ["ported", "@builder.singleton_method_node($1[0], $1[2], $2, @builder.body_nodes($4))"],
+          ["def_endless_method_endless_arg", ["defn_head", "f_opt_paren_args", "'='", "endless_arg"]] =>
+            ["ported", "@builder.def_node($1, $2, @builder.body_nodes($4))"],
+          ["def_endless_method_endless_arg", ["defs_head", "f_opt_paren_args", "'='", "endless_arg"]] =>
+            ["ported", "@builder.singleton_method_node($1[0], $1[2], $2, @builder.body_nodes($4))"],
+          ["begin_block", ["block_open", "compstmt_top_stmts", "'}'"]] =>
+            ["pass_through", "$2"],
+          ["stmt", ["k_END", "block_open", "compstmt_stmts", "'}'"]] =>
+            ["ported", "@builder.end_block($3)"],
+          ["mlhs_basic", ["mlhs_head", "tSTAR", "mlhs_node", "','", "mlhs_items_mlhs_item"]] =>
+            ["ported", "@builder.multiple_assign_post($1, $3, $5)"],
+          ["mlhs_basic", ["mlhs_head", "tSTAR", "','", "mlhs_items_mlhs_item"]] =>
+            ["ported", "@builder.multiple_assign_post($1, :NODE_SPECIAL_NO_NAME_REST, $4)"],
+          ["mlhs_basic", ["tSTAR", "mlhs_node", "','", "mlhs_items_mlhs_item"]] =>
+            ["ported", "@builder.multiple_assign_post([], $2, $4)"],
+          ["mlhs_basic", ["tSTAR", "','", "mlhs_items_mlhs_item"]] =>
+            ["ported", "@builder.multiple_assign_post([], :NODE_SPECIAL_NO_NAME_REST, $3)"],
+          ["f_opt_primary_value", ["f_arg_asgn", "f_eq", "primary_value"]] =>
+            ["ported", "@builder.parameter(:optional, $1, $3)"],
+          ["f_opt_arg_primary_value", ["f_opt_arg_primary_value", "','", "f_opt_primary_value"]] =>
+            ["ported", "@builder.parameter_list($1, $3)"],
+          ["args-list_primary_value_opt_args_tail_block_args_tail_none",
+            ["f_arg", "','", "f_opt_arg_primary_value", "','", "f_rest_arg", "opt_args_tail_block_args_tail_none"]] =>
+            ["ported", "@builder.parameter_list(@builder.append_block_rest(@builder.parameter_list($1, $3), $5), $6)"],
+          ["args-list_primary_value_opt_args_tail_block_args_tail_none",
+            ["f_arg", "','", "f_opt_arg_primary_value", "','", "f_rest_arg", "','", "f_arg", "opt_args_tail_block_args_tail_none"]] =>
+            ["ported", "@builder.parameter_list(@builder.append_block_rest(@builder.parameter_list($1, $3), $5, $7), $8)"],
+          ["args-list_primary_value_opt_args_tail_block_args_tail_none",
+            ["f_arg", "','", "f_opt_arg_primary_value", "opt_args_tail_block_args_tail_none"]] =>
+            ["ported", "@builder.parameter_list($1, $3, $4)"],
+          ["args-list_primary_value_opt_args_tail_block_args_tail_none",
+            ["f_arg", "','", "f_opt_arg_primary_value", "','", "f_arg", "opt_args_tail_block_args_tail_none"]] =>
+            ["ported", "@builder.parameter_list($1, $3, $5, $6)"],
+          ["args-list_primary_value_opt_args_tail_block_args_tail_none",
+            ["f_arg", "','", "f_rest_arg", "opt_args_tail_block_args_tail_none"]] =>
+            ["ported", "@builder.parameter_list(@builder.append_block_rest($1, $3), $4)"],
+          ["args-list_primary_value_opt_args_tail_block_args_tail_none",
+            ["f_arg", "','", "f_rest_arg", "','", "f_arg", "opt_args_tail_block_args_tail_none"]] =>
+            ["ported", "@builder.parameter_list(@builder.append_block_rest($1, $3, $5), $6)"],
+          ["args-list_primary_value_opt_args_tail_block_args_tail_none",
+            ["f_opt_arg_primary_value", "','", "f_rest_arg", "opt_args_tail_block_args_tail_none"]] =>
+            ["ported", "@builder.parameter_list(@builder.append_block_rest([], $1), $3)"],
+          ["args-list_primary_value_opt_args_tail_block_args_tail_none",
+            ["f_opt_arg_primary_value", "','", "f_rest_arg", "','", "f_arg", "opt_args_tail_block_args_tail_none"]] =>
+            ["ported", "@builder.parameter_list(@builder.append_block_rest([], $1, $5), $6)"],
+          ["args-list_primary_value_opt_args_tail_block_args_tail_none",
+            ["f_opt_arg_primary_value", "opt_args_tail_block_args_tail_none"]] =>
+            ["ported", "@builder.parameter_list($1, $2)"],
+          ["args-list_primary_value_opt_args_tail_block_args_tail_none",
+            ["f_opt_arg_primary_value", "','", "f_arg", "opt_args_tail_block_args_tail_none"]] =>
+            ["ported", "@builder.parameter_list($1, $3, $4)"],
+          ["args-list_primary_value_opt_args_tail_block_args_tail_none",
+            ["f_rest_arg", "opt_args_tail_block_args_tail_none"]] =>
+            ["ported", "(@builder.append_block_rest([], $1) + Array($2)).freeze"],
+          ["args-list_primary_value_opt_args_tail_block_args_tail_none",
+            ["f_rest_arg", "','", "f_arg", "opt_args_tail_block_args_tail_none"]] =>
+            ["ported", "@builder.parameter_list(@builder.append_block_rest([], $1, $3), $4)"],
+          ["block_param", ["f_arg", "excessed_comma"]] =>
+            ["ported", "@builder.parameter_list($1)"],
+          ["block_param", ["f_arg", "opt_args_tail_block_args_tail_none"]] =>
+            ["ported", "@builder.parameter_list($1, $2)"],
+          ["block_param", ["tail-only-args_block_args_tail"]] =>
+            ["ported", "@builder.parameter_list($1)"],
+        }.freeze,
+        "additional_expected_conflicts" => 0,
+        "runtime" => {
+          "ast_nodes" => %w[self assignment singleton_method singleton_class pattern keyword_arguments].freeze,
+          "builder_methods" => %w[self assignment singleton_method singleton_class pattern keyword_arguments rescue].freeze,
+          "lexer" => { "source_text_tokens" => %w[tOP_ASGN tUMINUS tUPLUS].freeze }.freeze
+        }.freeze
+      }.freeze
+
+      def self.select(grammar)
+        if grammar.rules.any? { |rule| rule.lhs.id.s_value == "value_expr_command" }
+          CURRENT
+        elsif grammar.rules.any? { |rule| rule.lhs.id.s_value == "top_compstmt" &&
+          rule.rhs.any? { |symbol| symbol.id.s_value == "option_terms" } }
+          legacy
+        elsif grammar.rules.any? { |rule| rule.lhs.id.s_value == "top_compstmt" &&
+          rule.rhs.any? { |symbol| symbol.id.s_value == "opt_terms" } }
+          legacy_3_3
+        else
+          raise ::Arpaka::Error, "Unsupported Ruby parse.y profile"
+        end
+      end
+
+      def self.legacy
+        @legacy ||= load("profiles/ruby_3_4.rb", "ruby-3.4")
+      end
+
+      def self.legacy_3_3
+        @legacy_3_3 ||= load("profiles/ruby_3_3.rb", "ruby-3.3")
+      end
+
+      def self.load(filename, name)
+        box = ::Ruby::Box.new
+        profile = box.eval(File.read(File.join(__dir__, filename)))
+        unless profile.is_a?(Hash) && profile["name"] == name
+          raise ::Arpaka::Error, "Invalid #{name} profile"
+        end
+        profile.freeze
+      rescue SyntaxError, TypeError => error
+        raise ::Arpaka::Error, "Ruby profile loading failed: #{error.message}"
+      end
+    end
+  end
+end