tapioca 0.17.9 → 0.18.0

data/lib/tapioca/runtime/dynamic_mixin_compiler.rb

@@ -4,10 +4,9 @@
 module Tapioca
   module Runtime
     class DynamicMixinCompiler
-      extend T::Sig
       include Runtime::Reflection
 
-      #: Array[Module]
+      #: Array[T::Module[top]]
       attr_reader :dynamic_extends, :dynamic_includes
 
       #: Array[Symbol]
@@ -16,7 +15,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
@@ -95,8 +94,6 @@ module Tapioca
           end
 
           class << self
-            extend T::Sig
-
             T::Sig::WithoutRuntime.sig { params(symbol: Symbol, args: T.untyped).returns(T.untyped) }
             def method_missing(symbol, *args)
               # Similarly, we need this here so that we can handle any
@@ -112,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[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 +173,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 +208,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,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, 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
@@ -43,8 +41,6 @@ module Tapioca
       end
 
       class << self
-        extend T::Sig
-
         # This method is responsible for building the name of the instantiated concrete type
         # and cloning the given constant so that we can return a type that is the same
         # as the current type but is a different instance and has a different name method.
@@ -56,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) -> 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 +72,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 +95,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 +164,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

@@ -3,21 +3,9 @@
 
 require "tapioca/runtime/source_location"
 
-# On Ruby 3.2 or newer, Class defines an attached_object method that returns the
-# attached class of a singleton class without iterating ObjectSpace. On older
-# versions of Ruby, we fall back to iterating ObjectSpace.
-if Class.method_defined?(:attached_object)
-  require "tapioca/runtime/attached_class_of_32"
-else
-  require "tapioca/runtime/attached_class_of_legacy"
-end
-
 module Tapioca
   module Runtime
     module Reflection
-      include AttachedClassOf
-
-      extend T::Sig
       extend self
 
       CLASS_METHOD = Kernel.instance_method(:class) #: UnboundMethod
@@ -32,7 +20,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 +31,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 +43,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
@@ -81,6 +69,12 @@ module Tapioca
         SUPERCLASS_METHOD.bind_call(constant)
       end
 
+      #: (Class[top] singleton_class) -> T::Module[top]?
+      def attached_class_of(singleton_class)
+        result = singleton_class.attached_object
+        Module === result ? result : nil
+      end
+
       #: (BasicObject object) -> Integer
       def object_id_of(object)
         OBJECT_ID_METHOD.bind_call(object)
@@ -91,22 +85,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 +109,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 +142,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 +211,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 +252,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 +266,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/autoload.rb

@@ -6,13 +6,10 @@ module Tapioca
     module Trackers
       module Autoload
         extend Tracker
-        extend T::Sig
 
         @constant_names_registered_for_autoload = [] #: Array[String]
 
         class << self
-          extend T::Sig
-
           #: -> void
           def eager_load_all!
             Runtime.with_disabled_exits do

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

@@ -11,9 +11,8 @@ module Tapioca
       module ConstantDefinition
         extend Tracker
         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|
@@ -36,7 +35,7 @@ module Tapioca
             ])
           end
 
-          (@class_files[key] ||= Set.new) << loc
+          ConstantDefinition.register(key, loc)
         end
 
         @creturn_tracepoint = TracePoint.trace(:c_return) do |tp|
@@ -46,12 +45,10 @@ module Tapioca
           next unless Module === key
 
           loc = build_source_location(tp, caller_locations)
-          (@class_files[key] ||= Set.new) << loc
+          ConstantDefinition.register(key, loc)
         end
 
         class << self
-          extend T::Sig
-
           def disable!
             @class_tracepoint.disable
             @creturn_tracepoint.disable
@@ -67,15 +64,31 @@ module Tapioca
             SourceLocation.from_loc([file || "", lineno])
           end
 
+          def register(constant, loc)
+            return unless loc
+
+            (@class_files[constant] ||= Set.new) << loc
+          end
+
+          def register_cname(cname, namespace, locations)
+            return if namespace.autoload?(cname)
+
+            key = Reflection.constantize(cname, namespace: namespace, inherit: true)
+            return unless Module === key
+
+            loc = Reflection.resolve_loc(locations)
+            ConstantDefinition.register(key, loc)
+          end
+
           # 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
