tapioca 0.19.0 → 0.19.1

data/lib/tapioca/dsl/compilers/url_helpers.rb

@@ -78,7 +78,7 @@ module Tapioca
       #   include GeneratedUrlHelpersModule
       # end
       # ~~~
-      #: [ConstantType = T::Module[top]]
+      #: [ConstantType = Module[top]]
       class UrlHelpers < Compiler
         # @override
         #: -> void
@@ -96,7 +96,7 @@ module Tapioca
 
         class << self
           # @override
-          #: -> Enumerable[T::Module[top]]
+          #: -> Enumerable[Module[top]]
           def gather_constants
             return [] unless defined?(Rails.application) && Rails.application
 
@@ -128,7 +128,7 @@ module Tapioca
             constants.concat(NON_DISCOVERABLE_INCLUDERS).push(GeneratedUrlHelpersModule, GeneratedPathHelpersModule)
           end
 
-          #: -> Array[T::Module[top]]
+          #: -> Array[Module[top]]
           def gather_non_discoverable_includers
             [].tap do |includers|
               if defined?(ActionController::TemplateAssertions) && defined?(ActionDispatch::IntegrationTest)
@@ -143,7 +143,7 @@ module Tapioca
 
           # Returns `true` if `mod` "directly" includes `helper`.
           # For classes, this method will return false if the `helper` is included only by a superclass
-          #: (T::Module[top] mod, T::Module[top] helper) -> bool
+          #: (Module[top] mod, Module[top] helper) -> bool
           private def includes_helper?(mod, helper)
             ancestors = ancestors_of(mod)
 
@@ -158,11 +158,11 @@ module Tapioca
           end
         end
 
-        NON_DISCOVERABLE_INCLUDERS = gather_non_discoverable_includers #: Array[T::Module[top]]
+        NON_DISCOVERABLE_INCLUDERS = gather_non_discoverable_includers #: Array[Module[top]]
 
         private
 
-        #: (RBI::Tree root, T::Module[top] constant) -> void
+        #: (RBI::Tree root, Module[top] constant) -> void
         def generate_module_for(root, constant)
           root.create_module(T.must(constant.name)) do |mod|
             mod.create_include("::ActionDispatch::Routing::UrlFor")
@@ -178,7 +178,7 @@ module Tapioca
           end
         end
 
-        #: (RBI::Scope mod, T::Module[top] helper_module) -> void
+        #: (RBI::Scope mod, Module[top] helper_module) -> void
         def create_mixins_for(mod, helper_module)
           include_helper = constant.ancestors.include?(helper_module) || NON_DISCOVERABLE_INCLUDERS.include?(constant)
           extend_helper = constant.singleton_class.ancestors.include?(helper_module)

data/lib/tapioca/dsl/helpers/graphql_type_helper.rb

@@ -110,7 +110,7 @@ module Tapioca
 
         private
 
-        #: (T::Module[top] constant) -> String
+        #: (Module[top] constant) -> String
         def type_for_constant(constant)
           if constant.instance_methods.include?(:prepare)
             prepare_method = constant.instance_method(:prepare)

data/lib/tapioca/dsl/pipeline.rb

@@ -7,13 +7,13 @@ module Tapioca
       #: Enumerable[singleton(Compiler)]
       attr_reader :active_compilers
 
-      #: Array[T::Module[top]]
+      #: Array[Module[top]]
       attr_reader :requested_constants
 
       #: Array[Pathname]
       attr_reader :requested_paths
 
-      #: Array[T::Module[top]]
+      #: Array[Module[top]]
       attr_reader :skipped_constants
 
       #: ^(String error) -> void
@@ -23,12 +23,12 @@ module Tapioca
       attr_reader :errors
 
       #: (
-      #|   requested_constants: Array[T::Module[top]],
+      #|   requested_constants: Array[Module[top]],
       #|   ?requested_paths: Array[Pathname],
       #|   ?requested_compilers: Array[singleton(Compiler)],
       #|   ?excluded_compilers: Array[singleton(Compiler)],
       #|   ?error_handler: ^(String error) -> void,
