Merge pull request #3042 from Shopify/support-forwarding-parameters

Support forwarding parameters in method types

Author: soutaro

config.yml

@@ -598,6 +598,9 @@ nodes:
       - name: rest_keywords
         c_type: rbs_node
         optional: true  # NULL when no double-splat (e.g., `() -> void` vs `(**String) -> void`)
+      - name: forwarding
+        c_type: rbs_node
+        optional: true  # NULL when no forwarding parameter (e.g., `() -> void` vs `(...) -> void`)
       - name: return_type
         c_type: rbs_node
   - name: RBS::Types::Function::Param
@@ -610,6 +613,8 @@ nodes:
         optional: true  # NULL when param is unnamed (e.g., `(String) -> void` vs `(String name) -> void`)
     locations:
       - optional: name
+  - name: RBS::Types::Function::ForwardingParam
+    rust_name: FunctionForwardingParamNode
   - name: RBS::Types::Interface
     rust_name: InterfaceTypeNode
     fields:

ext/rbs_extension/ast_translation.c

@@ -1636,6 +1636,7 @@ VALUE rbs_struct_to_ruby_value(rbs_translation_context_t ctx, rbs_node_t *instan
         VALUE arg_required_keywords = rbs_hash_to_ruby_hash(ctx, node->required_keywords);
         VALUE arg_optional_keywords = rbs_hash_to_ruby_hash(ctx, node->optional_keywords);
         VALUE arg_rest_keywords = rbs_struct_to_ruby_value(ctx, (rbs_node_t *) node->rest_keywords); // rbs_node
+        VALUE arg_forwarding = rbs_struct_to_ruby_value(ctx, (rbs_node_t *) node->forwarding);       // rbs_node
         VALUE arg_return_type = rbs_struct_to_ruby_value(ctx, (rbs_node_t *) node->return_type);     // rbs_node
 
         // Claim the shared kwargs hash, clear it, fill it, and hand it to `.new`.
@@ -1649,9 +1650,23 @@ VALUE rbs_struct_to_ruby_value(rbs_translation_context_t ctx, rbs_node_t *instan
         rb_hash_aset(h, ID2SYM(rb_intern("required_keywords")), arg_required_keywords);
         rb_hash_aset(h, ID2SYM(rb_intern("optional_keywords")), arg_optional_keywords);
         rb_hash_aset(h, ID2SYM(rb_intern("rest_keywords")), arg_rest_keywords);
+        rb_hash_aset(h, ID2SYM(rb_intern("forwarding")), arg_forwarding);
         rb_hash_aset(h, ID2SYM(rb_intern("return_type")), arg_return_type);
         return CLASS_NEW_INSTANCE(RBS_Types_Function, 1, &h);
     }
+    case RBS_TYPES_FUNCTION_FORWARDING_PARAM: {
+        rbs_types_function_forwarding_param_t *node = (rbs_types_function_forwarding_param_t *) instance;
+
+        // Compute child VALUEs into locals variables first, before any recursion into `rbs_struct_to_ruby_value()`.
+        VALUE arg_location = rbs_location_range_to_ruby_location(ctx, node->base.location);
+
+        // Claim the shared kwargs hash, clear it, fill it, and hand it to `.new`.
+        // Must not recurse between `rb_hash_clear()` and `CLASS_NEW_INSTANCE()`.
+        VALUE h = ctx.reusable_kwargs_hash;
+        rb_hash_clear(h);
+        rb_hash_aset(h, ID2SYM(rb_intern("location")), arg_location);
+        return CLASS_NEW_INSTANCE(RBS_Types_Function_ForwardingParam, 1, &h);
+    }
     case RBS_TYPES_FUNCTION_PARAM: {
         rbs_types_function_param_t *node = (rbs_types_function_param_t *) instance;
 

ext/rbs_extension/class_constants.c

@@ -79,6 +79,7 @@ VALUE RBS_Types_Block;
 VALUE RBS_Types_ClassInstance;
 VALUE RBS_Types_ClassSingleton;
 VALUE RBS_Types_Function;
+VALUE RBS_Types_Function_ForwardingParam;
 VALUE RBS_Types_Function_Param;
 VALUE RBS_Types_Interface;
 VALUE RBS_Types_Intersection;
@@ -173,6 +174,7 @@ void rbs__init_constants(void) {
     IMPORT_CONSTANT(RBS_Types_ClassInstance, RBS_Types, "ClassInstance");
     IMPORT_CONSTANT(RBS_Types_ClassSingleton, RBS_Types, "ClassSingleton");
     IMPORT_CONSTANT(RBS_Types_Function, RBS_Types, "Function");
+    IMPORT_CONSTANT(RBS_Types_Function_ForwardingParam, RBS_Types_Function, "ForwardingParam");
     IMPORT_CONSTANT(RBS_Types_Function_Param, RBS_Types_Function, "Param");
     IMPORT_CONSTANT(RBS_Types_Interface, RBS_Types, "Interface");
     IMPORT_CONSTANT(RBS_Types_Intersection, RBS_Types, "Intersection");

ext/rbs_extension/class_constants.h

@@ -87,6 +87,7 @@ extern VALUE RBS_Types_Block;
 extern VALUE RBS_Types_ClassInstance;
 extern VALUE RBS_Types_ClassSingleton;
 extern VALUE RBS_Types_Function;
+extern VALUE RBS_Types_Function_ForwardingParam;
 extern VALUE RBS_Types_Function_Param;
 extern VALUE RBS_Types_Interface;
 extern VALUE RBS_Types_Intersection;

include/rbs/ast.h

@@ -125,18 +125,19 @@ enum rbs_node_type {
     RBS_TYPES_CLASS_INSTANCE = 63,
     RBS_TYPES_CLASS_SINGLETON = 64,
     RBS_TYPES_FUNCTION = 65,
-    RBS_TYPES_FUNCTION_PARAM = 66,
-    RBS_TYPES_INTERFACE = 67,
-    RBS_TYPES_INTERSECTION = 68,
-    RBS_TYPES_LITERAL = 69,
-    RBS_TYPES_OPTIONAL = 70,
-    RBS_TYPES_PROC = 71,
-    RBS_TYPES_RECORD = 72,
-    RBS_TYPES_RECORD_FIELD_TYPE = 73,
-    RBS_TYPES_TUPLE = 74,
-    RBS_TYPES_UNION = 75,
-    RBS_TYPES_UNTYPED_FUNCTION = 76,
-    RBS_TYPES_VARIABLE = 77,
+    RBS_TYPES_FUNCTION_FORWARDING_PARAM = 66,
+    RBS_TYPES_FUNCTION_PARAM = 67,
+    RBS_TYPES_INTERFACE = 68,
+    RBS_TYPES_INTERSECTION = 69,
+    RBS_TYPES_LITERAL = 70,
+    RBS_TYPES_OPTIONAL = 71,
+    RBS_TYPES_PROC = 72,
+    RBS_TYPES_RECORD = 73,
+    RBS_TYPES_RECORD_FIELD_TYPE = 74,
+    RBS_TYPES_TUPLE = 75,
+    RBS_TYPES_UNION = 76,
+    RBS_TYPES_UNTYPED_FUNCTION = 77,
+    RBS_TYPES_VARIABLE = 78,
     RBS_AST_SYMBOL,
 };
 
@@ -854,9 +855,15 @@ typedef struct rbs_types_function {
     struct rbs_hash *RBS_NONNULL required_keywords;
     struct rbs_hash *RBS_NONNULL optional_keywords;
     struct rbs_node *RBS_NULLABLE rest_keywords;
+    struct rbs_node *RBS_NULLABLE forwarding;
     struct rbs_node *RBS_NONNULL return_type;
 } rbs_types_function_t;
 
+typedef struct rbs_types_function_forwarding_param {
+    rbs_node_t base;
+
+} rbs_types_function_forwarding_param_t;
+
 typedef struct rbs_types_function_param {
     rbs_node_t base;
 
@@ -1030,7 +1037,8 @@ rbs_types_bases_void_t *RBS_NONNULL rbs_types_bases_void_new(rbs_allocator_t *RB
 rbs_types_block_t *RBS_NONNULL rbs_types_block_new(rbs_allocator_t *RBS_NONNULL allocator, rbs_location_range location, rbs_node_t *RBS_NONNULL type, bool required, rbs_node_t *RBS_NULLABLE self_type);
 rbs_types_class_instance_t *RBS_NONNULL rbs_types_class_instance_new(rbs_allocator_t *RBS_NONNULL allocator, rbs_location_range location, rbs_type_name_t *RBS_NONNULL name, rbs_node_list_t *RBS_NONNULL args, rbs_location_range name_range);
 rbs_types_class_singleton_t *RBS_NONNULL rbs_types_class_singleton_new(rbs_allocator_t *RBS_NONNULL allocator, rbs_location_range location, rbs_type_name_t *RBS_NONNULL name, rbs_node_list_t *RBS_NONNULL args, rbs_location_range name_range);
-rbs_types_function_t *RBS_NONNULL rbs_types_function_new(rbs_allocator_t *RBS_NONNULL allocator, rbs_location_range location, rbs_node_list_t *RBS_NONNULL required_positionals, rbs_node_list_t *RBS_NONNULL optional_positionals, rbs_node_t *RBS_NULLABLE rest_positionals, rbs_node_list_t *RBS_NONNULL trailing_positionals, rbs_hash_t *RBS_NONNULL required_keywords, rbs_hash_t *RBS_NONNULL optional_keywords, rbs_node_t *RBS_NULLABLE rest_keywords, rbs_node_t *RBS_NONNULL return_type);
+rbs_types_function_t *RBS_NONNULL rbs_types_function_new(rbs_allocator_t *RBS_NONNULL allocator, rbs_location_range location, rbs_node_list_t *RBS_NONNULL required_positionals, rbs_node_list_t *RBS_NONNULL optional_positionals, rbs_node_t *RBS_NULLABLE rest_positionals, rbs_node_list_t *RBS_NONNULL trailing_positionals, rbs_hash_t *RBS_NONNULL required_keywords, rbs_hash_t *RBS_NONNULL optional_keywords, rbs_node_t *RBS_NULLABLE rest_keywords, rbs_node_t *RBS_NULLABLE forwarding, rbs_node_t *RBS_NONNULL return_type);
+rbs_types_function_forwarding_param_t *RBS_NONNULL rbs_types_function_forwarding_param_new(rbs_allocator_t *RBS_NONNULL allocator, rbs_location_range location);
 rbs_types_function_param_t *RBS_NONNULL rbs_types_function_param_new(rbs_allocator_t *RBS_NONNULL allocator, rbs_location_range location, rbs_node_t *RBS_NONNULL type, rbs_ast_symbol_t *RBS_NULLABLE name);
 rbs_types_interface_t *RBS_NONNULL rbs_types_interface_new(rbs_allocator_t *RBS_NONNULL allocator, rbs_location_range location, rbs_type_name_t *RBS_NONNULL name, rbs_node_list_t *RBS_NONNULL args, rbs_location_range name_range);
 rbs_types_intersection_t *RBS_NONNULL rbs_types_intersection_new(rbs_allocator_t *RBS_NONNULL allocator, rbs_location_range location, rbs_node_list_t *RBS_NONNULL types);

lib/rbs/types.rb

@@ -959,16 +959,44 @@ def to_s
         end
       end
 
+      class ForwardingParam
+        attr_reader :location
+
+        def initialize(location:)
+          @location = location
+        end
+
+        def ==(other)
+          other.is_a?(ForwardingParam)
+        end
+
+        alias eql? ==
+
+        def hash
+          self.class.hash
+        end
+
+        def to_json(state = nil)
+          json = {} #: Hash[Symbol, untyped]
+          json.to_json(state)
+        end
+
+        def to_s
+          "..."
+        end
+      end
+
       attr_reader :required_positionals
       attr_reader :optional_positionals
       attr_reader :rest_positionals
       attr_reader :trailing_positionals
       attr_reader :required_keywords
       attr_reader :optional_keywords
       attr_reader :rest_keywords
+      attr_reader :forwarding
       attr_reader :return_type
 
-      def initialize(required_positionals:, optional_positionals:, rest_positionals:, trailing_positionals:, required_keywords:, optional_keywords:, rest_keywords:, return_type:)
+      def initialize(required_positionals:, optional_positionals:, rest_positionals:, trailing_positionals:, required_keywords:, optional_keywords:, rest_keywords:, return_type:, forwarding: nil)
         @return_type = return_type
         @required_positionals = required_positionals
         @optional_positionals = optional_positionals
@@ -977,6 +1005,7 @@ def initialize(required_positionals:, optional_positionals:, rest_positionals:,
         @required_keywords = required_keywords
         @optional_keywords = optional_keywords
         @rest_keywords = rest_keywords
+        @forwarding = forwarding
       end
 
       def ==(other)
@@ -988,6 +1017,7 @@ def ==(other)
           other.required_keywords == required_keywords &&
           other.optional_keywords == optional_keywords &&
           other.rest_keywords == rest_keywords &&
+          other.forwarding == forwarding &&
           other.return_type == return_type
       end
 
@@ -1002,6 +1032,7 @@ def hash
           required_keywords.hash ^
           optional_keywords.hash ^
           rest_keywords.hash ^
+          forwarding.hash ^
           return_type.hash
       end
 
@@ -1043,6 +1074,7 @@ def map_type(&block)
             required_keywords: hmapv(required_keywords) {|param| param.map_type(&block) },
             optional_keywords: hmapv(optional_keywords) {|param| param.map_type(&block) },
             rest_keywords: rest_keywords&.yield_self {|param| param.map_type(&block) },
+            forwarding: forwarding,
             return_type: yield(return_type)
           )
         else
@@ -1110,6 +1142,7 @@ def to_json(state = nil)
           required_keywords: required_keywords,
           optional_keywords: optional_keywords,
           rest_keywords: rest_keywords,
+          forwarding: forwarding,
           return_type: return_type
         }.to_json(state)
       end
@@ -1129,6 +1162,7 @@ def self.empty(return_type)
           required_keywords: {},
           optional_keywords: {},
           rest_keywords: nil,
+          forwarding: nil,
           return_type: return_type
         )
       end
@@ -1142,12 +1176,13 @@ def with_return_type(type)
           required_keywords: required_keywords,
           optional_keywords: optional_keywords,
           rest_keywords: rest_keywords,
+          forwarding: forwarding,
           return_type: type
         )
       end
 
       def update(required_positionals: self.required_positionals, optional_positionals: self.optional_positionals, rest_positionals: self.rest_positionals, trailing_positionals: self.trailing_positionals,
-                 required_keywords: self.required_keywords, optional_keywords: self.optional_keywords, rest_keywords: self.rest_keywords, return_type: self.return_type)
+                 required_keywords: self.required_keywords, optional_keywords: self.optional_keywords, rest_keywords: self.rest_keywords, forwarding: self.forwarding, return_type: self.return_type)
         Function.new(
           required_positionals: required_positionals,
           optional_positionals: optional_positionals,
@@ -1156,6 +1191,7 @@ def update(required_positionals: self.required_positionals, optional_positionals
           required_keywords: required_keywords,
           optional_keywords: optional_keywords,
           rest_keywords: rest_keywords,
+          forwarding: forwarding,
           return_type: return_type
         )
       end
@@ -1167,6 +1203,7 @@ def empty?
           trailing_positionals.empty? &&
           required_keywords.empty? &&
           optional_keywords.empty? &&
+          !forwarding? &&
           !rest_keywords
       end
 
@@ -1175,6 +1212,7 @@ def param_to_s
         params = []
 
         params.push(*required_positionals.map(&:to_s))
+        params.push(forwarding.to_s) if forwarding
         params.push(*optional_positionals.map {|p| "?#{p}"})
         params.push("*#{rest_positionals}") if rest_positionals
         params.push(*trailing_positionals.map(&:to_s))
@@ -1185,6 +1223,10 @@ def param_to_s
         params.join(", ")
       end
 
+      def forwarding?
+        !forwarding.nil?
+      end
+
       def return_to_s
         return_type.to_s(1)
       end

lib/rbs/wasm/serialization_schema.rb

@@ -23,7 +23,7 @@ module WASM
     # :bool, :location_range, :location_range_list, :attr_ivar_name, or
     # [:enum, [value_or_nil, ...]].
     module SerializationSchema
-      SYMBOL_TAG = 78
+      SYMBOL_TAG = 79
 
       SCHEMA = [
         nil, # tag 0 is reserved for NULL
@@ -91,7 +91,8 @@ module SerializationSchema
         [:node, "RBS::Types::Block", true, nil, [[:type, :node], [:required, :bool], [:self_type, :node]], false],
         [:node, "RBS::Types::ClassInstance", true, [[:name, true], [:args, false]], [[:name, :node], [:args, :node_list]], false],
         [:node, "RBS::Types::ClassSingleton", true, [[:name, true], [:args, false]], [[:name, :node], [:args, :node_list]], false],
-        [:node, "RBS::Types::Function", false, nil, [[:required_positionals, :node_list], [:optional_positionals, :node_list], [:rest_positionals, :node], [:trailing_positionals, :node_list], [:required_keywords, :hash], [:optional_keywords, :hash], [:rest_keywords, :node], [:return_type, :node]], false],
+        [:node, "RBS::Types::Function", false, nil, [[:required_positionals, :node_list], [:optional_positionals, :node_list], [:rest_positionals, :node], [:trailing_positionals, :node_list], [:required_keywords, :hash], [:optional_keywords, :hash], [:rest_keywords, :node], [:forwarding, :node], [:return_type, :node]], false],
+        [:node, "RBS::Types::Function::ForwardingParam", true, nil, nil, false],
         [:node, "RBS::Types::Function::Param", true, [[:name, false]], [[:type, :node], [:name, :node]], false],
         [:node, "RBS::Types::Interface", true, [[:name, true], [:args, false]], [[:name, :node], [:args, :node_list]], false],
         [:node, "RBS::Types::Intersection", true, nil, [[:types, :node_list]], false],

schema/function.json

@@ -78,10 +78,21 @@
         }
       ]
     },
