tapioca 0.10.1 → 0.10.3

data/lib/tapioca/runtime/reflection.rb

@@ -19,20 +19,26 @@ module Tapioca
       PROTECTED_INSTANCE_METHODS_METHOD = T.let(Module.instance_method(:protected_instance_methods), UnboundMethod)
       PRIVATE_INSTANCE_METHODS_METHOD = T.let(Module.instance_method(:private_instance_methods), UnboundMethod)
       METHOD_METHOD = T.let(Kernel.instance_method(:method), UnboundMethod)
+      UNDEFINED_CONSTANT = T.let(Module.new.freeze, Module)
 
       REQUIRED_FROM_LABELS = T.let(["<top (required)>", "<main>"].freeze, T::Array[String])
 
+      T::Sig::WithoutRuntime.sig { params(constant: BasicObject).returns(T::Boolean) }
+      def constant_defined?(constant)
+        !UNDEFINED_CONSTANT.eql?(constant)
+      end
+
       sig do
         params(
           symbol: String,
           inherit: T::Boolean,
-          namespace: Module
+          namespace: Module,
         ).returns(BasicObject).checked(:never)
       end
       def constantize(symbol, inherit: false, namespace: Object)
         namespace.const_get(symbol, inherit)
       rescue NameError, LoadError, RuntimeError, ArgumentError, TypeError
-        nil
+        UNDEFINED_CONSTANT
       end
 
       sig { params(object: BasicObject).returns(Class).checked(:never) }
@@ -177,6 +183,61 @@ module Tapioca
 
         T.cast(result, Module)
       end
+
+      sig { params(constant: Module).returns(T::Set[String]) }
+      def file_candidates_for(constant)
+        relevant_methods_for(constant).filter_map do |method|
+          method.source_location&.first
+        end.to_set
+      end
+
+      private
+
+      sig { params(constant: Module).returns(T::Array[UnboundMethod]) }
+      def relevant_methods_for(constant)
+        methods = methods_for(constant).select(&:source_location)
+          .reject { |x| method_defined_by_forwardable_module?(x) }
+
+        return methods unless methods.empty?
+
+        constants_of(constant).flat_map do |const_name|
+          if (mod = child_module_for_parent_with_name(constant, const_name.to_s))
+            relevant_methods_for(mod)
+          else
+            []
+          end
+        end
+      end
+
+      sig { params(constant: Module).returns(T::Array[UnboundMethod]) }
+      def methods_for(constant)
+        modules = [constant, singleton_class_of(constant)]
+        method_list_methods = [
+          PUBLIC_INSTANCE_METHODS_METHOD,
+          PROTECTED_INSTANCE_METHODS_METHOD,
+          PRIVATE_INSTANCE_METHODS_METHOD,
+        ]
+
+        modules.product(method_list_methods).flat_map do |mod, method_list_method|
+          method_list_method.bind_call(mod, false).map { |name| mod.instance_method(name) }
+        end
+      end
+
+      sig { params(parent: Module, name: String).returns(T.nilable(Module)) }
+      def child_module_for_parent_with_name(parent, name)
+        return if parent.autoload?(name)
+
+        child = constantize(name, inherit: true, namespace: parent)
+        return unless Module === child
+        return unless name_of(child) == "#{name_of(parent)}::#{name}"
+
+        child
+      end
+
+      sig { params(method: UnboundMethod).returns(T::Boolean) }
+      def method_defined_by_forwardable_module?(method)
+        method.source_location&.first == Object.const_source_location(:Forwardable)&.first
+      end
     end
   end
 end

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

@@ -5,6 +5,7 @@ module Tapioca
   module Runtime
     module Trackers
       module Autoload
+        extend Tracker
         extend T::Sig
 
         NOOP_METHOD = ->(*_args, **_kwargs, &_block) {}
@@ -28,6 +29,8 @@ module Tapioca
 
           sig { params(constant_name: String).void }
           def register(constant_name)
+            return unless enabled?
+
             @constant_names_registered_for_autoload << constant_name
           end
 

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

@@ -9,6 +9,7 @@ module Tapioca
       # correspondence between classes/modules and files, as this information isn't
       # available in the ruby runtime without extra accounting.
       module ConstantDefinition
+        extend Tracker
         extend Reflection
         extend T::Sig
 
@@ -20,7 +21,7 @@ module Tapioca
         @class_files = {}.compare_by_identity
 
         # Immediately activated upon load. Observes class/module definition.
-        Tapioca.register_trace(:class) do |tp|
+        @class_tracepoint = TracePoint.trace(:class) do |tp|
           next if tp.self.singleton_class?
 
           key = tp.self
