tapioca 0.17.9 → 0.17.10

data/lib/tapioca/gem/pipeline.rb

@@ -72,27 +72,34 @@ module Tapioca
         @events << Gem::ConstantFound.new(symbol, constant)
       end
 
-      #: (String symbol, Module constant) -> void
+      #: (String symbol, T::Module[top] constant) -> void
       def push_foreign_constant(symbol, constant)
         @events << Gem::ForeignConstantFound.new(symbol, constant)
       end
 
-      #: (String symbol, Module constant, RBI::Const node) -> void
+      #: (String symbol, T::Module[top] constant, RBI::Const node) -> void
       def push_const(symbol, constant, node)
         @events << Gem::ConstNodeAdded.new(symbol, constant, node)
       end
 
-      #: (String symbol, Module constant, RBI::Scope node) -> void
+      #: (String symbol, T::Module[top] constant, RBI::Scope node) -> void
       def push_scope(symbol, constant, node)
         @events << Gem::ScopeNodeAdded.new(symbol, constant, node)
       end
 
-      #: (String symbol, Module constant, RBI::Scope node) -> void
+      #: (String symbol, T::Module[top] constant, RBI::Scope node) -> void
       def push_foreign_scope(symbol, constant, node)
         @events << Gem::ForeignScopeNodeAdded.new(symbol, constant, node)
       end
 
-      #: (String symbol, Module constant, UnboundMethod method, RBI::Method node, untyped signature, Array[[Symbol, String]] parameters) -> void
+      #: (
+      #|   String symbol,
+      #|   T::Module[top] constant,
+      #|   UnboundMethod method,
+      #|   RBI::Method node,
+      #|   untyped signature,
+      #|   Array[[Symbol, String]] parameters
+      #| ) -> void
       def push_method(symbol, constant, method, node, signature, parameters) # rubocop:disable Metrics/ParameterLists
         @events << Gem::MethodNodeAdded.new(symbol, constant, method, node, signature, parameters)
       end
@@ -145,7 +152,7 @@ module Tapioca
         end
       end
 
-      #: (Symbol method_name, Module owner) -> MethodDefinitionLookupResult
+      #: (Symbol method_name, T::Module[top] owner) -> MethodDefinitionLookupResult
       def method_definition_in_gem(method_name, owner)
         definitions = Tapioca::Runtime::Trackers::MethodDefinition.method_definitions_for(method_name, owner)
 
@@ -171,7 +178,7 @@ module Tapioca
 
       # Helpers
 
-      #: (Module constant) -> String?
+      #: (T::Module[top] constant) -> String?
       def name_of(constant)
         name = name_of_proxy_target(constant, super(class_of(constant)))
         return name if name
@@ -243,7 +250,7 @@ module Tapioca
 
       # Compiling
 
-      #: (String symbol, Module constant) -> void
+      #: (String symbol, T::Module[top] constant) -> void
       def compile_foreign_constant(symbol, constant)
         return if skip_foreign_constant?(symbol, constant)
         return if seen?(symbol)
@@ -269,7 +276,7 @@ module Tapioca
         end
       end
 
-      #: (String name, Module constant) -> void
+      #: (String name, T::Module[top] constant) -> void
       def compile_alias(name, constant)
         return if seen?(name)
 
@@ -324,7 +331,7 @@ module Tapioca
         @root << node
       end
 
-      #: (String name, Module constant) -> void
+      #: (String name, T::Module[top] constant) -> void
       def compile_module(name, constant)
         return if skip_module?(name, constant)
         return if seen?(name)
@@ -335,7 +342,7 @@ module Tapioca
         push_scope(name, constant, scope)
       end
 
-      #: (String name, Module constant) -> RBI::Scope
+      #: (String name, T::Module[top] constant) -> RBI::Scope
       def compile_scope(name, constant)
         scope = if constant.is_a?(Class)
           superclass = compile_superclass(constant)
@@ -418,7 +425,7 @@ module Tapioca
         false
       end
 
-      #: (String name, Module constant) -> bool
+      #: (String name, T::Module[top] constant) -> bool
       def skip_alias?(name, constant)
         return true if symbol_in_payload?(name)
         return true unless constant_in_gem?(name)
@@ -436,12 +443,12 @@ module Tapioca
         false
       end
 
-      #: (String name, Module constant) -> bool
+      #: (String name, T::Module[top] constant) -> bool
       def skip_foreign_constant?(name, constant)
         Tapioca::TypeVariableModule === constant
       end
 
