arpaka 1.0.0 → 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,14 +3,10 @@
 require "lrama"
 require "json"
 require "digest"
-require_relative "actions"
-require_relative "profile/ruby"
+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
@@ -109,57 +105,10 @@ module Arpaka::RubyGrammar
       load_parse_y(parse_y)
     end
     names = symbol_names(grammar)
-    name = ->(symbol) { symbol.term ? symbol.id.s_value : names.fetch(symbol.id.s_value) }
-    profile = ::Arpaka::Profile::RUBY.select(grammar)
-    expected_conflicts = (grammar.expect || 0) + profile.fetch("additional_expected_conflicts", 0)
-    lines = ["/* Generated from ruby/ruby #{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("actions")[rule.id] || profile.fetch("compatibility_actions", {})[key]
-      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"
+    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: (profile.fetch("actions")[rule.id] ||
-          profile.fetch("compatibility_actions", {})[[rule.lhs.id.s_value,
-            rule.rhs.map { |symbol| symbol.id.s_value }]])&.first || "unsupported" }
-    end
-    { "parse.y" => source, "rules.json" => JSON.pretty_generate(compact) + "\n",
-      "runtime" => profile.fetch("runtime", {}),
-      "source_profile" => profile.fetch("source_tag", REVISION) }
+    artifacts
   end
 
   def self.verify_structure(original, source, names)

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

data/lib/arpaka/{profile → ruby/profiles}/ruby_3_3.rb