@@ -40,19 +41,26 @@ module Tapioca
           (@class_files[key] ||= Set.new) << loc
         end
 
-        Tapioca.register_trace(:c_return) do |tp|
+        @creturn_tracepoint = TracePoint.trace(:c_return) do |tp|
           next unless tp.method_id == :new
-          next unless Module === tp.return_value
 
           key = tp.return_value
+          next unless Module === key
+
           loc = build_constant_location(tp, caller_locations)
           (@class_files[key] ||= Set.new) << loc
         end
 
         class << self
+          def disable!
+            @class_tracepoint.disable
+            @creturn_tracepoint.disable
+            super
+          end
+
           def build_constant_location(tp, locations)
-            file = resolve_loc(caller_locations)
-            lineno = file == File.realpath(tp.path) ? tp.lineno : 0
+            file = resolve_loc(locations)
+            lineno = File.identical?(file, tp.path) ? tp.lineno : 0
 
             ConstantLocation.new(path: file, lineno: lineno)
           end

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

@@ -5,11 +5,11 @@ module Tapioca
   module Runtime
     module Trackers
       module Mixin
+        extend Tracker
         extend T::Sig
 
         @constants_to_mixin_locations = {}.compare_by_identity
         @mixins_to_constants = {}.compare_by_identity
-        @enabled = true
 
         class Type < T::Enum
           enums do
@@ -28,31 +28,52 @@ module Tapioca
               .returns(T.type_parameter(:Result))
           end
           def with_disabled_registration(&block)
-            @enabled = false
-
-            block.call
-          ensure
-            @enabled = true
+            with_disabled_tracker(&block)
           end
 
-          sig do
-            params(
-              constant: Module,
-              mixin: Module,
-              mixin_type: Type,
-            ).void
-          end
+          sig { params(constant: Module, mixin: Module, mixin_type: Type).void }
           def register(constant, mixin, mixin_type)
-            return unless @enabled
+            return unless enabled?
 
             location = Reflection.resolve_loc(caller_locations)
 
-            constants = constants_with_mixin(mixin)
-            constants.fetch(mixin_type).store(constant, location)
+            register_with_location(constant, mixin, mixin_type, location)
+          end
+
+          def resolve_to_attached_class(constant, mixin, mixin_type)
+            attached_class = Reflection.attached_class_of(constant)
+            return unless attached_class
+
+            if mixin_type == Type::Include || mixin_type == Type::Prepend
+              location = mixin_location(mixin, mixin_type, constant)
+              register_with_location(constant, mixin, Type::Extend, T.must(location))
+            end
+
+            attached_class
           end
 
           sig { params(mixin: Module).returns(T::Hash[Type, T::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)) }
+          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 }
+          def register_with_location(constant, mixin, mixin_type, location)
+            return unless @enabled
+
+            constants = find_or_initialize_mixin_lookup(mixin)
+            constants.fetch(mixin_type).store(constant, location)
+          end
+
+          sig { params(mixin: Module).returns(T::Hash[Type, T::Hash[Module, String]]) }
+          def find_or_initialize_mixin_lookup(mixin)
             @mixins_to_constants[mixin] ||= {
               Type::Prepend => {}.compare_by_identity,
               Type::Include => {}.compare_by_identity,
@@ -74,8 +95,6 @@ class Module
         Tapioca::Runtime::Trackers::Mixin::Type::Prepend,
       )
 
-      register_extend_on_attached_class(constant) if constant.singleton_class?
-
       super
     end
 
@@ -86,8 +105,6 @@ class Module
         Tapioca::Runtime::Trackers::Mixin::Type::Include,
       )
 
-      register_extend_on_attached_class(constant) if constant.singleton_class?
-
       super
     end
 
@@ -99,21 +116,5 @@ class Module
       ) if Module === obj
       super
     end
-
-    private
-
-    # Including or prepending on a singleton class is functionally equivalent to extending the
-    # attached class. Registering the mixin as an extend on the attached class ensures that
-    # this mixin can be found whether searching for an include/prepend on the singleton class
-    # or an extend on the attached class.
-    def register_extend_on_attached_class(constant)
-      attached_class = Tapioca::Runtime::Reflection.attached_class_of(constant)
-
-      Tapioca::Runtime::Trackers::Mixin.register(
-        T.cast(attached_class, Module),
-        self,
-        Tapioca::Runtime::Trackers::Mixin::Type::Extend,
-      ) if attached_class
-    end
   end)
 end

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

@@ -5,27 +5,40 @@ module Tapioca
   module Runtime
     module Trackers
       module RequiredAncestor