-      #: (String name, Module constant) -> bool
+      #: (String name, T::Module[top] constant) -> bool
       def skip_module?(name, constant)
         return true unless defined_in_gem?(constant, strict: false)
         return true if Tapioca::TypeVariableModule === constant
@@ -449,7 +456,7 @@ module Tapioca
         false
       end
 
-      #: (Module constant, ?strict: bool) -> bool
+      #: (T::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))
@@ -461,7 +468,7 @@ module Tapioca
         end
       end
 
-      #: (Module constant) -> Set[String]
+      #: (T::Module[top] constant) -> Set[String]
       def get_file_candidates(constant)
         file_candidates_for(constant)
       rescue ArgumentError, NameError
@@ -492,7 +499,7 @@ module Tapioca
 
       # Helpers
 
-      #: ((Module & T::Generic) constant) -> String
+      #: ((T::Module[top] & T::Generic) constant) -> String
       def generic_name_of(constant)
         type_name = T.must(constant.name)
         return type_name if type_name =~ /\[.*\]$/
@@ -508,7 +515,7 @@ module Tapioca
         "#{type_name}[#{type_variable_names}]"
       end
 
-      #: (Module constant, String? class_name) -> String?
+      #: (T::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/gemfile.rb

@@ -64,7 +64,7 @@ module Tapioca
       [dependencies, missing_specs]
     end
 
-    #: -> [T::Enumerable[Spec], Array[String]]
+    #: -> [Enumerable[Spec], Array[String]]
     def materialize_deps
       deps = definition.locked_gems.dependencies.except(*@excluded_gems).values
       resolve = definition.resolve

data/lib/tapioca/helpers/config_helper.rb

@@ -89,7 +89,11 @@ module Tapioca
       @validating_config = false
     end
 
-    #: (Hash[Symbol, Thor::Option] command_options, String config_key, Hash[untyped, untyped] config_options) -> Array[ConfigError]
+    #: (
+    #|   Hash[Symbol, Thor::Option] command_options,
+    #|   String config_key,
+    #|   Hash[untyped, untyped] config_options
+    #| ) -> Array[ConfigError]
     def validate_config_options(command_options, config_key, config_options)
       config_options.filter_map do |config_option_key, config_option_value|
         command_option = command_options[config_option_key.to_sym]

data/lib/tapioca/helpers/rbi_files_helper.rb

@@ -64,7 +64,14 @@ module Tapioca
       url
     end
 
-    #: (command: String, gem_dir: String, dsl_dir: String, auto_strictness: bool, ?gems: Array[Gemfile::GemSpec], ?compilers: T::Enumerable[singleton(Dsl::Compiler)]) -> void
+    #: (
+    #|   command: String,
+    #|   gem_dir: String,
+    #|   dsl_dir: String,
+    #|   auto_strictness: bool,
+    #|   ?gems: Array[Gemfile::GemSpec],
+    #|   ?compilers: Enumerable[singleton(Dsl::Compiler)]
+    #| ) -> void
     def validate_rbi_files(command:, gem_dir:, dsl_dir:, auto_strictness:, gems: [], compilers: [])
       error_url_base = Spoom::Sorbet::Errors::DEFAULT_ERROR_URL_BASE
 

data/lib/tapioca/loaders/gem.rb

@@ -9,7 +9,13 @@ module Tapioca
       class << self
         extend T::Sig
 
