tapioca 0.16.9 → 0.17.7

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

@@ -10,12 +10,12 @@ module Tapioca
 
         NOOP_METHOD = ->(*_args, **_kwargs, &_block) {}
 
-        @constant_names_registered_for_autoload = T.let([], T::Array[String])
+        @constant_names_registered_for_autoload = [] #: Array[String]
 
         class << self
           extend T::Sig
 
-          sig { void }
+          #: -> void
           def eager_load_all!
             with_disabled_exits do
               until @constant_names_registered_for_autoload.empty?
@@ -27,18 +27,14 @@ module Tapioca
             end
           end
 
-          sig { params(constant_name: String).void }
+          #: (String constant_name) -> void
           def register(constant_name)
             return unless enabled?
 
             @constant_names_registered_for_autoload << constant_name
           end
 
-          sig do
-            type_parameters(:Result)
-              .params(block: T.proc.returns(T.type_parameter(:Result)))
-              .returns(T.type_parameter(:Result))
-          end
+          #: [Result] { -> Result } -> Result
           def with_disabled_exits(&block)
             original_abort = Kernel.instance_method(:abort)
             original_exit = Kernel.instance_method(:exit)
@@ -47,7 +43,9 @@ module Tapioca
               Kernel.define_method(:abort, NOOP_METHOD)
               Kernel.define_method(:exit, NOOP_METHOD)
 
-              block.call
+              Tapioca.silence_warnings do
+                block.call
+              end
             ensure
               Kernel.define_method(:exit, original_exit)
               Kernel.define_method(:abort, original_abort)

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

@@ -13,12 +13,7 @@ module Tapioca
         extend Reflection
         extend T::Sig
 
-        class ConstantLocation < T::Struct
-          const :lineno, Integer
-          const :path, String
-        end
-
-        @class_files = {}.compare_by_identity
+        @class_files = {}.compare_by_identity #: Hash[Module, Set[SourceLocation]]
 
         # Immediately activated upon load. Observes class/module definition.
         @class_tracepoint = TracePoint.trace(:class) do |tp|
@@ -28,14 +23,17 @@ module Tapioca
 
           path = tp.path
           if File.exist?(path)
-            loc = build_constant_location(tp, caller_locations)
+            loc = build_source_location(tp, caller_locations)
           else
             caller_location = T.must(caller_locations)
               .find { |loc| loc.path && File.exist?(loc.path) }
 
             next unless caller_location
 
-            loc = ConstantLocation.new(path: caller_location.absolute_path || "", lineno: caller_location.lineno)
+            loc = SourceLocation.from_loc([
+              caller_location.absolute_path || "",
+              caller_location.lineno,
+            ])
           end
 
           (@class_files[key] ||= Set.new) << loc
@@ -47,31 +45,37 @@ module Tapioca
           key = tp.return_value
           next unless Module === key
 
-          loc = build_constant_location(tp, caller_locations)
+          loc = build_source_location(tp, caller_locations)
           (@class_files[key] ||= Set.new) << loc
         end
 
         class << self
+          extend T::Sig
+
           def disable!
             @class_tracepoint.disable
             @creturn_tracepoint.disable
             super
           end
 
-          def build_constant_location(tp, locations)
-            file = resolve_loc(locations)
-            lineno = File.identical?(file, tp.path) ? tp.lineno : 0
+          def build_source_location(tp, locations)
+            loc = resolve_loc(locations)
+            file = loc&.file
+            line = loc&.line
+            lineno = file && File.identical?(file, tp.path) ? tp.lineno : (line || 0)
 
-            ConstantLocation.new(path: file, lineno: lineno)
+            SourceLocation.from_loc([file || "", lineno])
           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]
           def files_for(klass)
-            locations_for(klass).map(&:path).to_set
+            locations_for(klass).map(&:file).to_set
           end
 
+          #: (Module klass) -> Set[SourceLocation]
           def locations_for(klass)
             @class_files.fetch(klass, Set.new)
           end

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