+        extend Tracker
         @required_ancestors_map = {}.compare_by_identity
 
         class << self
           extend T::Sig
 
-          sig { params(requiring: T::Helpers, block: T.proc.returns(Module)).void }
+          sig { params(requiring: T::Helpers, block: T.proc.void).void }
           def register(requiring, block)
+            return unless enabled?
+
             ancestors = @required_ancestors_map[requiring] ||= []
             ancestors << block
           end
 
-          sig { params(mod: Module).returns(T::Array[T.proc.returns(Module)]) }
+          sig { params(mod: Module).returns(T::Array[T.proc.void]) }
           def required_ancestors_blocks_by(mod)
             @required_ancestors_map[mod] || []
           end
 
-          sig { params(mod: Module).returns(T::Array[T.nilable(Module)]) }
+          sig { params(mod: Module).returns(T::Array[T.untyped]) }
           def required_ancestors_by(mod)
             blocks = required_ancestors_blocks_by(mod)
             blocks.map do |block|
-              block.call
+              # Common return values of `block.call` here could be a Module or a Sorbet's runtime value for T.class.
+              # But in reality it could be whatever the block has that can pass Sorbet's static check. Like
+              #
+              # ```
+              # requires_ancestor { T.class_of(Foo); nil }
+              # ```
+              #
+              # So it's not designed to be used at runtime and it's accidental that just calling `to_s` on the above
+              # common values can get us the correct value to generate type signatures. (See SorbetRequiredAncestors)
+              # Therefore, the return value `block.call` should be considered unreliable and treated with caution.
+              T.unsafe(block.call)
             rescue NameError
               # The ancestor required doesn't exist, let's return nil and let the compiler decide what to do.
               nil

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

@@ -0,0 +1,45 @@
+# typed: true
+# frozen_string_literal: true
+
+module Tapioca
+  module Runtime
+    module Trackers
+      module Tracker
+        extend T::Sig
+        extend T::Helpers
+
+        abstract!
+
+        class << self
+          extend T::Sig
+
+          sig { params(base: T.all(Tracker, Module)).void }
+          def extended(base)
+            Trackers.register_tracker(base)
+            base.instance_exec do
+              @enabled = true
+            end
+          end
+        end
+
+        sig { void }
+        def disable!
+          @enabled = false
+        end
+
+        def enabled?
+          @enabled
+        end
+
+        def with_disabled_tracker(&block)
+          original_state = @enabled
+          @enabled = false
+
+          block.call
+        ensure
+          @enabled = original_state
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/runtime/trackers.rb

@@ -1,6 +1,32 @@
-# typed: strict
+# typed: true
 # frozen_string_literal: true
 
+require "tapioca/runtime/trackers/tracker"
+
+module Tapioca
+  module Runtime
+    module Trackers
+      extend T::Sig
+
+      @trackers = T.let([], T::Array[Tracker])
+
+      class << self
+        extend T::Sig
+
+        sig { void }
+        def disable_all!
+          @trackers.each(&:disable!)
+        end
+
+        sig { params(tracker: Tracker).void }
+        def register_tracker(tracker)
+          @trackers << tracker
+        end
+      end
+    end
+  end
+end
+
 # The load order below is important:
 # ----------------------------------
 # We want the mixin tracker to be the first thing that is

data/lib/tapioca/sorbet_ext/generic_name_patch.rb

@@ -28,7 +28,7 @@ module T
           fixed,
           lower,
           upper,
-          bounds_proc
+          bounds_proc,
         ).tap do |type_variable|
           Tapioca::Runtime::GenericTypeRegistry.register_type_variable(self, type_variable)
         end
@@ -44,7 +44,7 @@ module T
           fixed,
           lower,
           upper,
-          bounds_proc
+          bounds_proc,
         ).tap do |type_variable|
           Tapioca::Runtime::GenericTypeRegistry.register_type_variable(self, type_variable)
         end
@@ -82,6 +82,8 @@ module T
       def coerce(val)
         if val.is_a?(Tapioca::TypeVariableModule)
           val.coerce_to_type_variable
+        elsif val.respond_to?(:__tapioca_override_type)
+          val.__tapioca_override_type
         else
           super
         end
@@ -128,7 +130,7 @@ module Tapioca
         fixed: T.untyped,
         lower: T.untyped,
         upper: T.untyped,
-        bounds_proc: T.nilable(T.proc.returns(T::Hash[Symbol, T.untyped]))
+        bounds_proc: T.nilable(T.proc.returns(T::Hash[Symbol, T.untyped])),
       ).void
     end
     def initialize(context, type, variance, fixed, lower, upper, bounds_proc)