-        #: (bundle: Gemfile, prerequire: String?, postrequire: String, default_command: String, halt_upon_load_error: bool) -> void
+        #: (
+        #|   bundle: Gemfile,
+        #|   prerequire: String?,
+        #|   postrequire: String,
+        #|   default_command: String,
+        #|   halt_upon_load_error: bool
+        #| ) -> void
         def load_application(bundle:, prerequire:, postrequire:, default_command:, halt_upon_load_error:)
           loader = new(
             bundle: bundle,
@@ -30,7 +36,13 @@ module Tapioca
 
       protected
 
-      #: (bundle: Gemfile, prerequire: String?, postrequire: String, default_command: String, halt_upon_load_error: bool) -> void
+      #: (
+      #|   bundle: Gemfile,
+      #|   prerequire: String?,
+      #|   postrequire: String,
+      #|   default_command: String,
+      #|   halt_upon_load_error: bool
+      #| ) -> void
       def initialize(bundle:, prerequire:, postrequire:, default_command:, halt_upon_load_error:)
         super()
 

data/lib/tapioca/rbi_ext/model.rb

@@ -5,7 +5,7 @@ module RBI
   class Tree
     extend T::Sig
 
-    #: (::Module constant) ?{ (Scope scope) -> void } -> Scope
+    #: (T::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
@@ -61,7 +61,14 @@ module RBI
       create_node(RBI::TypeMember.new(name, value))
     end
 
-    #: (String name, ?parameters: Array[TypedParam], ?return_type: String?, ?class_method: bool, ?visibility: RBI::Visibility, ?comments: Array[RBI::Comment]) ?{ (RBI::Method node) -> void } -> void
+    #: (
+    #|   String name,
+    #|   ?parameters: Array[TypedParam],
+    #|   ?return_type: String?,
+    #|   ?class_method: bool,
+    #|   ?visibility: RBI::Visibility,
+    #|   ?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: [], &block)
       return unless Tapioca::RBIHelper.valid_method_name?(name)

data/lib/tapioca/repo_index.rb

@@ -30,7 +30,7 @@ module Tapioca
       @entries.add(gem_name)
     end
 
-    #: -> T::Enumerable[String]
+    #: -> Enumerable[String]
     def gems
       @entries.sort
     end

data/lib/tapioca/runtime/attached_class_of_32.rb

@@ -10,7 +10,7 @@ module Tapioca
     module AttachedClassOf
       extend T::Sig
 
-      #: (Class singleton_class) -> Module?
+      #: (Class singleton_class) -> T::Module[top]?
       def attached_class_of(singleton_class)
         result = singleton_class.attached_object
         Module === result ? result : nil

data/lib/tapioca/runtime/attached_class_of_legacy.rb

@@ -10,7 +10,7 @@ module Tapioca
     # @requires_ancestor: Tapioca::Runtime::Reflection
     module AttachedClassOf
       extend T::Sig
-      #: (Class singleton_class) -> Module?
+      #: (Class singleton_class) -> T::Module[top]?
       def attached_class_of(singleton_class)
         # https://stackoverflow.com/a/36622320/98634
         result = ObjectSpace.each_object(singleton_class).find do |klass|

data/lib/tapioca/runtime/dynamic_mixin_compiler.rb

@@ -7,7 +7,7 @@ module Tapioca
       extend T::Sig
       include Runtime::Reflection
 
-      #: Array[Module]
+      #: Array[T::Module[top]]
       attr_reader :dynamic_extends, :dynamic_includes
 
       #: Array[Symbol]
@@ -16,7 +16,7 @@ module Tapioca
       #: Array[Symbol]
       attr_reader :instance_attribute_readers, :instance_attribute_writers, :instance_attribute_predicates
 
-      #: (Module constant) -> void
+      #: (T::Module[top] constant) -> void
       def initialize(constant)
         @constant = constant
         mixins_from_modules = {}.compare_by_identity
@@ -112,12 +112,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[Module]
+        @dynamic_extends = mixins_from_modules.delete(constant) || [] #: Array[T::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[Module]
+        @dynamic_includes = mixins_from_modules.keys #: Array[T::Module[top]]
 
         @class_attribute_readers = class_attribute_readers #: Array[Symbol]
         @class_attribute_writers = class_attribute_writers #: Array[Symbol]
@@ -176,7 +176,7 @@ module Tapioca
         tree << RBI::Include.new("GeneratedInstanceMethods")
       end
 
-      #: (RBI::Tree tree) -> [Array[Module], Array[Module]]
+      #: (RBI::Tree tree) -> [Array[T::Module[top]], Array[T::Module[top]]]
       def compile_mixes_in_class_methods(tree)
         includes = dynamic_includes.filter_map do |mod|
           qname = qualified_name_of(mod)
@@ -211,7 +211,7 @@ module Tapioca
         [[], []] # silence errors
       end
 
-      #: (Module mod, Array[Module] dynamic_extends) -> bool
+      #: (T::Module[top] mod, Array[T::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,18 +21,18 @@ 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, Module]
+      @generic_instances = {} #: Hash[String, T::Module[top]]
 
-      @type_variables = {}.compare_by_identity #: Hash[Module, Array[TypeVariableModule]]
+      @type_variables = {}.compare_by_identity #: Hash[T::Module[top], Array[TypeVariableModule]]
 
       class GenericType < T::Types::Simple
         extend T::Sig
 
-        #: (Module raw_type, Module underlying_type) -> void
+        #: (T::Module[top] raw_type, T::Module[top] underlying_type) -> void
         def initialize(raw_type, underlying_type)
           super(raw_type)
 
-          @underlying_type = underlying_type #: Module
+          @underlying_type = underlying_type #: T::Module[top]
         end
 
         # @override
@@ -56,7 +56,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) -> Module
+        #: (untyped constant, untyped types) -> T::Module[top]
         def register_type(constant, types)
           # Build the name of the instantiated generic type,
           # something like `"Foo[X, Y, Z]"`