+    "forwarding": {
+      "title": "Forwarding parameter",
+      "oneOf": [
+        {
+          "type": "object"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
     "return_type": {
       "title": "Return type of a function",
       "$ref": "types.json"
     }
   },
-  "required": ["required_positionals", "optional_positionals", "rest_positionals", "trailing_positionals", "required_keywords", "optional_keywords", "rest_keywords", "return_type"]
+  "required": ["required_positionals", "optional_positionals", "rest_positionals", "trailing_positionals", "required_keywords", "optional_keywords", "rest_keywords", "forwarding", "return_type"]
 }

sig/types.rbs

@@ -385,13 +385,20 @@ module RBS
                     | -> Enumerator[t, Param]
       end
 
+      class ForwardingParam
+        attr_reader location: Location?
+
+        def initialize: (location: Location) -> void
+      end
+
       attr_reader required_positionals: Array[Param]
       attr_reader optional_positionals: Array[Param]
       attr_reader rest_positionals: Param?
       attr_reader trailing_positionals: Array[Param]
       attr_reader required_keywords: Hash[Symbol, Param]
       attr_reader optional_keywords: Hash[Symbol, Param]
       attr_reader rest_keywords: Param?
+      attr_reader forwarding: ForwardingParam?
       attr_reader return_type: t
 
       def initialize: (required_positionals: Array[Param],
@@ -401,7 +408,8 @@ module RBS
                        required_keywords: Hash[Symbol, Param],
                        optional_keywords: Hash[Symbol, Param],
                        rest_keywords: Param?,
-                       return_type: t) -> void
+                       return_type: t,
+                       ?forwarding: ForwardingParam?) -> void
 
       def free_variables: (?Set[Symbol]) -> Set[Symbol]
 
@@ -431,9 +439,11 @@ module RBS
                    ?required_keywords: Hash[Symbol, Param],
                    ?optional_keywords: Hash[Symbol, Param],
                    ?rest_keywords: Param?,
+                   ?forwarding: ForwardingParam?,
                    ?return_type: t) -> Function
 
       def empty?: () -> bool
+      def forwarding?: () -> bool
 
       def param_to_s: () -> String
       def return_to_s: () -> String