-      #|   ?skipped_constants: Array[T::Module[top]],
+      #|   ?skipped_constants: Array[Module[top]],
       #|   ?number_of_workers: Integer?,
       #|   ?compiler_options: Hash[String, untyped],
       #|   ?lsp_addon: bool
@@ -56,7 +56,7 @@ module Tapioca
         @errors = [] #: Array[String]
       end
 
-      #: [R] { (T::Module[top] constant, RBI::File rbi) -> R } -> Array[R]
+      #: [R] { (Module[top] constant, RBI::File rbi) -> R } -> Array[R]
       def run(&blk)
         constants_to_process = gather_constants(requested_constants, requested_paths, skipped_constants)
           .select { |c| Module === c } # Filter value constants out
@@ -128,10 +128,10 @@ module Tapioca
       end
 
       #: (
-      #|   Array[T::Module[top]] requested_constants,
+      #|   Array[Module[top]] requested_constants,
       #|   Array[Pathname] requested_paths,
-      #|   Array[T::Module[top]] skipped_constants
-      #| ) -> Set[T::Module[top]]
+      #|   Array[Module[top]] skipped_constants
+      #| ) -> Set[Module[top]]
       def gather_constants(requested_constants, requested_paths, skipped_constants)
         Compiler.requested_constants = requested_constants
         constants = Set.new.compare_by_identity
@@ -153,7 +153,7 @@ module Tapioca
         constants
       end
 
-      #: (Set[T::Module[top]] constants) -> Set[T::Module[top]]
+      #: (Set[Module[top]] constants) -> Set[Module[top]]
       def filter_anonymous_and_reloaded_constants(constants)
         # Group constants by their names
         constants_by_name = constants
@@ -182,7 +182,7 @@ module Tapioca
         Set.new.compare_by_identity.merge(filtered_constants)
       end
 
-      #: (T::Module[top] constant) -> RBI::File?
+      #: (Module[top] constant) -> RBI::File?
       def rbi_for_constant(constant)
         file = RBI::File.new(strictness: "true")
 

data/lib/tapioca/gem/events.rb

@@ -37,12 +37,12 @@ module Tapioca
 
     class ForeignConstantFound < ConstantFound
       # @override
-      #: -> T::Module[top]
+      #: -> Module[top]
       def constant
         T.cast(@constant, T::Module[T.anything])
       end
 
-      #: (String symbol, T::Module[top] constant) -> void
+      #: (String symbol, Module[top] constant) -> void
       def initialize(symbol, constant)
         super
       end
@@ -53,10 +53,10 @@ module Tapioca
       #: String
       attr_reader :symbol
 
-      #: T::Module[top]
+      #: Module[top]
       attr_reader :constant
 
-      #: (String symbol, T::Module[top] constant) -> void
+      #: (String symbol, Module[top] constant) -> void
       def initialize(symbol, constant)
         super()
         @symbol = symbol
@@ -68,7 +68,7 @@ module Tapioca
       #: RBI::Const
       attr_reader :node
 
-      #: (String symbol, T::Module[top] constant, RBI::Const node) -> void
+      #: (String symbol, Module[top] constant, RBI::Const node) -> void
       def initialize(symbol, constant, node)
         super(symbol, constant)
         @node = node
@@ -79,7 +79,7 @@ module Tapioca
       #: RBI::Scope
       attr_reader :node
 
-      #: (String symbol, T::Module[top] constant, RBI::Scope node) -> void
+      #: (String symbol, Module[top] constant, RBI::Scope node) -> void
       def initialize(symbol, constant, node)
         super(symbol, constant)
         @node = node
@@ -103,7 +103,7 @@ module Tapioca
 
       #: (
       #|   String symbol,
-      #|   T::Module[top] constant,
+      #|   Module[top] constant,
       #|   UnboundMethod method,
       #|   RBI::Method node,
       #|   untyped signature,

data/lib/tapioca/gem/listeners/methods.rb

@@ -25,9 +25,9 @@ module Tapioca
         #: (
         #|   RBI::Tree tree,
         #|   String module_name,
-        #|   T::Module[top] mod,
+        #|   Module[top] mod,
         #|   ?Array[Symbol] for_visibility,