@@ -0,0 +1,65 @@
+# typed: true
+# frozen_string_literal: true
+
+module Tapioca
+  module Runtime
+    module Trackers
+      module MethodDefinition
+        extend Tracker
+        extend T::Sig
+
+        @method_definitions = {}.compare_by_identity #: Hash[Module, Hash[Symbol, Array[SourceLocation]]]
+
+        class << self
+          #: (Symbol method_name, Module 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.
+            # In those cases, we should skip the registration, as the method's original
+            # definition should already be registered.
+            return if T::Private::DeclState.current.skip_on_method_added
+
+            loc = Reflection.resolve_loc(locations)
+            return unless loc
+
+            registrations_for(method_name, owner) << loc
+          end
+
+          #: (Symbol method_name, Module owner) -> Array[SourceLocation]
+          def method_definitions_for(method_name, owner)
+            definitions = registrations_for(method_name, owner)
+
+            if definitions.empty?
+              source_loc = owner.instance_method(method_name).source_location
+              definitions = [SourceLocation.from_loc(source_loc)].compact
+            end
+
+            definitions
+          end
+
+          private
+
+          #: (Symbol method_name, Module owner) -> Array[SourceLocation]
+          def registrations_for(method_name, owner)
+            owner_lookup = (@method_definitions[owner] ||= {})
+            owner_lookup[method_name] ||= []
+          end
+        end
+      end
+    end
+  end
+end
+
+class Module
+  prepend(Module.new do
+    def singleton_method_added(method_name)
+      Tapioca::Runtime::Trackers::MethodDefinition.register(method_name, singleton_class, Kernel.caller_locations)
+      super
+    end
+
+    def method_added(method_name)
+      Tapioca::Runtime::Trackers::MethodDefinition.register(method_name, self, Kernel.caller_locations)
+      super
+    end
+  end)
+end

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

@@ -22,22 +22,19 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig do
-            type_parameters(:Result)
-              .params(block: T.proc.returns(T.type_parameter(:Result)))
-              .returns(T.type_parameter(:Result))
-          end
+          #: [Result] { -> Result } -> Result
           def with_disabled_registration(&block)
             with_disabled_tracker(&block)
           end
 
-          sig { params(constant: Module, mixin: Module, mixin_type: Type).void }
+          #: (Module constant, Module mixin, Type mixin_type) -> void
           def register(constant, mixin, mixin_type)
             return unless enabled?
 
             location = Reflection.resolve_loc(caller_locations)
+            return unless location
 
-            register_with_location(constant, mixin, mixin_type, location)
+            register_with_location(constant, mixin, mixin_type, location.file)
           end
 
           def resolve_to_attached_class(constant, mixin, mixin_type)
@@ -52,19 +49,19 @@ module Tapioca
             attached_class
           end
 
-          sig { params(mixin: Module).returns(T::Hash[Type, T::Hash[Module, String]]) }
+          #: (Module mixin) -> Hash[Type, Hash[Module, String]]
           def constants_with_mixin(mixin)
             find_or_initialize_mixin_lookup(mixin)
           end
 
-          sig { params(mixin: Module, mixin_type: Type, constant: Module).returns(T.nilable(String)) }
+          #: (Module mixin, Type mixin_type, Module constant) -> String?
           def mixin_location(mixin, mixin_type, constant)
             find_or_initialize_mixin_lookup(mixin).dig(mixin_type, constant)
           end
 
           private
 
-          sig { params(constant: Module, mixin: Module, mixin_type: Type, location: String).void }
+          #: (Module constant, Module mixin, Type mixin_type, String location) -> void
           def register_with_location(constant, mixin, mixin_type, location)
             return unless @enabled
 
@@ -72,7 +69,7 @@ module Tapioca
             constants.fetch(mixin_type).store(constant, location)
           end
 
