Merge pull request #2550 from Shopify/jb-current-attributes-compiler

Include type_parameters declarations in signatures

Author: amomchilov

lib/tapioca/dsl/compiler.rb

@@ -139,11 +139,16 @@ def parameters_types_from_signature(method_def, signature)
 
       #: (RBI::Scope scope, (Method | UnboundMethod) method_def, ?class_method: bool) -> void
       def create_method_from_def(scope, method_def, class_method: false)
+        parameters = compile_method_parameters_to_rbi(method_def)
+        return_type = compile_method_return_type_to_rbi(method_def)
+        type_params = extract_type_parameters(parameters.map(&:type).push(return_type))
+
         scope.create_method(
           method_def.name.to_s,
-          parameters: compile_method_parameters_to_rbi(method_def),
-          return_type: compile_method_return_type_to_rbi(method_def),
+          parameters: parameters,
+          return_type: return_type,
           class_method: class_method,
+          type_params: type_params,
         )
       end
 

lib/tapioca/gem/listeners/sorbet_signatures.rb

@@ -8,8 +8,6 @@ class SorbetSignatures < Base
         include Runtime::Reflection
         include RBIHelper
 
-        TYPE_PARAMETER_MATCHER = /T\.type_parameter\(:?([[:word:]]+)\)/
-
         private
 
         # @override
@@ -42,9 +40,7 @@ def compile_signature(signature, parameters)
           sig.return_type = return_type
           @pipeline.push_symbol(return_type)
 
-          parameter_types.values.join(", ").scan(TYPE_PARAMETER_MATCHER).flatten.uniq.each do |k, _|
-            sig.type_params << k
-          end
+          sig.type_params.concat(extract_type_parameters(parameter_types.values.map(&:to_s).push(return_type)))
 
           case signature.mode
           when "abstract"

lib/tapioca/helpers/rbi_helper.rb

@@ -94,6 +94,13 @@ def as_non_nilable_type(type)
       end
     end
 
+    TYPE_PARAMETER_MATCHER = /T\.type_parameter\(:?([[:word:]]+)\)/
+
+    #: (Array[String] type_strings) -> Array[String]
+    def extract_type_parameters(type_strings)
+      type_strings.join(", ").scan(TYPE_PARAMETER_MATCHER).flatten.uniq
+    end
+
     #: (String name) -> bool
     def valid_method_name?(name)
       Prism.parse_success?("def self.#{name}(a); end")

lib/tapioca/rbi_ext/model.rb

@@ -65,10 +65,11 @@ def create_type_variable(name, type:, variance: :invariant, fixed: nil, upper: n
     #|   ?return_type: String?,
     #|   ?class_method: bool,
     #|   ?visibility: RBI::Visibility,
-    #|   ?comments: Array[RBI::Comment]
+    #|   ?comments: Array[RBI::Comment],
+    #|   ?type_params: Array[String]
     #| ) ?{ (RBI::Method node) -> void } -> void
     def create_method(name, parameters: [], return_type: nil, class_method: false, visibility: RBI::Public.new,
-      comments: [], &block)
+      comments: [], type_params: [], &block)
       return unless Tapioca::RBIHelper.valid_method_name?(name)
 
       sigs = []
@@ -77,7 +78,7 @@ def create_method(name, parameters: [], return_type: nil, class_method: false, v
         # If there is no block, and the params and return type have not been supplied, then
         # we create a single signature with the given parameters and return type
         params = parameters.map { |param| RBI::SigParam.new(param.param.name.to_s, param.type) }
-        sigs << RBI::Sig.new(params: params, return_type: return_type || "T.untyped")
+        sigs << RBI::Sig.new(params: params, return_type: return_type || "T.untyped", type_params: type_params)
       end
 
       method = RBI::Method.new(

spec/tapioca/dsl/compiler_spec.rb

@@ -92,6 +92,15 @@ def bar(a, b = 42, *c)
               def baz(d:, e: 42, **f, &blk)
               end
 
+              sig do
+                type_parameters(:U, :V)
+                  .params(a: T.type_parameter(:U), blk: T.proc.params(arg: T.type_parameter(:U)).returns(T.type_parameter(:V)))
+                  .returns(T.type_parameter(:V))
+              end
+              def complex_type_params(a, &blk)
+                blk.call(a)
+              end
+
               sig { type_parameters(:U).params(a: T.type_parameter(:U)).returns(T.type_parameter(:U)) }
               def foo(a)
                 a
@@ -120,7 +129,10 @@ def bar(a, b = T.unsafe(nil), *c); end
               sig { params(d: ::String, e: ::Integer, f: ::Integer, blk: T.proc.params(a: ::String).returns(::String)).returns(::Integer) }
               def baz(d:, e: T.unsafe(nil), **f, &blk); end
 
-              sig { params(a: T.type_parameter(:U)).returns(T.type_parameter(:U)) }
+              sig { type_parameters(:U, :V).params(a: T.type_parameter(:U), blk: T.proc.params(arg: T.type_parameter(:U)).returns(T.type_parameter(:V))).returns(T.type_parameter(:V)) }
+              def complex_type_params(a, &blk); end
+
+              sig { type_parameters(:U).params(a: T.type_parameter(:U)).returns(T.type_parameter(:U)) }
               def foo(a); end
 
               sig { params(a: ::Integer, b: ::Integer, c: ::Integer, d: ::Integer, e: ::Integer, f: ::Integer, blk: T.proc.void).void }

spec/tapioca/dsl/compilers/active_support_current_attributes_spec.rb

@@ -159,6 +159,11 @@ def user_id
                   def user_id=(value)
                     super
                   end
+
+                  sig { type_parameters(:T).params(t: T.untyped, blk: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+                  def with_type(t, &blk)
+                    blk.call
+                  end
                 end
               RUBY
 
@@ -174,6 +179,9 @@ def user_id; end
 
                     sig { params(value: T.nilable(::Integer)).void }
                     def user_id=(value); end
+
+                    sig { type_parameters(:T).params(t: T.untyped, blk: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+                    def with_type(t, &blk); end
                   end
 
                   module GeneratedAttributeMethods