@@ -76,7 +76,7 @@ module Tapioca
           @generic_instances.values.any? { |generic_type| generic_type === instance }
         end
 
-        #: (Module constant) -> Array[TypeVariableModule]?
+        #: (T::Module[top] constant) -> Array[TypeVariableModule]?
         def lookup_type_variables(constant)
           @type_variables[constant]
         end
@@ -99,7 +99,7 @@ module Tapioca
 
         private
 
-        #: (Module constant, String name) -> Module
+        #: (T::Module[top] constant, String name) -> T::Module[top]
         def create_generic_type(constant, name)
           generic_type = case constant
           when Class
@@ -168,7 +168,7 @@ module Tapioca
           end
         end
 
-        #: (Module constant) -> Array[TypeVariableModule]
+        #: (T::Module[top] constant) -> Array[TypeVariableModule]
         def lookup_or_initialize_type_variables(constant)
           @type_variables[constant] ||= []
         end

data/lib/tapioca/runtime/reflection.rb

@@ -32,7 +32,7 @@ module Tapioca
       PROTECTED_INSTANCE_METHODS_METHOD = Module.instance_method(:protected_instance_methods) #: UnboundMethod
       PRIVATE_INSTANCE_METHODS_METHOD = Module.instance_method(:private_instance_methods) #: UnboundMethod
       METHOD_METHOD = Kernel.instance_method(:method) #: UnboundMethod
-      UNDEFINED_CONSTANT = Module.new.freeze #: Module
+      UNDEFINED_CONSTANT = Module.new.freeze #: T::Module[top]
 
       REQUIRED_FROM_LABELS = ["<top (required)>", "<main>", "<compiled>"].freeze #: Array[String]
 
@@ -43,7 +43,7 @@ module Tapioca
       end
 
       # @without_runtime
-      #: (String symbol, ?inherit: bool, ?namespace: Module) -> BasicObject
+      #: (String symbol, ?inherit: bool, ?namespace: T::Module[top]) -> BasicObject
       def constantize(symbol, inherit: false, namespace: Object)
         namespace.const_get(symbol, inherit)
       rescue NameError, LoadError, RuntimeError, ArgumentError, TypeError
@@ -55,23 +55,23 @@ module Tapioca
         CLASS_METHOD.bind_call(object)
       end
 
-      #: (Module constant) -> Array[Symbol]
+      #: (T::Module[top] constant) -> Array[Symbol]
       def constants_of(constant)
         CONSTANTS_METHOD.bind_call(constant, false)
       end
 
-      #: (Module constant) -> String?
+      #: (T::Module[top] constant) -> String?
       def name_of(constant)
         name = NAME_METHOD.bind_call(constant)
         name&.start_with?("#<") ? nil : name
       end
 
-      #: (Module constant) -> Class[top]
+      #: (T::Module[top] constant) -> Class[top]
       def singleton_class_of(constant)
         SINGLETON_CLASS_METHOD.bind_call(constant)
       end
 
-      #: (Module constant) -> Array[Module]
+      #: (T::Module[top] constant) -> Array[T::Module[top]]
       def ancestors_of(constant)
         ANCESTORS_METHOD.bind_call(constant)
       end
@@ -91,22 +91,22 @@ module Tapioca
         EQUAL_METHOD.bind_call(object, other)
       end
 
-      #: (Module constant) -> Array[Symbol]
+      #: (T::Module[top] constant) -> Array[Symbol]
       def public_instance_methods_of(constant)
         PUBLIC_INSTANCE_METHODS_METHOD.bind_call(constant)
       end
 
-      #: (Module constant) -> Array[Symbol]
+      #: (T::Module[top] constant) -> Array[Symbol]
       def protected_instance_methods_of(constant)
         PROTECTED_INSTANCE_METHODS_METHOD.bind_call(constant)
       end
 
-      #: (Module constant) -> Array[Symbol]
+      #: (T::Module[top] constant) -> Array[Symbol]
       def private_instance_methods_of(constant)
         PRIVATE_INSTANCE_METHODS_METHOD.bind_call(constant)
       end
 
