Refine generic ActiveJob type naming

Author: iamhaseebn

lib/tapioca/dsl/compilers/active_job.rb

@@ -47,15 +47,14 @@ def decorate
 
           root.create_path(constant) do |job|
             method = constant.instance_method(:perform)
-            constant_name = T.must(name_of(constant))
-            job_type = generic_job_type(constant_name)
+            constant_name = generic_name_of(constant) #: as !nil
             parameters = compile_method_parameters_to_rbi(method)
             return_type = compile_method_return_type_to_rbi(method)
 
             job.create_method(
               "perform_later",
-              parameters: perform_later_parameters(parameters, job_type),
-              return_type: "T.any(#{job_type}, FalseClass)",
+              parameters: perform_later_parameters(parameters, constant_name),
+              return_type: "T.any(#{constant_name}, FalseClass)",
               class_method: true,
             )
 
@@ -70,32 +69,27 @@ def decorate
 
         private
 
-        # Resolves the constant name into a valid Sorbet type reference,
-        # applying `T.untyped` for any unfixed generic type variables.
-        #
-        # @example
-        #   generic_job_type("StandardJob") # => "StandardJob"
-        #   generic_job_type("GenericJob")  # => "GenericJob[T.untyped]"
-        #: (String constant_name) -> String
-        def generic_job_type(constant_name)
-          return constant_name unless T::Generic === constant
+        #: (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 constant_name unless type_variables
+          return type_name unless type_variables
 
-          type_arguments = type_variables.reject(&:fixed?).map { "T.untyped" }
-          return constant_name if type_arguments.empty?
+          type_variables = type_variables.reject(&:fixed?)
+          return type_name if type_variables.empty?
 
-          "#{constant_name}[#{type_arguments.join(", ")}]"
+          "#{type_name}[#{type_variables.map { "T.untyped" }.join(", ")}]"
         end
 
-        #: (Array[RBI::TypedParam] parameters, String job_type) -> Array[RBI::TypedParam]
-        def perform_later_parameters(parameters, job_type)
+        #: (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 }
             parameters + [create_block_param(
               "block",
-              type: "T.nilable(T.proc.params(job: #{job_type}).void)",
+              type: "T.nilable(T.proc.params(job: #{constant_name}).void)",
             )]
           else
             parameters