@@ -7,9 +7,9 @@
  "source_revision" => "343ea050023cfc0374fdea6fdf625b2f57b716a4",
  "source_sha256" => "0347b145280f89b0052aaaa506aa2022c9abdfa2c37677203d53a1a2b3e35861",
  "runtime" => {
-   "ast_nodes" => %w[assignment singleton_method singleton_class pattern].freeze,
-   "builder_methods" => %w[assignment singleton_method singleton_class rescue].freeze,
-   "lexer" => {"source_text_tokens" => ["tOP_ASGN"].freeze}.freeze
+   "ast_nodes" => %w[assignment singleton_method singleton_class pattern keyword_arguments].freeze,
+   "builder_methods" => %w[assignment singleton_method singleton_class rescue keyword_arguments].freeze,
+  "lexer" => {"source_text_tokens" => %w[tOP_ASGN tUMINUS tUPLUS].freeze}.freeze
  }.freeze,
  "actions" => {
   1 => ["ported", "nil"],
@@ -37,15 +37,15 @@
   23 => ["ported", "nil"],
   24 => ["ported", "$1"],
   25 => ["ported", "nil"],
-  26 => ["ported", "@builder.alias_node($2, $4)"],
-  27 => ["ported", "@builder.alias_node($2, $3)"],
-  28 => ["ported", "@builder.alias_node($2, $3)"],
-  29 => ["unsupported", "@builder.unsupported(31)"],
+  26 => ["ported", "@builder.alias_node(:method, $2, $4)"],
+  27 => ["ported", "@builder.alias_node(:variable, $2, $3)"],
+  28 => ["ported", "@builder.alias_node(:variable, $2, $3)"],
+  29 => ["unsupported", "@builder.unsupported(29)"],
   30 => ["ported", "@builder.undef_node($2)"],
-  31 => ["ported", "@builder.if_node($3, [$1], nil)"],
-  32 => ["ported", "@builder.unless_node($3, [$1], nil)"],
-  33 => ["ported", "@builder.loop(:while, $3, [$1])"],
-  34 => ["ported", "@builder.loop(:until, $3, [$1])"],
+  31 => ["ported", "@builder.modifier_if_node($3, [$1])"],
+  32 => ["ported", "@builder.modifier_unless_node($3, [$1])"],
+  33 => ["ported", "@builder.modifier_loop(:while, $3, [$1])"],
+  34 => ["ported", "@builder.modifier_loop(:until, $3, [$1])"],
   35 => ["ported", "@builder.rescue_modifier($1, $4)"],
   36 => ["ported", "@builder.end_block($4)"],
   37 => ["ported", "$1"],
@@ -64,7 +64,7 @@
   50 => ["ported", "@builder.opassign(@builder.field($1, $2, $3), $4, $6)"],
   51 => ["ported", "@builder.def_node($1, $2, $4)"],
   52 => ["ported", "@builder.singleton_method_node($1[0], $1[2], $2, $4)"],
-  53 => ["unsupported", "@builder.unsupported(56)"],
+  53 => ["unsupported", "@builder.unsupported(53)"],
   54 => ["ported", "$1"],
   55 => ["ported", "@builder.rescue_modifier($1, $4)"],
   56 => ["ported", "@builder.unary(\":!\", $3)"],
@@ -103,7 +103,7 @@
   89 => ["ported", "@builder.receiver_call($1, :\"::\", $3, $4)"],
   90 => ["ported", "@builder.block_call(@builder.receiver_call($1, :\"::\", $3, $4), $5)"],
   91 => ["ported", "@builder.block_call(@builder.receiver_call($1, :\"::\", $3, []), $5)"],
-  92 => ["ported", "@builder.call(:super, $2 || [])"],
+  92 => ["ported", "@builder.super_call($2 || [])"],
   93 => ["ported", "@builder.call(:yield, $2 || [])"],
   94 => ["ported", "@builder.call(:return, $2 || [])"],
   95 => ["ported", "@builder.call(:break, $2 || [])"],
@@ -186,8 +186,8 @@
   172 => ["ported", "@builder.operator(\"**\")"],
   173 => ["ported", "@builder.operator(\"!\")"],
   174 => ["ported", "@builder.operator(\"~\")"],
-  175 => ["ported", "@builder.operator(\"+@\")"],
-  176 => ["ported", "@builder.operator(\"-@\")"],
+  175 => ["ported", "@builder.operator($1 || \"+@\")"],
+  176 => ["ported", "@builder.operator($1 || \"-@\")"],
   177 => ["ported", "@builder.operator(\"[]\")"],
   178 => ["ported", "@builder.operator(\"[]=\")"],
   179 => ["ported", "@builder.operator(\"`\")"],
@@ -240,7 +240,7 @@
   226 => ["ported", "@builder.opassign(@builder.field($1, $2, $3), $4, $6)"],
   227 => ["ported", "@builder.opassign(@builder.field($1, :\"::\", $3), $4, $6)"],
   228 => ["ported", "@builder.opassign(@builder.field(nil, :\"::\", $2), $3, $5)"],
-  229 => ["unsupported", "@builder.unsupported(234)"],
+  229 => ["unsupported", "@builder.unsupported(229)"],
   230 => ["ported", "@builder.range(:\"..\", $1, $3)"],
   231 => ["ported", "@builder.range(:\"...\", $1, $3)"],
   232 => ["ported", "@builder.range(:\"..\", $1, nil)"],
@@ -484,8 +484,8 @@
   470 => ["ported", "@builder.receiver_call($1, :\"::\", $3, [])"],
   471 => ["ported", "$1"],
   472 => ["ported", "$1"],
-  473 => ["ported", "@builder.call(:super, $2 || [])"],
-  474 => ["ported", "@builder.call(:super, [])"],
+    473 => ["ported", "@builder.super_call($2 || [])"],
+    474 => ["ported", "@builder.super_call(nil)"],
   475 => ["ported", "@builder.index($1, $3 || [])"],
   476 => ["ported", "$2"],
   477 => ["ported", "$2"],
@@ -508,8 +508,8 @@
   494 => ["ported", "$1"],
   495 => ["ported", "$1"],
   496 => ["ported", "$1"],
-  497 => ["ported", "@builder.if_node($3, [$1], nil)"],
-  498 => ["ported", "@builder.unless_node($3, [$1], nil)"],
+  497 => ["ported", "@builder.modifier_if_node($3, [$1])"],
+  498 => ["ported", "@builder.modifier_unless_node($3, [$1])"],
   499 => ["ported", "$1"],
   500 => ["ported", "@builder.pattern(:array, [nil, [$1], nil, nil])"],
   501 => ["ported", "@builder.pattern(:array, [[$1] + Array($3[0]), $3[1], $3[2]])"],
@@ -615,7 +615,7 @@
   601 => ["ported", "@builder.concat_strings($1, $2)"],
   602 => ["ported", "@builder.string(@builder.join_strings($2))"],
   603 => ["ported", "@builder.xstring(@builder.join_strings($2))"],
-  604 => ["ported", "@builder.regexp(@builder.join_strings($2))"],
+  604 => ["ported", "@builder.regexp(@builder.join_strings($2), $3)"],
   605 => ["ported", "$1"],
   606 => ["ported", "$1"],
   607 => ["ported", "@builder.word_array($3 || [])"],