-      #: (Module constant) -> Array[Module]
+      #: (T::Module[top] constant) -> Array[T::Module[top]]
       def inherited_ancestors_of(constant)
         if Class === constant
           ancestors_of(superclass_of(constant) || Object)
@@ -115,7 +115,7 @@ module Tapioca
         end
       end
 
-      #: (Module constant) -> String?
+      #: (T::Module[top] constant) -> String?
       def qualified_name_of(constant)
         name = name_of(constant)
         return if name.nil?
@@ -148,7 +148,7 @@ module Tapioca
         type.to_s
       end
 
-      #: (Module constant, Symbol method) -> Method
+      #: (T::Module[top] constant, Symbol method) -> Method
       def method_of(constant, method)
         METHOD_METHOD.bind_call(constant, method)
       end
@@ -217,32 +217,32 @@ module Tapioca
         SourceLocation.from_loc([file, resolved_loc.lineno])
       end
 
-      #: (Module constant) -> Set[String]
+      #: (T::Module[top] constant) -> Set[String]
       def file_candidates_for(constant)
         relevant_methods_for(constant).filter_map do |method|
           method.source_location&.first
         end.to_set
       end
 
-      #: (Module constant) -> untyped
+      #: (T::Module[top] constant) -> untyped
       def abstract_type_of(constant)
         T::Private::Abstract::Data.get(constant, :abstract_type) ||
           T::Private::Abstract::Data.get(singleton_class_of(constant), :abstract_type)
       end
 
-      #: (Module constant) -> bool
+      #: (T::Module[top] constant) -> bool
       def final_module?(constant)
         T::Private::Final.final_module?(constant)
       end
 
-      #: (Module constant) -> bool
+      #: (T::Module[top] constant) -> bool
       def sealed_module?(constant)
         T::Private::Sealed.sealed_module?(constant)
       end
 
       private
 
-      #: (Module constant) -> Array[UnboundMethod]
+      #: (T::Module[top] constant) -> Array[UnboundMethod]
       def relevant_methods_for(constant)
         methods = methods_for(constant).select(&:source_location)
           .reject { |x| method_defined_by_forwardable_module?(x) }
@@ -258,7 +258,7 @@ module Tapioca
         end
       end
 