-        #|   ?attached_class: T::Module[top]?
+        #|   ?attached_class: Module[top]?
         #| ) -> void
         def compile_directly_owned_methods(
           tree,
@@ -59,7 +59,7 @@ module Tapioca
         #: (
         #|   RBI::Tree tree,
         #|   String symbol_name,
-        #|   T::Module[top] constant,
+        #|   Module[top] constant,
         #|   UnboundMethod? method,
         #|   ?RBI::Visibility visibility
         #| ) -> void
@@ -169,7 +169,7 @@ module Tapioca
         # This method implements a better way of checking whether a constant defines a method.
         # It walks up the ancestor tree via the `super_method` method; if any of the super
         # methods are owned by the constant, it means that the constant declares the method.
-        #: (UnboundMethod method, T::Module[top] constant) -> bool
+        #: (UnboundMethod method, Module[top] constant) -> bool
         def method_owned_by_constant?(method, constant)
           # Widen the type of `method` to be nilable
           method = method #: UnboundMethod?
@@ -183,7 +183,7 @@ module Tapioca
           false
         end
 
-        #: (T::Module[top] mod) -> Hash[Symbol, Array[Symbol]]
+        #: (Module[top] mod) -> Hash[Symbol, Array[Symbol]]
         def method_names_by_visibility(mod)
           {
             public: public_instance_methods_of(mod),
@@ -192,7 +192,7 @@ module Tapioca
           }
         end
 
-        #: (T::Module[top] constant, String method_name) -> bool
+        #: (Module[top] constant, String method_name) -> bool
         def struct_method?(constant, method_name)
           return false unless T::Props::ClassMethods === constant
 
@@ -202,7 +202,7 @@ module Tapioca
             .include?(method_name.gsub(/=$/, "").to_sym)
         end
 
-        #: (T::Module[top]? attached_class, Symbol method_name) -> bool?
+        #: (Module[top]? attached_class, Symbol method_name) -> bool?
         def method_new_in_abstract_class?(attached_class, method_name)
           attached_class &&
             method_name == :new &&
@@ -210,7 +210,7 @@ module Tapioca
             Class === attached_class.singleton_class
         end
 
-        #: (T::Module[top] constant) -> UnboundMethod?
+        #: (Module[top] constant) -> UnboundMethod?
         def initialize_method_for(constant)
           constant.instance_method(:initialize)
         rescue

data/lib/tapioca/gem/listeners/mixins.rb

@@ -30,7 +30,7 @@ module Tapioca
           add_mixins(node, constant, extends.reverse, Runtime::Trackers::Mixin::Type::Extend)
         end
 
-        #: (RBI::Tree tree, T::Module[top] constant, Array[T::Module[top]] mods, Runtime::Trackers::Mixin::Type mixin_type) -> void
+        #: (RBI::Tree tree, Module[top] constant, Array[Module[top]] mods, Runtime::Trackers::Mixin::Type mixin_type) -> void
         def add_mixins(tree, constant, mods, mixin_type)
           mods
             .select do |mod|
@@ -57,7 +57,7 @@ module Tapioca
             end
         end
 
-        #: (T::Module[top] constant, T::Module[top] mixin, Runtime::Trackers::Mixin::Type mixin_type) -> bool
+        #: (Module[top] constant, Module[top] mixin, Runtime::Trackers::Mixin::Type mixin_type) -> bool
         def mixed_in_by_gem?(constant, mixin, mixin_type)
           mixin_location = Runtime::Trackers::Mixin.mixin_location(mixin, mixin_type, constant)
 
@@ -73,7 +73,7 @@ module Tapioca
           mixin_name.start_with?("T::") && !mixin_name.start_with?("T::Props")
         end
 
-        #: (T::Module[top] constant) -> Array[T::Module[top]]
+        #: (Module[top] constant) -> Array[Module[top]]
         def interesting_ancestors_of(constant)
           inherited_ancestors = Set.new.compare_by_identity.merge(inherited_ancestors_of(constant))
 

data/lib/tapioca/gem/listeners/sorbet_signatures.rb

@@ -23,8 +23,10 @@ module Tapioca
         def compile_signature(signature, parameters)
           parameter_types = signature.arg_types.to_h #: Hash[Symbol, T::Types::Base]
           parameter_types.merge!(signature.kwarg_types)
-          parameter_types[signature.rest_name] = signature.rest_type if signature.has_rest
-          parameter_types[signature.keyrest_name] = signature.keyrest_type if signature.has_keyrest
+          rest_type = signature.rest_type
+          parameter_types[signature.rest_name] = rest_type if rest_type
+          keyrest_type = signature.keyrest_type
+          parameter_types[signature.keyrest_name] = keyrest_type if keyrest_type
           parameter_types[signature.block_name] = signature.block_type if signature.block_name
 
           sig = RBI::Sig.new
@@ -40,7 +42,7 @@ module Tapioca
           sig.return_type = return_type
           @pipeline.push_symbol(return_type)
 
-          sig.type_params.concat(extract_type_parameters(parameter_types.values.map(&:to_s).push(return_type)))
+          sig.type_params.concat(extract_type_parameters(parameter_types.values.map(&:to_s).append(return_type)))
 
           case signature.mode
           when "abstract"

data/lib/tapioca/gem/listeners/sorbet_type_variables.rb

@@ -22,7 +22,7 @@ module Tapioca
           node << sclass if sclass.nodes.length > 1
         end
 
-        #: (RBI::Tree tree, T::Module[top] constant) -> void
+        #: (RBI::Tree tree, Module[top] constant) -> void
         def compile_type_variable_declarations(tree, constant)
           # Try to find the type variables defined on this constant, bail if we can't
           type_variables = Runtime::GenericTypeRegistry.lookup_type_variables(constant)

data/lib/tapioca/gem/pipeline.rb

@@ -72,29 +72,29 @@ module Tapioca
         @events << Gem::ConstantFound.new(symbol, constant)
       end
 
-      #: (String symbol, T::Module[top] constant) -> void
+      #: (String symbol, Module[top] constant) -> void
       def push_foreign_constant(symbol, constant)
         @events << Gem::ForeignConstantFound.new(symbol, constant)
       end
 
-      #: (String symbol, T::Module[top] constant, RBI::Const node) -> void
+      #: (String symbol, Module[top] constant, RBI::Const node) -> void
       def push_const(symbol, constant, node)
         @events << Gem::ConstNodeAdded.new(symbol, constant, node)
       end
 
-      #: (String symbol, T::Module[top] constant, RBI::Scope node) -> void
+      #: (String symbol, Module[top] constant, RBI::Scope node) -> void
       def push_scope(symbol, constant, node)
         @events << Gem::ScopeNodeAdded.new(symbol, constant, node)
       end
 
-      #: (String symbol, T::Module[top] constant, RBI::Scope node) -> void
+      #: (String symbol, Module[top] constant, RBI::Scope node) -> void
       def push_foreign_scope(symbol, constant, node)
         @events << Gem::ForeignScopeNodeAdded.new(symbol, constant, node)
       end
 
       #: (
       #|   String symbol,
-      #|   T::Module[top] constant,
+      #|   Module[top] constant,
       #|   UnboundMethod method,
       #|   RBI::Method node,
       #|   untyped signature,
@@ -150,7 +150,7 @@ module Tapioca
         end
       end
 
-      #: (Symbol method_name, T::Module[top] owner) -> MethodDefinitionLookupResult
+      #: (Symbol method_name, Module[top] owner) -> MethodDefinitionLookupResult
       def method_definition_in_gem(method_name, owner)
         definitions = Tapioca::Runtime::Trackers::MethodDefinition.method_definitions_for(method_name, owner)
 
@@ -176,7 +176,7 @@ module Tapioca
 
       # Helpers
 
-      #: (T::Module[top] constant) -> String?
+      #: (Module[top] constant) -> String?
       def name_of(constant)
         name = name_of_proxy_target(constant, super(class_of(constant)))
         return name if name
@@ -248,7 +248,7 @@ module Tapioca
 
       # Compiling
 
-      #: (String symbol, T::Module[top] constant) -> void
+      #: (String symbol, Module[top] constant) -> void
       def compile_foreign_constant(symbol, constant)
         return if skip_foreign_constant?(symbol, constant)
         return if seen?(symbol)
@@ -274,7 +274,7 @@ module Tapioca
         end
       end
 
-      #: (String name, T::Module[top] constant) -> void
+      #: (String name, Module[top] constant) -> void
       def compile_alias(name, constant)
         return if seen?(name)
 
@@ -329,7 +329,7 @@ module Tapioca
         @root << node
       end
 
-      #: (String name, T::Module[top] constant) -> void
+      #: (String name, Module[top] constant) -> void
       def compile_module(name, constant)
         return if skip_module?(name, constant)
         return if seen?(name)
@@ -340,7 +340,7 @@ module Tapioca
         push_scope(name, constant, scope)
       end
 
-      #: (String name, T::Module[top] constant) -> RBI::Scope
+      #: (String name, Module[top] constant) -> RBI::Scope
       def compile_scope(name, constant)
         scope = if constant.is_a?(Class)
           superclass = compile_superclass(constant)
@@ -423,7 +423,7 @@ module Tapioca
         false
       end
 
-      #: (String name, T::Module[top] constant) -> bool
+      #: (String name, Module[top] constant) -> bool
       def skip_alias?(name, constant)
         return true if symbol_in_payload?(name)
         return true unless constant_in_gem?(name)
@@ -441,12 +441,12 @@ module Tapioca
         false
       end
 
-      #: (String name, T::Module[top] constant) -> bool
+      #: (String name, Module[top] constant) -> bool
       def skip_foreign_constant?(name, constant)
         Tapioca::TypeVariableModule === constant
       end
 
-      #: (String name, T::Module[top] constant) -> bool
+      #: (String name, Module[top] constant) -> bool
       def skip_module?(name, constant)
         return true unless defined_in_gem?(constant, strict: false)
         return true if Tapioca::TypeVariableModule === constant
@@ -454,7 +454,7 @@ module Tapioca
         false
       end
 
-      #: (T::Module[top] constant, ?strict: bool) -> bool
+      #: (Module[top] constant, ?strict: bool) -> bool
       def defined_in_gem?(constant, strict: true)
         files = get_file_candidates(constant)
           .merge(Runtime::Trackers::ConstantDefinition.files_for(constant))
@@ -466,7 +466,7 @@ module Tapioca
         end
       end
 
-      #: (T::Module[top] constant) -> Set[String]
+      #: (Module[top] constant) -> Set[String]
       def get_file_candidates(constant)
         file_candidates_for(constant)
       rescue ArgumentError, NameError
@@ -497,7 +497,7 @@ module Tapioca
 
       # Helpers
 
-      #: ((T::Module[top] & T::Generic) constant) -> String
+      #: ((Module[top] & T::Generic) constant) -> String
       def generic_name_of(constant)
         type_name = T.must(constant.name)
         return type_name if type_name =~ /\[.*\]$/
@@ -513,7 +513,7 @@ module Tapioca
         "#{type_name}[#{type_variable_names}]"
       end
 
-      #: (T::Module[top] constant, String? class_name) -> String?
+      #: (Module[top] constant, String? class_name) -> String?
       def name_of_proxy_target(constant, class_name)
         return unless class_name == "ActiveSupport::Deprecation::DeprecatedConstantProxy"
 

data/lib/tapioca/helpers/sorbet_helper.rb

@@ -22,6 +22,25 @@ module Tapioca
       SPOOM_CONTEXT.srb(sorbet_args.join(" "), sorbet_bin: sorbet_path)
     end
 
+    #: (String, rbi_mode: bool) { (String stderr) -> void } -> void
+    def sorbet_syntax_check!(source, rbi_mode:, &on_failure)
+      quoted_source = "\"#{source}\""
+
+      result = if rbi_mode
+        # --e-rbi cannot be used on its own, so we pass a dummy value like `-e ""`
+        sorbet("--no-config", "--stop-after=parser", "-e", '""', "--e-rbi", quoted_source)
+      else
+        sorbet("--no-config", "--stop-after=parser", "-e", quoted_source)
+      end
+
+      unless result.status
+        stderr = result.err #: as !nil
+        on_failure.call(stderr)
+      end
+
+      nil
+    end
+
     #: -> String
     def sorbet_path
       sorbet_path = ENV.fetch(SORBET_EXE_PATH_ENV_VAR, SORBET_BIN)

data/lib/tapioca/helpers/test/dsl_compiler.rb

@@ -94,21 +94,14 @@ module Tapioca
             compiler.decorate
 
             rbi = Tapioca::DEFAULT_RBI_FORMATTER.print_file(file)
-            result = sorbet(
-              "--no-config",
-              "--stop-after",
-              "parser",
-              "-e",
-              "\"#{rbi}\"",
-            )
 
-            unless result.status
+            sorbet_syntax_check!(rbi, rbi_mode: true) do |stderr|
               raise(SyntaxError, <<~MSG)
                 Expected generated RBI file for `#{constant_name}` to not have any parsing errors.
 
                 Got these parsing errors:
 
-                #{result.err}
+                #{stderr}
               MSG
             end
 

data/lib/tapioca/internal.rb

@@ -13,6 +13,7 @@ require "tapioca/sorbet_ext/backcompat_patches"
 require "tapioca/sorbet_ext/name_patch"
 require "tapioca/sorbet_ext/generic_name_patch"
 require "tapioca/sorbet_ext/proc_bind_patch"
+require "tapioca/sorbet_ext/void_patch"
 require "tapioca/runtime/generic_type_registry"
 
 # The rewriter needs to be loaded very early so RBS comments within Tapioca itself are rewritten

data/lib/tapioca/rbi_ext/model.rb

@@ -3,7 +3,7 @@
 
 module RBI
   class Tree
-    #: (T::Module[top] constant) ?{ (Scope scope) -> void } -> Scope
+    #: (Module[top] constant) ?{ (Scope scope) -> void } -> Scope
     def create_path(constant, &block)
       constant_name = Tapioca::Runtime::Reflection.name_of(constant)
       raise "given constant does not have a name" unless constant_name
@@ -65,11 +65,10 @@ module RBI
     #|   ?return_type: String?,
     #|   ?class_method: bool,
     #|   ?visibility: RBI::Visibility,
-    #|   ?comments: Array[RBI::Comment],
-    #|   ?type_params: Array[String]
+    #|   ?comments: Array[RBI::Comment]
     #| ) ?{ (RBI::Method node) -> void } -> void
     def create_method(name, parameters: [], return_type: nil, class_method: false, visibility: RBI::Public.new,
-      comments: [], type_params: [], &block)
+      comments: [], &block)
       return unless Tapioca::RBIHelper.valid_method_name?(name)
 
       sigs = []