@@ -164,10 +166,14 @@ module Tapioca
       constant_name&.split("::")&.last
     end
 
+    sig { returns(T::Boolean) }
+    def fixed?
+      bounds.key?(:fixed)
+    end
+
     sig { returns(String) }
     def serialize
-      bounds = @bounds_proc.call
-      fixed = bounds[:fixed].to_s if bounds.key?(:fixed)
+      fixed = bounds[:fixed].to_s if fixed?
       lower = bounds[:lower].to_s if bounds.key?(:lower)
       upper = bounds[:upper].to_s if bounds.key?(:upper)
 
@@ -176,7 +182,7 @@ module Tapioca
         @variance,
         fixed,
         upper,
-        lower
+        lower,
       )
     end
 
@@ -213,5 +219,10 @@ module Tapioca
     ensure
       self.class.send(:remove_const, temp_name) if temp_name
     end
+
+    sig { returns(T::Hash[Symbol, T.untyped]) }
+    def bounds
+      @bounds ||= @bounds_proc.call
+    end
   end
 end

data/lib/tapioca/static/symbol_loader.rb

@@ -62,14 +62,14 @@ module Tapioca
 
         sig { params(paths: T::Array[Pathname]).returns(T::Set[String]) }
         def symbols_from_paths(paths)
-          output = T.cast(Tempfile.create("sorbet") do |file|
+          output = Tempfile.create("sorbet") do |file|
             file.write(Array(paths).join("\n"))
             file.flush
 
             symbol_table_json_from("@#{file.path.shellescape}")
-          end, T.nilable(String))
+          end
 
-          return Set.new if output.nil? || output.empty?
+          return Set.new if output.empty?
 
           SymbolTableParser.parse_json(output)
         end

data/lib/tapioca/static/symbol_table_parser.rb

@@ -43,6 +43,12 @@ module Tapioca
 
           next if name.nil?
           next unless SKIP_PARSE_KINDS.include?(kind)
+
+          # Turn singleton class names to attached class names
+          if (match_data = name.match(/<Class:(.*)>/))
+            name = match_data[1]
+          end
+
           next if name.match?(/[<>()$]/)
           next if name.match?(/^[0-9]+$/)
           next if name == "T::Helpers"

data/lib/tapioca/version.rb

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

data/lib/tapioca.rb

@@ -11,16 +11,6 @@ module Tapioca
   class << self
     extend T::Sig
 
-    sig { params(trace_name: Symbol, block: T.proc.params(arg0: TracePoint).void).void }
-    def register_trace(trace_name, &block)
-      @traces << TracePoint.trace(trace_name, &block)
-    end
-
-    sig { void }
-    def disable_traces
-      @traces.each(&:disable)
-    end
-
     sig do
       type_parameters(:Result)
         .params(blk: T.proc.returns(T.type_parameter(:Result)))

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.10.1
+  version: 0.10.3
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-09-14 00:00:00.000000000 Z
+date: 2022-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -55,20 +55,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.21.0
-- !ruby/object:Gem::Dependency
-  name: pry
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.12.2
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.12.2
 - !ruby/object:Gem::Dependency
   name: rbi
   requirement: !ruby/object:Gem::Requirement
@@ -78,7 +64,7 @@ dependencies:
         version: 0.0.0
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.14
+        version: 0.0.16
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -88,21 +74,21 @@ dependencies:
         version: 0.0.0
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.14
+        version: 0.0.16
 - !ruby/object:Gem::Dependency
   name: sorbet-static-and-runtime
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.9204
+        version: 0.5.9892
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.9204
+        version: 0.5.9892
 - !ruby/object:Gem::Dependency
   name: spoom
   requirement: !ruby/object:Gem::Requirement
@@ -168,6 +154,7 @@ files:
 - lib/tapioca/commands/annotations.rb
 - lib/tapioca/commands/check_shims.rb
 - lib/tapioca/commands/command.rb
+- lib/tapioca/commands/command_without_tracker.rb
 - lib/tapioca/commands/configure.rb
 - lib/tapioca/commands/dsl.rb
 - lib/tapioca/commands/gem.rb
@@ -258,6 +245,7 @@ files:
 - lib/tapioca/runtime/trackers/constant_definition.rb
 - lib/tapioca/runtime/trackers/mixin.rb
 - lib/tapioca/runtime/trackers/required_ancestor.rb
+- lib/tapioca/runtime/trackers/tracker.rb
 - lib/tapioca/sorbet_ext/fixed_hash_patch.rb
 - lib/tapioca/sorbet_ext/generic_name_patch.rb
 - lib/tapioca/sorbet_ext/name_patch.rb