Let the private parser entry points enable forwarding parameters

Gating `(...)` behind a C-level option left the enabled path with no
test coverage from Ruby, where the whole suite lives. Without it the
forwarding branch of `parse_params`, its AST translation, and its
serialization would be free to rot until the semantics are settled.

Thread the option through the private `_parse_method_type` and
`_parse_signature` entry points (and their `_to_bytes` variants), which
tests already call directly. The public `RBS::Parser` API keeps passing
`false`, so signatures written for the gem still can't use the syntax.

This also strengthens the restriction tests: they used to pass simply
because the gate rejected `(...)` outright, and now run with the option
enabled, so they check the grammar restrictions they name.

The WebAssembly parser has no way to enable the option, so its shim
raises `NotImplementedError` rather than quietly parsing without it.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015bgoC4byczqmYRzNrDkVrL

Author: claude

ext/rbs_extension/main.c

@@ -185,7 +185,16 @@ static rbs_lexer_t *alloc_lexer_from_buffer(rbs_allocator_t *allocator, VALUE st
     return lexer;
 }
 
-static rbs_parser_t *alloc_parser_from_buffer(VALUE buffer, int start_pos, int end_pos) {
+// Build the parser options from the arguments the `_parse_*` entry points
+// receive. The optional syntax these enable is not part of the public
+// `RBS::Parser` API, so only the private entry points pass them through.
+static rbs_parser_options_t parser_options(VALUE enable_forwarding_params) {
+    return (rbs_parser_options_t) {
+        .enable_forwarding_params = RB_TEST(enable_forwarding_params),
+    };
+}
+
+static rbs_parser_t *alloc_parser_from_buffer_with_options(VALUE buffer, int start_pos, int end_pos, rbs_parser_options_t options) {
     VALUE string = rb_funcall(buffer, rb_intern("content"), 0);
     StringValue(string);
 
@@ -194,11 +203,12 @@ static rbs_parser_t *alloc_parser_from_buffer(VALUE buffer, int start_pos, int e
     rb_encoding *encoding = rb_enc_get(string);
     const char *encoding_name = rb_enc_name(encoding);
 
-    rbs_parser_t *parser = rbs_parser_new(
+    rbs_parser_t *parser = rbs_parser_new_with_options(
         rbs_string_from_ruby_string(string),
         rbs_encoding_find((const uint8_t *) encoding_name, (const uint8_t *) (encoding_name + strlen(encoding_name))),
         start_pos,
-        end_pos
+        end_pos,
+        options
     );
 
     if (parser == NULL) {
@@ -208,6 +218,10 @@ static rbs_parser_t *alloc_parser_from_buffer(VALUE buffer, int start_pos, int e
     return parser;
 }
 
+static rbs_parser_t *alloc_parser_from_buffer(VALUE buffer, int start_pos, int end_pos) {
+    return alloc_parser_from_buffer_with_options(buffer, start_pos, end_pos, (rbs_parser_options_t) { 0 });
+}
+
 static VALUE rbsparser_parse_type(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos, VALUE variables, VALUE require_eof, VALUE void_allowed, VALUE self_allowed, VALUE classish_allowed) {
     VALUE string = rb_funcall(buffer, rb_intern("content"), 0);
     StringValue(string);
@@ -254,12 +268,12 @@ static VALUE parse_method_type_try(VALUE a) {
     return rbs_struct_to_ruby_value(ctx, (rbs_node_t *) method_type);
 }
 
-static VALUE rbsparser_parse_method_type(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos, VALUE variables, VALUE require_eof) {
+static VALUE rbsparser_parse_method_type(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos, VALUE variables, VALUE require_eof, VALUE enable_forwarding_params) {
     VALUE string = rb_funcall(buffer, rb_intern("content"), 0);
     StringValue(string);
     rb_encoding *encoding = rb_enc_get(string);
 
-    rbs_parser_t *parser = alloc_parser_from_buffer(buffer, FIX2INT(start_pos), FIX2INT(end_pos));
+    rbs_parser_t *parser = alloc_parser_from_buffer_with_options(buffer, FIX2INT(start_pos), FIX2INT(end_pos), parser_options(enable_forwarding_params));
     declare_type_variables(parser, variables, buffer);
     struct parse_method_type_arg arg = {
         .buffer = buffer,
@@ -293,12 +307,12 @@ static VALUE parse_signature_try(VALUE a) {
     return rbs_struct_to_ruby_value(ctx, (rbs_node_t *) signature);
 }
 
-static VALUE rbsparser_parse_signature(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos) {
+static VALUE rbsparser_parse_signature(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos, VALUE enable_forwarding_params) {
     VALUE string = rb_funcall(buffer, rb_intern("content"), 0);
     StringValue(string);
     rb_encoding *encoding = rb_enc_get(string);
 
-    rbs_parser_t *parser = alloc_parser_from_buffer(buffer, FIX2INT(start_pos), FIX2INT(end_pos));
+    rbs_parser_t *parser = alloc_parser_from_buffer_with_options(buffer, FIX2INT(start_pos), FIX2INT(end_pos), parser_options(enable_forwarding_params));
     struct parse_signature_arg arg = {
         .buffer = buffer,
         .encoding = encoding,
@@ -386,12 +400,12 @@ static VALUE parse_method_type_to_bytes_try(VALUE a) {
     return serialized_node_to_string(parser, (rbs_node_t *) method_type);
 }
 
-static VALUE rbsparser_parse_method_type_to_bytes(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos, VALUE variables, VALUE require_eof) {
+static VALUE rbsparser_parse_method_type_to_bytes(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos, VALUE variables, VALUE require_eof, VALUE enable_forwarding_params) {
     VALUE string = rb_funcall(buffer, rb_intern("content"), 0);
     StringValue(string);
     rb_encoding *encoding = rb_enc_get(string);
 
-    rbs_parser_t *parser = alloc_parser_from_buffer(buffer, FIX2INT(start_pos), FIX2INT(end_pos));
+    rbs_parser_t *parser = alloc_parser_from_buffer_with_options(buffer, FIX2INT(start_pos), FIX2INT(end_pos), parser_options(enable_forwarding_params));
     declare_type_variables(parser, variables, buffer);
     struct parse_method_type_arg arg = {
         .buffer = buffer,
@@ -419,12 +433,12 @@ static VALUE parse_signature_to_bytes_try(VALUE a) {
     return serialized_node_to_string(parser, (rbs_node_t *) signature);
 }
 
-static VALUE rbsparser_parse_signature_to_bytes(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos) {
+static VALUE rbsparser_parse_signature_to_bytes(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos, VALUE enable_forwarding_params) {
     VALUE string = rb_funcall(buffer, rb_intern("content"), 0);
     StringValue(string);
     rb_encoding *encoding = rb_enc_get(string);
 
-    rbs_parser_t *parser = alloc_parser_from_buffer(buffer, FIX2INT(start_pos), FIX2INT(end_pos));
+    rbs_parser_t *parser = alloc_parser_from_buffer_with_options(buffer, FIX2INT(start_pos), FIX2INT(end_pos), parser_options(enable_forwarding_params));
     struct parse_signature_arg arg = {
         .buffer = buffer,
         .encoding = encoding,
@@ -609,11 +623,11 @@ void rbs__init_parser(void) {
     rb_gc_register_mark_object(EMPTY_HASH);
 
     rb_define_singleton_method(RBS_Parser, "_parse_type", rbsparser_parse_type, 8);
-    rb_define_singleton_method(RBS_Parser, "_parse_method_type", rbsparser_parse_method_type, 5);
-    rb_define_singleton_method(RBS_Parser, "_parse_signature", rbsparser_parse_signature, 3);
+    rb_define_singleton_method(RBS_Parser, "_parse_method_type", rbsparser_parse_method_type, 6);
+    rb_define_singleton_method(RBS_Parser, "_parse_signature", rbsparser_parse_signature, 4);
     rb_define_singleton_method(RBS_Parser, "_parse_type_to_bytes", rbsparser_parse_type_to_bytes, 8);
-    rb_define_singleton_method(RBS_Parser, "_parse_method_type_to_bytes", rbsparser_parse_method_type_to_bytes, 5);
-    rb_define_singleton_method(RBS_Parser, "_parse_signature_to_bytes", rbsparser_parse_signature_to_bytes, 3);
+    rb_define_singleton_method(RBS_Parser, "_parse_method_type_to_bytes", rbsparser_parse_method_type_to_bytes, 6);
+    rb_define_singleton_method(RBS_Parser, "_parse_signature_to_bytes", rbsparser_parse_signature_to_bytes, 4);
     rb_define_singleton_method(RBS_Parser, "_parse_type_params", rbsparser_parse_type_params, 4);
     rb_define_singleton_method(RBS_Parser, "_parse_inline_leading_annotation", rbsparser_parse_inline_leading_annotation, 4);
     rb_define_singleton_method(RBS_Parser, "_parse_inline_trailing_annotation", rbsparser_parse_inline_trailing_annotation, 4);

lib/rbs/parser_aux.rb

@@ -14,7 +14,7 @@ def self.parse_type(source, range: nil, byte_range: 0..., variables: [], require
     def self.parse_method_type(source, range: nil, byte_range: 0..., variables: [], require_eof: false)
       buf = buffer(source)
       byte_range = byte_range(range, buf.content) if range
-      _parse_method_type(buf, byte_range.begin || 0, byte_range.end || buf.content.bytesize, variables, require_eof)
+      _parse_method_type(buf, byte_range.begin || 0, byte_range.end || buf.content.bytesize, variables, require_eof, false)
     end
 
     def self.parse_signature(source)
@@ -28,7 +28,7 @@ def self.parse_signature(source)
           0
         end
       content = buf.content
-      dirs, decls = _parse_signature(buf, start_pos, content.bytesize)
+      dirs, decls = _parse_signature(buf, start_pos, content.bytesize, false)
 
       if resolved
         dirs = dirs.dup if dirs.frozen?

lib/rbs/wasm/parser.rb

@@ -12,8 +12,9 @@ module RBS
   # RBS::Parser API on top, exactly as it does for the C extension.
   class Parser
     class << self
-      def _parse_signature(buffer, start_pos, end_pos)
+      def _parse_signature(buffer, start_pos, end_pos, enable_forwarding_params)
         validate_position_range(buffer, start_pos, end_pos)
+        validate_parser_options(enable_forwarding_params)
         encoding = buffer.content.encoding.name
         status, bytes = WASM::Runtime.instance.parse_signature(buffer.content, encoding, start_pos, end_pos)
         raise_parse_failure(buffer, status, bytes, start_pos, end_pos) unless status == WASM::Runtime::OK
@@ -31,9 +32,10 @@ def _parse_type(buffer, start_pos, end_pos, variables, require_eof, void_allowed
         deserialize_or_nil(bytes, buffer)
       end
 
-      def _parse_method_type(buffer, start_pos, end_pos, variables, require_eof)
+      def _parse_method_type(buffer, start_pos, end_pos, variables, require_eof, enable_forwarding_params)
         validate_position_range(buffer, start_pos, end_pos)
         validate_variables(variables)
+        validate_parser_options(enable_forwarding_params)
         encoding = buffer.content.encoding.name
         status, bytes = WASM::Runtime.instance.parse_method_type(buffer.content, encoding, start_pos, end_pos, variables, require_eof)
         raise_parse_failure(buffer, status, bytes, start_pos, end_pos) unless status == WASM::Runtime::OK
@@ -99,6 +101,15 @@ def validate_position_range(buffer, start_pos, end_pos)
         end
       end
 
+      # The WebAssembly entry points (rbs_wasm.c) build their parsers with the
+      # default options, so the optional syntax the C extension can enable is
+      # not reachable here. The public RBS::Parser API never enables it.
+      def validate_parser_options(enable_forwarding_params)
+        if enable_forwarding_params
+          raise NotImplementedError, "forwarding parameter syntax is not supported by the WebAssembly parser"
+        end
+      end
+
       # Reject anything that is not nil or an Array of Symbols, matching
       # declare_type_variables in the C extension (main.c).
       def validate_variables(variables)

sig/parser.rbs

@@ -136,19 +136,23 @@ module RBS
 
     def self._parse_type: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, bool require_eof, bool void_allowed, bool self_allowed, bool classish_allowed) -> Types::t?
 
-    def self._parse_method_type: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, bool require_eof) -> MethodType?
+    # The `enable_forwarding_params` argument enables `(...)` forwarding
+    # parameters, which are experimental and have no type checking semantics
+    # yet. It is deliberately not exposed through the public `parse_*` methods,
+    # so signatures written for the gem can't use the syntax.
+    def self._parse_method_type: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, bool require_eof, bool enable_forwarding_params) -> MethodType?
 
-    def self._parse_signature: (Buffer, Integer start_pos, Integer end_pos) -> [Array[AST::Directives::t], Array[AST::Declarations::t]]
+    def self._parse_signature: (Buffer, Integer start_pos, Integer end_pos, bool enable_forwarding_params) -> [Array[AST::Directives::t], Array[AST::Declarations::t]]
 
     # Parse and serialize the result to the binary format consumed by
     # RBS::WASM::Deserializer (see ext/rbs_extension/main.c and
     # docs/wasm_serialization.md). The `_to_bytes` variants exist so the
     # round-trip can be exercised on CRuby.
     def self._parse_type_to_bytes: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, bool require_eof, bool void_allowed, bool self_allowed, bool classish_allowed) -> String?
 
-    def self._parse_method_type_to_bytes: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, bool require_eof) -> String?
+    def self._parse_method_type_to_bytes: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, bool require_eof, bool enable_forwarding_params) -> String?
 
-    def self._parse_signature_to_bytes: (Buffer, Integer start_pos, Integer end_pos) -> String
+    def self._parse_signature_to_bytes: (Buffer, Integer start_pos, Integer end_pos, bool enable_forwarding_params) -> String
 
     def self._parse_type_params: (Buffer, Integer start_pos, Integer end_pos, bool module_type_params) -> Array[AST::TypeParam]
 

test/rbs/method_type_parsing_test.rb

@@ -23,6 +23,19 @@ def parse_signature(string)
     RBS::Parser.parse_signature(buffer)
   end
 
+  # `(...)` forwarding parameters are gated behind a parser option that the
+  # public API deliberately doesn't expose, so the tests below reach for the
+  # private entry points to exercise the syntax itself.
+  def parse_method_type_with_forwarding(string)
+    buffer = Buffer.new(content: string.encode(Encoding::UTF_8), name: "sample.rbs")
+    RBS::Parser._parse_method_type(buffer, 0, buffer.content.bytesize, nil, true, true)
+  end
+
+  def parse_signature_with_forwarding(string)
+    buffer = Buffer.new(content: string.encode(Encoding::UTF_8), name: "sample.rbs")
+    RBS::Parser._parse_signature(buffer, 0, buffer.content.bytesize, true)
+  end
+
   def test_method_type
     Parser.parse_method_type("()->void").yield_self do |type|
       assert_equal "() -> void", type.to_s
@@ -48,10 +61,9 @@ def test_method_param
     end
   end
 
-  def test_forwarding_parameter_syntax_is_not_enabled
-    # `(...)` forwarding parameters are gated behind a C-level parser option
-    # (`rbs_parser_options_t`) that the Ruby API doesn't expose, so parsing
-    # them from Ruby is always an error.
+  def test_forwarding_parameter_syntax_is_not_enabled_by_default
+    # The syntax has no type checking semantics yet, so the public API never
+    # enables it. Signatures shipped in the wild can't use it.
     error = assert_raise(RBS::ParsingError) do
       parse_method_type("(...) -> void")
     end
@@ -60,19 +72,46 @@ def test_forwarding_parameter_syntax_is_not_enabled
     assert_raise(RBS::ParsingError) do
       parse_method_type("(String message, ...) -> void")
     end
-  end
 
-  def test_forwarding_parameter_syntax_is_not_enabled_in_signature
     assert_raise(RBS::ParsingError) do
       parse_signature(<<~RBS)
         class Foo
           def foo: (...) -> void
-                 | ...
         end
       RBS
     end
   end
 
+  def test_forwarding_parameter
+    parse_method_type_with_forwarding("(...) -> void").tap do |type|
+      assert_equal "(...) -> void", type.to_s
+      assert_instance_of Types::Function::ForwardingParam, type.type.forwarding
+      assert_equal "...", type.type.forwarding.location.source
+      assert_empty type.type.required_positionals
+      assert_nil type.block
+    end
+
+    parse_method_type_with_forwarding("(String message, ...) -> void").tap do |type|
+      assert_equal "(String message, ...) -> void", type.to_s
+      assert_equal 1, type.type.required_positionals.size
+      assert_predicate type.type, :forwarding?
+      assert_instance_of Types::Function::ForwardingParam, type.type.forwarding
+    end
+  end
+
+  def test_forwarding_parameter_with_overload_continuation
+    _, declarations = parse_signature_with_forwarding(<<~RBS)
+      class Foo
+        def foo: (...) -> void
+               | ...
+      end
+    RBS
+
+    method = declarations.fetch(0).members.fetch(0)
+    assert_predicate method, :overloading?
+    assert_predicate method.overloads.fetch(0).method_type.type, :forwarding?
+  end
+
   def test_forwarding_parameter_rejects_nonleading_parameters
     [
       "(?String value, ...) -> void",
@@ -82,7 +121,7 @@ def test_forwarding_parameter_rejects_nonleading_parameters
       "(**String values, ...) -> void",
     ].each do |source|
       assert_raise(RBS::ParsingError) do
-        parse_method_type(source)
+        parse_method_type_with_forwarding(source)
       end
     end
   end
@@ -94,7 +133,7 @@ def test_forwarding_parameter_must_be_last
       "(...,) -> void",
     ].each do |source|
       assert_raise(RBS::ParsingError) do
-        parse_method_type(source)
+        parse_method_type_with_forwarding(source)
       end
     end
   end
@@ -105,25 +144,29 @@ def test_forwarding_parameter_cannot_have_explicit_block
       "(...) ?{ () -> void } -> void",
     ].each do |source|
       assert_raise(RBS::ParsingError) do
-        parse_method_type(source)
+        parse_method_type_with_forwarding(source)
       end
     end
   end
 
   def test_forwarding_parameter_is_not_allowed_in_block_types
-    assert_raise(RBS::ParsingError) do
-      parse_method_type("() { (...) -> void } -> void")
+    error = assert_raise(RBS::ParsingError) do
+      parse_method_type_with_forwarding("() { (...) -> void } -> void")
     end
+    assert_include error.message, "forwarding parameter is not allowed in this context"
   end
 
   def test_forwarding_parameter_is_not_allowed_in_proc_types
+    # Proc types are parsed by `_parse_type`, which has no way to enable the
+    # syntax, but the context restriction is checked before the option anyway.
     [
       "^(...) -> void",
       "^(String, ...) -> void",
     ].each do |source|
-      assert_raise(RBS::ParsingError) do
+      error = assert_raise(RBS::ParsingError) do
         parse_type(source)
       end
+      assert_include error.message, "forwarding parameter is not allowed in this context"
     end
   end
 

test/rbs/parser_test.rb

@@ -1033,7 +1033,7 @@ class Foo[T < Integer] < Bar # Comment
   def test_invalid_position_range_raises
     # Regression: start_pos > end_pos used to cause an infinite loop in the lexer.
     assert_raises(ArgumentError) do
-      RBS::Parser._parse_signature(buffer(""), 1, 0)
+      RBS::Parser._parse_signature(buffer(""), 1, 0, false)
     end
   end
 
@@ -1051,7 +1051,7 @@ def test_invalid_utf8_byte_in_comment_does_not_hang
     # Regression: invalid UTF-8 byte in a comment used to loop forever in the lexer.
     source = "# \xC2".dup.force_encoding(Encoding::UTF_8)
     assert_raises(RBS::ParsingError) do
-      RBS::Parser._parse_signature(buffer(source), 0, source.bytesize)
+      RBS::Parser._parse_signature(buffer(source), 0, source.bytesize, false)
     end
   end
 
@@ -1061,7 +1061,7 @@ def test_invalid_utf8_byte_at_top_level_raises
     # Regression: invalid UTF-8 byte at top level used to trip RBS_ASSERT in the C extension.
     source = "\xFF".dup.force_encoding(Encoding::UTF_8)
     assert_raises(RBS::ParsingError) do
-      RBS::Parser._parse_signature(buffer(source), 0, source.bytesize)
+      RBS::Parser._parse_signature(buffer(source), 0, source.bytesize, false)
     end
   end
 
@@ -1183,7 +1183,7 @@ def test_utf8_replacement_character_in_comment_parses
     # ("\xEF\xBF\xBD") that decodes to the multibyte dummy code point, not the
     # sentinel that marks an invalid byte. A comment containing it must parse fine.
     source = "# \u{FFFD}\ntype x = untyped\n".dup.force_encoding(Encoding::UTF_8)
-    _, decls = RBS::Parser._parse_signature(buffer(source), 0, source.bytesize)
+    _, decls = RBS::Parser._parse_signature(buffer(source), 0, source.bytesize, false)
     assert_equal 1, decls.size
     assert_instance_of RBS::AST::Declarations::TypeAlias, decls[0]
   end

test/rbs/schema_test.rb

@@ -121,15 +121,11 @@ def test_method_type_schema
       parse_method_type("[G] (A a, ?B, *C, d: D, ?e: E e, **f) ?{ (G) -> void } -> String").to_json
     )
 
-    # Forwarding parameters can't be parsed from Ruby, so build the node directly
+    # Forwarding parameters are only parsed when explicitly enabled
+    source = "(String message, ...) -> void"
     JSONValidator.method_type.validate!(
-      RBS::MethodType.new(
-        type_params: [],
-        type: RBS::Types::Function.empty(RBS::Types::Bases::Void.new(location: nil)).update(
-          forwarding: RBS::Types::Function::ForwardingParam.new(location: nil)
-        ),
-        block: nil,
-        location: nil
+      RBS::Parser._parse_method_type(
+        RBS::Buffer.new(content: source, name: "test.rbs"), 0, source.bytesize, nil, true, true
       ).to_json
     )
   end