@@ -78,7 +77,11 @@ module RBI
         # 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", type_params: type_params)
+        return_type ||= "T.untyped"
+        type_params = Tapioca::RBIHelper.extract_type_parameters(parameters.map(&:type).append(return_type))
+
+        sig = RBI::Sig.new(params: params, return_type: return_type, type_params: type_params)
+        sigs << sig
       end
 
       method = RBI::Method.new(

data/lib/tapioca/runtime/dynamic_mixin_compiler.rb

@@ -6,7 +6,7 @@ module Tapioca
     class DynamicMixinCompiler
       include Runtime::Reflection
 
-      #: Array[T::Module[top]]
+      #: Array[Module[top]]
       attr_reader :dynamic_extends, :dynamic_includes
 
       #: Array[Symbol]
@@ -15,7 +15,7 @@ module Tapioca
       #: Array[Symbol]
       attr_reader :instance_attribute_readers, :instance_attribute_writers, :instance_attribute_predicates
 
-      #: (T::Module[top] constant) -> void
+      #: (Module[top] constant) -> void
       def initialize(constant)
         @constant = constant
         mixins_from_modules = {}.compare_by_identity
@@ -109,12 +109,12 @@ module Tapioca
         # is the list of all dynamically extended modules because of that
         # constant. We grab that value by deleting the key for the original
         # constant.
-        @dynamic_extends = mixins_from_modules.delete(constant) || [] #: Array[T::Module[top]]
+        @dynamic_extends = mixins_from_modules.delete(constant) || [] #: Array[Module[top]]
 
         # Since we deleted the original constant from the list of keys, all
         # the keys that remain are the ones that are dynamically included modules
         # during the include of the original constant.
-        @dynamic_includes = mixins_from_modules.keys #: Array[T::Module[top]]
+        @dynamic_includes = mixins_from_modules.keys #: Array[Module[top]]
 
         @class_attribute_readers = class_attribute_readers #: Array[Symbol]
         @class_attribute_writers = class_attribute_writers #: Array[Symbol]
@@ -173,7 +173,7 @@ module Tapioca
         tree << RBI::Include.new("GeneratedInstanceMethods")
       end
 
-      #: (RBI::Tree tree) -> [Array[T::Module[top]], Array[T::Module[top]]]
+      #: (RBI::Tree tree) -> [Array[Module[top]], Array[Module[top]]]
       def compile_mixes_in_class_methods(tree)
         includes = dynamic_includes.filter_map do |mod|
           qname = qualified_name_of(mod)
@@ -208,7 +208,7 @@ module Tapioca
         [[], []] # silence errors
       end
 
-      #: (T::Module[top] mod, Array[T::Module[top]] dynamic_extends) -> bool
+      #: (Module[top] mod, Array[Module[top]] dynamic_extends) -> bool
       def module_included_by_another_dynamic_extend?(mod, dynamic_extends)
         dynamic_extends.any? do |dynamic_extend|
           mod != dynamic_extend && ancestors_of(dynamic_extend).include?(mod)

data/lib/tapioca/runtime/generic_type_registry.rb

@@ -21,16 +21,16 @@ module Tapioca
     # variable to type variable serializers. This allows us to associate type variables
     # to the constant names that represent them, easily.
     module GenericTypeRegistry
-      @generic_instances = {} #: Hash[String, T::Module[top]]
+      @generic_instances = {} #: Hash[String, Module[top]]
 
-      @type_variables = {}.compare_by_identity #: Hash[T::Module[top], Array[TypeVariableModule]]
+      @type_variables = {}.compare_by_identity #: Hash[Module[top], Array[TypeVariableModule]]
 
       class GenericType < T::Types::Simple
-        #: (T::Module[top] raw_type, T::Module[top] underlying_type) -> void
+        #: (Module[top] raw_type, Module[top] underlying_type) -> void
         def initialize(raw_type, underlying_type)
           super(raw_type)
 
-          @underlying_type = underlying_type #: T::Module[top]
+          @underlying_type = underlying_type #: Module[top]
         end
 
         # @override
@@ -52,7 +52,7 @@ module Tapioca
         # 2 hash lookups (for the other two `Foo[Integer]`s).
         #
         # This method returns the created or cached clone of the constant.
-        #: (untyped constant, untyped types) -> T::Module[top]
+        #: (untyped constant, untyped types) -> Module[top]
         def register_type(constant, types)
           # Build the name of the instantiated generic type,
           # something like `"Foo[X, Y, Z]"`
@@ -72,7 +72,7 @@ module Tapioca
           @generic_instances.values.any? { |generic_type| generic_type === instance }
         end
 
-        #: (T::Module[top] constant) -> Array[TypeVariableModule]?
+        #: (Module[top] constant) -> Array[TypeVariableModule]?
         def lookup_type_variables(constant)
           @type_variables[constant]
         end
@@ -95,7 +95,7 @@ module Tapioca
 
         private
 
-        #: (T::Module[top] constant, String name) -> T::Module[top]
+        #: (Module[top] constant, String name) -> Module[top]
         def create_generic_type(constant, name)
           generic_type = case constant
           when Class
@@ -164,7 +164,7 @@ module Tapioca
           end
         end
 
-        #: (T::Module[top] constant) -> Array[TypeVariableModule]
+        #: (Module[top] constant) -> Array[TypeVariableModule]
         def lookup_or_initialize_type_variables(constant)
           @type_variables[constant] ||= []
         end