-          sig { params(mixin: Module).returns(T::Hash[Type, T::Hash[Module, String]]) }
+          #: (Module mixin) -> Hash[Type, Hash[Module, 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

@@ -11,7 +11,7 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { params(requiring: T::Helpers, block: T.proc.void).void }
+          #: (T::Helpers requiring, ^-> void block) -> void
           def register(requiring, block)
             return unless enabled?
 
@@ -19,12 +19,12 @@ module Tapioca
             ancestors << block
           end
 
-          sig { params(mod: Module).returns(T::Array[T.proc.void]) }
+          #: (Module mod) -> Array[^-> void]
           def required_ancestors_blocks_by(mod)
             @required_ancestors_map[mod] || []
           end
 
-          sig { params(mod: Module).returns(T::Array[T.untyped]) }
+          #: (Module 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

@@ -4,16 +4,13 @@
 module Tapioca
   module Runtime
     module Trackers
+      # @abstract
       module Tracker
         extend T::Sig
-        extend T::Helpers
-
-        abstract!
-
         class << self
           extend T::Sig
 
-          sig { params(base: T.all(Tracker, Module)).void }
+          #: ((Tracker & Module) base) -> void
           def extended(base)
             Trackers.register_tracker(base)
             base.instance_exec do
@@ -22,7 +19,7 @@ module Tapioca
           end
         end
 
-        sig { void }
+        #: -> void
         def disable!
           @enabled = false
         end

data/lib/tapioca/runtime/trackers.rb

@@ -8,16 +8,12 @@ module Tapioca
     module Trackers
       extend T::Sig
 
-      @trackers = T.let([], T::Array[Tracker])
+      @trackers = [] #: Array[Tracker]
 
       class << self
         extend T::Sig
 
-        sig do
-          type_parameters(:Return)
-            .params(blk: T.proc.returns(T.type_parameter(:Return)))
-            .returns(T.type_parameter(:Return))
-        end
+        #: [Return] { -> Return } -> Return
         def with_trackers_enabled(&blk)
           # Currently this is a dirty hack to ensure disabling trackers
           # doesn't work while in the block passed to this method.
@@ -30,12 +26,12 @@ module Tapioca
           end
         end
 
-        sig { void }
+        #: -> void
         def disable_all!
           @trackers.each(&:disable!)
         end
 
-        sig { params(tracker: Tracker).void }
+        #: (Tracker tracker) -> void
         def register_tracker(tracker)
           @trackers << tracker
         end
@@ -56,3 +52,4 @@ require "tapioca/runtime/trackers/mixin"
 require "tapioca/runtime/trackers/constant_definition"
 require "tapioca/runtime/trackers/autoload"
 require "tapioca/runtime/trackers/required_ancestor"
+require "tapioca/runtime/trackers/method_definition"

data/lib/tapioca/sorbet_ext/generic_name_patch.rb

@@ -130,19 +130,12 @@ module Tapioca
       end
     end
 
-    DEFAULT_BOUNDS_PROC = T.let(-> { {} }, T.proc.returns(T::Hash[Symbol, T.untyped]))
+    DEFAULT_BOUNDS_PROC = -> { {} } #: ^-> Hash[Symbol, untyped]
 
-    sig { returns(Type) }
+    #: Type
     attr_reader :type
 
-    sig do
-      params(
-        context: Module,
-        type: Type,
-        variance: Symbol,
-        bounds_proc: T.nilable(T.proc.returns(T::Hash[Symbol, T.untyped])),
-      ).void
-    end
+    #: (Module context, Type type, Symbol variance, (^-> Hash[Symbol, untyped])? bounds_proc) -> void
     def initialize(context, type, variance, bounds_proc)
       @context = context
       @type = type
@@ -151,18 +144,19 @@ module Tapioca
 
       super()
     end
-    sig { returns(T.nilable(String)) }
+
+    #: -> String?
     def name
       constant_name = super
       constant_name&.split("::")&.last
     end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def fixed?
       bounds.key?(:fixed)
     end
 
