Gate forwarding parameter syntax behind a parser option

`(...)` forwarding parameters (#3042) are syntax-only for now: nothing
defines their type checking semantics yet, and distributing signatures
that use them would break older parsers and tools that silently drop
the node.

Introduce `rbs_parser_options_t` and `rbs_parser_new_with_options()` so
the syntax must be opted into at the C API level. `rbs_parser_new()`
uses the zero-initialized options, which disable every optional syntax,
and the Ruby API doesn't expose the option, so `(...)` is a syntax
error everywhere in the gem. The AST, types, and serialization support
stays in place for when the semantics are settled.

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

Author: claude

include/rbs/parser.h

@@ -40,6 +40,21 @@ typedef struct rbs_error_t {
     bool syntax_error;
 } rbs_error_t;
 
+/**
+ * Options that control which syntax the parser accepts.
+ *
+ * Zero-initializing the struct gives the default configuration, where
+ * every optional syntax is disabled.
+ * */
+typedef struct {
+    /**
+     * Accept `(...)` forwarding parameters in method types.
+     *
+     * The syntax is experimental and disabled by default.
+     * */
+    bool enable_forwarding_params;
+} rbs_parser_options_t;
+
 /**
  * An RBS parser is a LL(3) parser.
  * */
@@ -57,6 +72,8 @@ typedef struct {
     rbs_constant_pool_t constant_pool;
     rbs_allocator_t *allocator;
     rbs_error_t *error;
+
+    rbs_parser_options_t options;
 } rbs_parser_t;
 
 /**
@@ -107,6 +124,16 @@ RBS_NODISCARD rbs_lexer_t *rbs_lexer_new(rbs_allocator_t *, rbs_string_t string,
  * Returns `NULL` for a `start_pos` that `rbs_lexer_new` rejects.
  * */
 RBS_NODISCARD rbs_parser_t *rbs_parser_new(rbs_string_t string, const rbs_encoding_t *encoding, int start_pos, int end_pos);
+
+/**
+ * Allocate new rbs_parser_t object with the given options.
+ *
+ * `rbs_parser_new` is equivalent to passing a zero-initialized
+ * `rbs_parser_options_t`, which disables every optional syntax.
+ *
+ * Returns `NULL` for a `start_pos` that `rbs_lexer_new` rejects.
+ * */
+RBS_NODISCARD rbs_parser_t *rbs_parser_new_with_options(rbs_string_t string, const rbs_encoding_t *encoding, int start_pos, int end_pos, rbs_parser_options_t options);
 void rbs_parser_free(rbs_parser_t *parser);
 
 /**

src/parser.c

@@ -556,6 +556,11 @@ static bool parse_params(rbs_parser_t *parser, method_params *params, bool forwa
                 return false;
             }
 
+            if (!parser->options.enable_forwarding_params) {
+                rbs_parser_set_error(parser, parser->next_token, true, "forwarding parameter syntax is not enabled");
+                return false;
+            }
+
             rbs_parser_advance(parser);
             params->forwarding = (rbs_node_t *) rbs_types_function_forwarding_param_new(
                 ALLOCATOR(),
@@ -3569,6 +3574,10 @@ rbs_lexer_t *rbs_lexer_new(rbs_allocator_t *allocator, rbs_string_t string, cons
 }
 
 rbs_parser_t *rbs_parser_new(rbs_string_t string, const rbs_encoding_t *encoding, int start_pos, int end_pos) {
+    return rbs_parser_new_with_options(string, encoding, start_pos, end_pos, (rbs_parser_options_t) { 0 });
+}
+
+rbs_parser_t *rbs_parser_new_with_options(rbs_string_t string, const rbs_encoding_t *encoding, int start_pos, int end_pos, rbs_parser_options_t options) {
     rbs_allocator_t *allocator = rbs_allocator_init();
 
     rbs_lexer_t *lexer = rbs_lexer_new(allocator, string, encoding, start_pos, end_pos);
@@ -3593,6 +3602,8 @@ rbs_parser_t *rbs_parser_new(rbs_string_t string, const rbs_encoding_t *encoding
         .constant_pool = { 0 },
         .allocator = allocator,
         .error = NULL,
+
+        .options = options,
     };
 
     // The parser's constant pool is mainly used for storing the names of type variables, which usually aren't many.

test/rbs/method_type_parsing_test.rb

@@ -48,34 +48,29 @@ def test_method_param
     end
   end
 
-  def test_forwarding_parameter
-    parse_method_type("(...) -> 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
+  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.
+    error = assert_raise(RBS::ParsingError) do
+      parse_method_type("(...) -> void")
     end
+    assert_include error.message, "forwarding parameter syntax is not enabled"
 
-    parse_method_type("(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
+    assert_raise(RBS::ParsingError) do
+      parse_method_type("(String message, ...) -> void")
     end
   end
 
-  def test_forwarding_parameter_with_overload_continuation
-    _, _, declarations = parse_signature(<<~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?
+  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_rejects_nonleading_parameters

test/rbs/schema_test.rb

@@ -121,8 +121,16 @@ 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
     JSONValidator.method_type.validate!(
-      parse_method_type("(String message, ...) -> void").to_json
+      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
+      ).to_json
     )
   end
 

test/rbs/wasm/serialization_test.rb

@@ -109,7 +109,6 @@ def test_method_type_round_trip
       "(Integer) -> String",
       "[T] (T) -> T",
       "(Integer, ?String, *Symbol, foo: bool, ?bar: Integer, **untyped) -> void",
-      "(String message, ...) -> void",
       "() { (Integer) -> void } -> bool",
       "() ?{ () -> void } -> void",
       "[A, B < Comparable[A]] (A) -> B",