-      #: (Module constant) -> Array[UnboundMethod]
+      #: (T::Module[top] constant) -> Array[UnboundMethod]
       def methods_for(constant)
         modules = [constant, singleton_class_of(constant)]
         method_list_methods = [
@@ -272,7 +272,7 @@ module Tapioca
         end
       end
 
-      #: (Module parent, String name) -> Module?
+      #: (T::Module[top] parent, String name) -> T::Module[top]?
       def child_module_for_parent_with_name(parent, name)
         return if parent.autoload?(name)
 

data/lib/tapioca/runtime/trackers/constant_definition.rb

@@ -13,7 +13,7 @@ module Tapioca
         extend Reflection
         extend T::Sig
 
-        @class_files = {}.compare_by_identity #: Hash[Module, Set[SourceLocation]]
+        @class_files = {}.compare_by_identity #: Hash[T::Module[top], Set[SourceLocation]]
 
         # Immediately activated upon load. Observes class/module definition.
         @class_tracepoint = TracePoint.trace(:class) do |tp|
@@ -70,12 +70,12 @@ module Tapioca
           # Returns the files in which this class or module was opened. Doesn't know
           # about situations where the class was opened prior to +require+ing,
           # or where metaprogramming was used via +eval+, etc.
-          #: (Module klass) -> Set[String]
+          #: (T::Module[top] klass) -> Set[String]
           def files_for(klass)
             locations_for(klass).map(&:file).to_set
           end
 
-          #: (Module klass) -> Set[SourceLocation]
+          #: (T::Module[top] klass) -> Set[SourceLocation]
           def locations_for(klass)
             @class_files.fetch(klass, Set.new)
           end

data/lib/tapioca/runtime/trackers/method_definition.rb

@@ -8,10 +8,10 @@ module Tapioca
         extend Tracker
         extend T::Sig
 
-        @method_definitions = {}.compare_by_identity #: Hash[Module, Hash[Symbol, Array[SourceLocation]]]
+        @method_definitions = {}.compare_by_identity #: Hash[T::Module[top], Hash[Symbol, Array[SourceLocation]]]
 
         class << self
-          #: (Symbol method_name, Module owner, Array[Thread::Backtrace::Location] locations) -> void
+          #: (Symbol method_name, T::Module[top] owner, Array[Thread::Backtrace::Location] locations) -> void
           def register(method_name, owner, locations)
             return unless enabled?
             # If Sorbet runtime is redefining a method, it sets this to true.
@@ -25,7 +25,7 @@ module Tapioca
             registrations_for(method_name, owner) << loc
           end
 
-          #: (Symbol method_name, Module owner) -> Array[SourceLocation]
+          #: (Symbol method_name, T::Module[top] owner) -> Array[SourceLocation]
           def method_definitions_for(method_name, owner)
             definitions = registrations_for(method_name, owner)
 
@@ -39,7 +39,7 @@ module Tapioca
 
           private
 
-          #: (Symbol method_name, Module owner) -> Array[SourceLocation]
+          #: (Symbol method_name, T::Module[top] owner) -> Array[SourceLocation]
           def registrations_for(method_name, owner)
             owner_lookup = (@method_definitions[owner] ||= {})
             owner_lookup[method_name] ||= []

data/lib/tapioca/runtime/trackers/mixin.rb

@@ -27,7 +27,7 @@ module Tapioca
             with_disabled_tracker(&block)
           end
 
-          #: (Module constant, Module mixin, Type mixin_type) -> void
+          #: (T::Module[top] constant, T::Module[top] mixin, Type mixin_type) -> void
           def register(constant, mixin, mixin_type)
             return unless enabled?
 
@@ -49,19 +49,19 @@ module Tapioca
             attached_class
           end
 
-          #: (Module mixin) -> Hash[Type, Hash[Module, String]]
+          #: (T::Module[top] mixin) -> Hash[Type, Hash[T::Module[top], String]]
           def constants_with_mixin(mixin)
             find_or_initialize_mixin_lookup(mixin)
           end
 
-          #: (Module mixin, Type mixin_type, Module constant) -> String?
+          #: (T::Module[top] mixin, Type mixin_type, T::Module[top] constant) -> String?
           def mixin_location(mixin, mixin_type, constant)
             find_or_initialize_mixin_lookup(mixin).dig(mixin_type, constant)
           end
 
           private
 
-          #: (Module constant, Module mixin, Type mixin_type, String location) -> void
+          #: (T::Module[top] constant, T::Module[top] mixin, Type mixin_type, String location) -> void
           def register_with_location(constant, mixin, mixin_type, location)
             return unless @enabled
 
@@ -69,7 +69,7 @@ module Tapioca
             constants.fetch(mixin_type).store(constant, location)
           end
 
-          #: (Module mixin) -> Hash[Type, Hash[Module, String]]
+          #: (T::Module[top] mixin) -> Hash[Type, Hash[T::Module[top], String]]
           def find_or_initialize_mixin_lookup(mixin)
             @mixins_to_constants[mixin] ||= {
               Type::Prepend => {}.compare_by_identity,

data/lib/tapioca/runtime/trackers/required_ancestor.rb

@@ -19,12 +19,12 @@ module Tapioca
             ancestors << block
           end
 
-          #: (Module mod) -> Array[^-> void]
+          #: (T::Module[top] mod) -> Array[^-> void]
           def required_ancestors_blocks_by(mod)
             @required_ancestors_map[mod] || []
           end
 
-          #: (Module mod) -> Array[untyped]
+          #: (T::Module[top] mod) -> Array[untyped]
           def required_ancestors_by(mod)
             blocks = required_ancestors_blocks_by(mod)
             blocks.map do |block|

data/lib/tapioca/runtime/trackers/tracker.rb

@@ -10,7 +10,7 @@ module Tapioca
         class << self
           extend T::Sig
 
-          #: ((Tracker & Module) base) -> void
+          #: ((Tracker & T::Module[top]) base) -> void
           def extended(base)
             Trackers.register_tracker(base)
             base.instance_exec do

data/lib/tapioca/sorbet_ext/generic_name_patch.rb

@@ -135,7 +135,7 @@ module Tapioca
     #: Type
     attr_reader :type
 
-    #: (Module context, Type type, Symbol variance, (^-> Hash[Symbol, untyped])? bounds_proc) -> void
+    #: (T::Module[top] context, Type type, Symbol variance, (^-> Hash[Symbol, untyped])? bounds_proc) -> void
     def initialize(context, type, variance, bounds_proc)
       @context = context
       @type = type