-    sig { returns(String) }
+    #: -> String
     def serialize
       fixed = bounds[:fixed].to_s if fixed?
       lower = bounds[:lower].to_s if bounds.key?(:lower)
@@ -177,14 +171,14 @@ module Tapioca
       )
     end
 
-    sig { returns(Tapioca::TypeVariable) }
+    #: -> Tapioca::TypeVariable
     def coerce_to_type_variable
       TypeVariable.new(name, @variance)
     end
 
     private
 
-    sig { returns(T::Hash[Symbol, T.untyped]) }
+    #: -> Hash[Symbol, untyped]
     def bounds
       @bounds ||= @bounds_proc.call
     end

data/lib/tapioca/sorbet_ext/name_patch.rb

@@ -5,7 +5,7 @@ module T
   module Types
     class Simple
       module NamePatch
-        NAME_METHOD = T.let(Module.instance_method(:name), UnboundMethod)
+        NAME_METHOD = Module.instance_method(:name) #: UnboundMethod
 
         def name
           # Sorbet memoizes this method into the `@name` instance variable but
@@ -16,7 +16,7 @@ module T
         def qualified_name_of(constant)
           name = NAME_METHOD.bind_call(constant)
           name = nil if name&.start_with?("#<")
-          return if name.nil?
+          return "::T.untyped" if name.nil?
 
           if name.start_with?("::")
             name

data/lib/tapioca/sorbet_ext/proc_bind_patch.rb

@@ -8,7 +8,7 @@ module T
         super(arg_types, returns)
 
         unless bind == T::Private::Methods::ARG_NOT_PROVIDED
-          @bind = T.let(T::Utils.coerce(bind), T::Types::Base)
+          @bind = T::Utils.coerce(bind) #: T::Types::Base
         end
       end
 

data/lib/tapioca/static/requires_compiler.rb

@@ -6,12 +6,12 @@ module Tapioca
     class RequiresCompiler
       extend T::Sig
 
-      sig { params(sorbet_path: String).void }
+      #: (String sorbet_path) -> void
       def initialize(sorbet_path)
         @sorbet_path = sorbet_path
       end
 
-      sig { returns(String) }
+      #: -> String
       def compile
         config = Spoom::Sorbet::Config.parse_file(@sorbet_path)
         files = collect_files(config)
@@ -25,7 +25,7 @@ module Tapioca
 
       private
 
-      sig { params(config: Spoom::Sorbet::Config).returns(T::Array[String]) }
+      #: (Spoom::Sorbet::Config config) -> Array[String]
       def collect_files(config)
         config.paths.flat_map do |path|
           path = (Pathname.new(@sorbet_path) / "../.." / path).cleanpath
@@ -40,14 +40,14 @@ module Tapioca
         end.sort.uniq
       end
 
-      sig { params(file_path: String).returns(T::Enumerable[String]) }
+      #: (String file_path) -> T::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"] }
         end.reject { |require| require.include?('#{') } # ignore interpolation
       end
 
-      sig { params(config: Spoom::Sorbet::Config, file_path: Pathname).returns(T::Boolean) }
+      #: (Spoom::Sorbet::Config config, Pathname file_path) -> bool
       def file_ignored_by_sorbet?(config, file_path)
         file_path_parts = path_parts(file_path)
 
@@ -76,7 +76,7 @@ module Tapioca
         end
       end
 
-      sig { params(path: Pathname).returns(T::Array[String]) }
+      #: (Pathname path) -> Array[String]
       def path_parts(path)
         T.unsafe(path).descend.map { |part| part.basename.to_s }
       end

data/lib/tapioca/static/symbol_loader.rb

@@ -9,17 +9,17 @@ module Tapioca
         include SorbetHelper
         include Runtime::Reflection
 
-        sig { returns(T::Set[String]) }
+        #: -> Set[String]
         def payload_symbols
           unless @payload_symbols
             output = symbol_table_json_from("-e ''", table_type: "symbol-table-full-json")
