Support generic ActiveJob return types

Author: iamhaseebn

lib/tapioca/dsl/compilers/active_job.rb

@@ -47,7 +47,7 @@ def decorate
 
           root.create_path(constant) do |job|
             method = constant.instance_method(:perform)
-            constant_name = name_of(constant)
+            constant_name = generic_name_of(constant) #: as !nil
             parameters = compile_method_parameters_to_rbi(method)
             return_type = compile_method_return_type_to_rbi(method)
 
@@ -69,7 +69,27 @@ def decorate
 
         private
 
-        #: (Array[RBI::TypedParam] parameters, String? constant_name) -> Array[RBI::TypedParam]
+        # Resolves a constant name into a valid Sorbet type reference,
+        # applying `T.untyped` for any unfixed generic type variables.
+        #
+        # @example
+        #   generic_name_of(StandardJob) # => "StandardJob"
+        #   generic_name_of(GenericJob)  # => "GenericJob[T.untyped]"
+        #: (Module[top] constant) -> String?
+        def generic_name_of(constant)
+          type_name = name_of(constant)
+          return type_name if !type_name || type_name.end_with?("]")
+
+          type_variables = Runtime::GenericTypeRegistry.lookup_type_variables(constant)
+          return type_name unless type_variables
+
+          type_variables = type_variables.reject(&:fixed?)
+          return type_name if type_variables.empty?
+
+          "#{type_name}[#{type_variables.map { "T.untyped" }.join(", ")}]"
+        end
+
+        #: (Array[RBI::TypedParam] parameters, String constant_name) -> Array[RBI::TypedParam]
         def perform_later_parameters(parameters, constant_name)
           if ::Gem::Requirement.new(">= 7.0").satisfied_by?(::ActiveJob.gem_version)
             parameters.reject! { |typed_param| RBI::BlockParam === typed_param.param }

spec/tapioca/dsl/compilers/active_job_spec.rb

@@ -111,6 +111,69 @@ def perform_now(user_id); end
               assert_equal(expected, rbi_for(:NotifyJob))
             end
 
+            it "generates correct RBI file for a generic job" do
+              add_ruby_file("job.rb", <<~RUBY)
+                class GenericJob < ActiveJob::Base
+                  extend T::Sig
+                  extend T::Generic
+
+                  Elem = type_member
+
+                  sig { params(value: Elem).returns(Elem) }
+                  def perform(value)
+                    value
+                  end
+                end
+              RUBY
+
+              expected = template(<<~RBI)
+                # typed: strong
+
+                class GenericJob
+                  class << self
+                    sig { params(value: Elem, block: T.nilable(T.proc.params(job: GenericJob[T.untyped]).void)).returns(T.any(GenericJob[T.untyped], FalseClass)) }
+                    def perform_later(value, &block); end
+
+                    sig { params(value: Elem).returns(Elem) }
+                    def perform_now(value); end
+                  end
+                end
+              RBI
+              assert_equal(expected, rbi_for(:GenericJob))
+            end
+
+            it "generates correct RBI file for a job with multiple type members" do
+              add_ruby_file("job.rb", <<~RUBY)
+                class GenericJob < ActiveJob::Base
+                  extend T::Sig
+                  extend T::Generic
+
+                  Input = type_member
+                  Output = type_member
+
+                  sig { params(value: Input).returns(Output) }
+                  def perform(value)
+                    raise NotImplementedError
+                  end
+                end
+              RUBY
+
+              expected = template(<<~RBI)
+                # typed: strong
+
+                class GenericJob
+                  class << self
+                    sig { params(value: Input, block: T.nilable(T.proc.params(job: GenericJob[T.untyped, T.untyped]).void)).returns(T.any(GenericJob[T.untyped, T.untyped], FalseClass)) }
+                    def perform_later(value, &block); end
+
+                    sig { params(value: Input).returns(Output) }
+                    def perform_now(value); end
+                  end
+                end
+              RBI
+              assert_equal(expected, rbi_for(:GenericJob))
+            end
+
             it "generates correct RBI file for subclass with block argument" do
               add_ruby_file("job.rb", <<~RUBY)
                 class NotifyJob < ActiveJob::Base