@@ -84,3 +97,12 @@ module Tapioca
     end
   end
 end
+
+class Module
+  prepend(::Module.new do
+    def const_added(cname)
+      ::Tapioca::Runtime::Trackers::ConstantDefinition.register_cname(cname, self, Kernel.caller_locations)
+      super(cname)
+    end
+  end)
+end

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

@@ -6,12 +6,11 @@ module Tapioca
     module Trackers
       module MethodDefinition
         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 +24,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 +38,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

@@ -6,7 +6,6 @@ module Tapioca
     module Trackers
       module Mixin
         extend Tracker
-        extend T::Sig
 
         @constants_to_mixin_locations = {}.compare_by_identity
         @mixins_to_constants = {}.compare_by_identity
@@ -20,14 +19,12 @@ module Tapioca
         end
 
         class << self
-          extend T::Sig
-
           #: [Result] { -> Result } -> Result
           def with_disabled_registration(&block)
             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 +46,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 +66,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

@@ -9,8 +9,6 @@ module Tapioca
         @required_ancestors_map = {}.compare_by_identity
 
         class << self
-          extend T::Sig
-
           #: (T::Helpers requiring, ^-> void block) -> void
           def register(requiring, block)
             return unless enabled?
@@ -19,12 +17,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

@@ -6,11 +6,8 @@ module Tapioca
     module Trackers
       # @abstract
       module Tracker
-        extend T::Sig
         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/runtime/trackers.rb

@@ -6,13 +6,9 @@ require "tapioca/runtime/trackers/tracker"
 module Tapioca
   module Runtime
     module Trackers
-      extend T::Sig
-
       @trackers = [] #: Array[Tracker]
 
       class << self
-        extend T::Sig
-
         #: [Return] { -> Return } -> Return
         def with_trackers_enabled(&blk)
           # Currently this is a dirty hack to ensure disabling trackers

data/lib/tapioca/sorbet_ext/generic_name_patch.rb

@@ -120,8 +120,6 @@ module Tapioca
   # need to do any matching of constants to type variables to bind their names, Ruby will
   # do that automatically for us and we get the `name` method for free from `Module`.
   class TypeVariableModule < Module
-    extend T::Sig
-
     class Type < T::Enum
       enums do
         Member = new("type_member")
@@ -135,7 +133,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

data/lib/tapioca/static/requires_compiler.rb

@@ -4,8 +4,6 @@
 module Tapioca
   module Static
     class RequiresCompiler
-      extend T::Sig
-
       #: (String sorbet_path) -> void
       def initialize(sorbet_path)
         @sorbet_path = sorbet_path
@@ -40,7 +38,7 @@ module Tapioca
         end.sort.uniq
       end
 
-      #: (String file_path) -> T::Enumerable[String]
+      #: (String file_path) -> Enumerable[String]
       def collect_requires(file_path)
         File.binread(file_path).lines.filter_map do |line|
           /^\s*require\s*(\(\s*)?['"](?<name>[^'"]+)['"](\s*\))?/.match(line) { |m| m["name"] }

data/lib/tapioca/static/symbol_loader.rb

@@ -5,7 +5,6 @@ module Tapioca
   module Static
     module SymbolLoader
       class << self
-        extend T::Sig
         include SorbetHelper
         include Runtime::Reflection
 

data/lib/tapioca/static/symbol_table_parser.rb

@@ -4,13 +4,9 @@
 module Tapioca
   module Static
     class SymbolTableParser
-      extend T::Sig
-
       SKIP_PARSE_KINDS = ["CLASS_OR_MODULE", "STATIC_FIELD"].freeze #: Array[String]
 
       class << self
-        extend T::Sig
-
         #: (String json_string) -> Set[String]
         def parse_json(json_string)
           obj = JSON.parse(json_string)

data/lib/tapioca/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Tapioca
-  VERSION = "0.17.9"
+  VERSION = "0.18.0"
 end

data/lib/tapioca.rb

@@ -5,8 +5,6 @@ require "sorbet-runtime"
 require "rubygems/user_interaction"
 
 module Tapioca
-  extend T::Sig
-
   @traces = [] #: Array[TracePoint]
 
   class Error < StandardError; end