-            @payload_symbols = T.let(SymbolTableParser.parse_json(output), T.nilable(T::Set[String]))
+            @payload_symbols = SymbolTableParser.parse_json(output) #: Set[String]?
           end
 
           T.must(@payload_symbols)
         end
 
-        sig { params(gem: Gemfile::GemSpec).returns(T::Set[String]) }
+        #: (Gemfile::GemSpec gem) -> Set[String]
         def engine_symbols(gem)
           gem_engine = engines.find do |engine|
             gem.full_gem_path == engine.config.root.to_s
@@ -44,12 +44,12 @@ module Tapioca
           Set.new
         end
 
-        sig { params(gem: Gemfile::GemSpec).returns(T::Set[String]) }
+        #: (Gemfile::GemSpec gem) -> Set[String]
         def gem_symbols(gem)
           symbols_from_paths(gem.files)
         end
 
-        sig { params(paths: T::Array[Pathname]).returns(T::Set[String]) }
+        #: (Array[Pathname] paths) -> Set[String]
         def symbols_from_paths(paths)
           return Set.new if paths.empty?
 
@@ -67,20 +67,18 @@ module Tapioca
 
         private
 
-        T::Sig::WithoutRuntime.sig { returns(T::Array[T.class_of(Rails::Engine)]) }
+        # @without_runtime
+        #: -> Array[singleton(Rails::Engine)]
         def engines
-          @engines ||= T.let(
-            if Object.const_defined?("Rails::Engine")
-              descendants_of(Object.const_get("Rails::Engine"))
-                .reject(&:abstract_railtie?)
-            else
-              []
-            end,
-            T.nilable(T::Array[T.class_of(Rails::Engine)]),
-          )
+          @engines ||= if Object.const_defined?("Rails::Engine")
+            descendants_of(Object.const_get("Rails::Engine"))
+              .reject(&:abstract_railtie?)
+          else
+            []
+          end #: Array[singleton(Rails::Engine)]?
         end
 
-        sig { params(input: String, table_type: String).returns(String) }
+        #: (String input, ?table_type: String) -> String
         def symbol_table_json_from(input, table_type: "symbol-table-json")
           sorbet("--no-config", "--quiet", "--print=#{table_type}", input).out
         end

data/lib/tapioca/static/symbol_table_parser.rb

@@ -6,12 +6,12 @@ module Tapioca
     class SymbolTableParser
       extend T::Sig
 
-      SKIP_PARSE_KINDS = T.let(["CLASS_OR_MODULE", "STATIC_FIELD"].freeze, T::Array[String])
+      SKIP_PARSE_KINDS = ["CLASS_OR_MODULE", "STATIC_FIELD"].freeze #: Array[String]
 
       class << self
         extend T::Sig
 
-        sig { params(json_string: String).returns(T::Set[String]) }
+        #: (String json_string) -> Set[String]
         def parse_json(json_string)
           obj = JSON.parse(json_string)
 
@@ -23,16 +23,16 @@ module Tapioca
         end
       end
 
-      sig { returns(T::Set[String]) }
+      #: Set[String]
       attr_reader :symbols
 
-      sig { void }
+      #: -> void
       def initialize
-        @symbols = T.let(Set.new, T::Set[String])
-        @parents = T.let([], T::Array[String])
+        @symbols = Set.new #: Set[String]
+        @parents = [] #: Array[String]
       end
 
-      sig { params(object: T::Hash[String, T.untyped]).void }
+      #: (Hash[String, untyped] object) -> void
       def parse_object(object)
         children = object.fetch("children", [])
 
@@ -61,7 +61,7 @@ module Tapioca
         end
       end
 
-      sig { params(name: String).returns(String) }
+      #: (String name) -> String
       def fully_qualified_name(name)
         [*@parents, name].join("::")
       end

data/lib/tapioca/version.rb

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