tapioca 0.10.1 → 0.10.2

data/lib/tapioca/gemfile.rb

@@ -8,7 +8,7 @@ module Tapioca
     Spec = T.type_alias do
       T.any(
         ::Bundler::StubSpecification,
-        ::Gem::Specification
+        ::Gem::Specification,
       )
     end
 
@@ -147,7 +147,7 @@ module Tapioca
               .flat_map do |spec|
                 spec.files.filter_map { |file| [file.realpath.to_s, spec] if file.exist? }
               end.to_h,
-            T.nilable(T::Hash[String, Gemfile::GemSpec])
+            T.nilable(T::Hash[String, Gemfile::GemSpec]),
           )
         end
       end
@@ -157,7 +157,7 @@ module Tapioca
           "sorbet", "sorbet-static", "sorbet-runtime", "sorbet-static-and-runtime",
           "debug", "fakefs",
         ].freeze,
-        T::Array[String]
+        T::Array[String],
       )
 
       sig { returns(String) }
@@ -201,7 +201,7 @@ module Tapioca
         if default_gem?
           files.any? { |file| file.to_s == to_realpath(path) }
         else
-          to_realpath(path).start_with?(full_gem_path) || has_parent_gemspec?(path)
+          path_in_dir?(to_realpath(path), full_gem_path) || has_parent_gemspec?(path)
         end
       end
 

data/lib/tapioca/helpers/config_helper.rb

@@ -96,7 +96,7 @@ module Tapioca
       params(
         command_options: T::Hash[Symbol, Thor::Option],
         config_key: String,
-        config_options: T::Hash[T.untyped, T.untyped]
+        config_options: T::Hash[T.untyped, T.untyped],
       ).returns(T::Array[ConfigError])
     end
     def validate_config_options(command_options, config_key, config_options)
@@ -157,18 +157,18 @@ module Tapioca
         if match
           ConfigErrorMessagePart.new(
             message: "#{match[1]}#{match[2]}",
-            colors: [:bold, :blue]
+            colors: [:bold, :blue],
           )
         else
           ConfigErrorMessagePart.new(
             message: part,
-            colors: [:yellow]
+            colors: [:yellow],
           )
         end
       end
 
       ConfigError.new(
-        message_parts: message_parts
+        message_parts: message_parts,
       )
     end
 

data/lib/tapioca/helpers/env_helper.rb

@@ -11,6 +11,7 @@ module Tapioca
     sig { params(options: T::Hash[Symbol, T.untyped]).void }
     def set_environment(options) # rubocop:disable Naming/AccessorMethodName
       ENV["RAILS_ENV"] = ENV["RACK_ENV"] = options[:environment]
+      ENV["RUBY_DEBUG_ENABLE"] = "0"
     end
   end
 end

data/lib/tapioca/helpers/gem_helper.rb

@@ -5,15 +5,17 @@ module Tapioca
   module GemHelper
     extend T::Sig
 
-    sig { params(gemfile_dir: String, full_gem_path: String).returns(T::Boolean) }
-    def gem_in_app_dir?(gemfile_dir, full_gem_path)
-      !gem_in_bundle_path?(to_realpath(full_gem_path)) &&
-        full_gem_path.start_with?(to_realpath(gemfile_dir))
+    sig { params(app_dir: String, full_gem_path: String).returns(T::Boolean) }
+    def gem_in_app_dir?(app_dir, full_gem_path)
+      app_dir = to_realpath(app_dir)
+      full_gem_path = to_realpath(full_gem_path)
+
+      !gem_in_bundle_path?(full_gem_path) && path_in_dir?(full_gem_path, app_dir)
     end
 
     sig { params(full_gem_path: String).returns(T::Boolean) }
     def gem_in_bundle_path?(full_gem_path)
-      full_gem_path.start_with?(Bundler.bundle_path.to_s, Bundler.app_cache.to_s)
+      path_in_dir?(full_gem_path, Bundler.bundle_path) || path_in_dir?(full_gem_path, Bundler.app_cache)
     end
 
     sig { params(path: T.any(String, Pathname)).returns(String) }
@@ -22,5 +24,15 @@ module Tapioca
       path_string = File.realpath(path_string) if File.exist?(path_string)
       path_string
     end
+
+    private
+
+    sig { params(path: T.any(Pathname, String), dir: T.any(Pathname, String)).returns(T::Boolean) }
+    def path_in_dir?(path, dir)
+      dir = Pathname.new(dir)
+      path = Pathname.new(path)
+
+      path.ascend.any?(dir)
+    end
   end
 end

data/lib/tapioca/helpers/rbi_files_helper.rb

@@ -42,7 +42,7 @@ module Tapioca
       params(
         index: RBI::Index,
         shim_rbi_dir: String,
-        todo_rbi_file: String
+        todo_rbi_file: String,
       ).returns(T::Hash[String, T::Array[RBI::Node]])
     end
     def duplicated_nodes_from_index(index, shim_rbi_dir:, todo_rbi_file:)
@@ -80,7 +80,7 @@ module Tapioca
         dsl_dir: String,
         auto_strictness: T::Boolean,
         gems: T::Array[Gemfile::GemSpec],
-        compilers: T::Enumerable[Class]
+        compilers: T::Enumerable[Class],
       ).void
     end
     def validate_rbi_files(command:, gem_dir:, dsl_dir:, auto_strictness:, gems: [], compilers: [])
@@ -92,7 +92,7 @@ module Tapioca
         "--error-url-base=#{error_url_base}",
         "--stop-after namer",
         dsl_dir,
-        gem_dir
+        gem_dir,
       )
       say(" Done", :green)
 

data/lib/tapioca/helpers/rbi_helper.rb

@@ -17,7 +17,7 @@ module Tapioca
           variance: Symbol,
           fixed: T.nilable(String),
           upper: T.nilable(String),
-          lower: T.nilable(String)
+          lower: T.nilable(String),
         ).returns(String)
       end
       def serialize_type_variable(type, variance, fixed, upper, lower)

data/lib/tapioca/helpers/sorbet_helper.rb

@@ -7,12 +7,12 @@ module Tapioca
 
     SORBET_GEM_SPEC = T.let(
       ::Gem::Specification.find_by_name("sorbet-static"),
-      ::Gem::Specification
+      ::Gem::Specification,
     )
 
     SORBET_BIN = T.let(
       Pathname.new(SORBET_GEM_SPEC.full_gem_path) / "libexec" / "sorbet",
-      Pathname
+      Pathname,
     )
 
     SORBET_EXE_PATH_ENV_VAR = "TAPIOCA_SORBET_EXE"

data/lib/tapioca/helpers/source_uri.rb

@@ -29,7 +29,7 @@ module URI
           gem_name: String,
           gem_version: T.nilable(String),
           path: String,
-          line_number: T.nilable(String)
+          line_number: T.nilable(String),
         ).returns(URI::Source)
       end
       def build(gem_name:, gem_version:, path:, line_number:)

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

@@ -109,7 +109,7 @@ module Tapioca
           def pipeline
             @pipeline ||= Tapioca::Dsl::Pipeline.new(
               requested_constants: [],
-              requested_compilers: activated_compiler_classes
+              requested_compilers: activated_compiler_classes,
             )
           end
         end

data/lib/tapioca/loaders/dsl.rb

@@ -63,7 +63,7 @@ module Tapioca
 
         load_rails_application(
           environment_load: true,
-          eager_load: @eager_load
+          eager_load: @eager_load,
         )
 
         say("Done", :green)

data/lib/tapioca/loaders/gem.rb

@@ -14,7 +14,7 @@ module Tapioca
             bundle: Gemfile,
             prerequire: T.nilable(String),
             postrequire: String,
-            default_command: String
+            default_command: String,
           ).void
         end
         def load_application(bundle:, prerequire:, postrequire:, default_command:)
@@ -38,7 +38,7 @@ module Tapioca
           bundle: Gemfile,
           prerequire: T.nilable(String),
           postrequire: String,
-          default_command: String
+          default_command: String,
         ).void
       end
       def initialize(bundle:, prerequire:, postrequire:, default_command:)

data/lib/tapioca/loaders/loader.rb

@@ -113,7 +113,7 @@ module Tapioca
         if Object.const_defined?("ActiveSupport")
           Object.const_get("ActiveSupport").run_load_hooks(
             :before_eager_load,
-            application
+            application,
           )
         end
 

data/lib/tapioca/rbi_ext/model.rb

@@ -32,7 +32,7 @@ module RBI
       params(
         name: String,
         superclass_name: T.nilable(String),
-        block: T.nilable(T.proc.params(scope: RBI::Scope).void)
+        block: T.nilable(T.proc.params(scope: RBI::Scope).void),
       ).returns(Scope)
     end
     def create_class(name, superclass_name: nil, &block)
@@ -68,7 +68,7 @@ module RBI
         variance: Symbol,
         fixed: T.nilable(String),
         upper: T.nilable(String),
-        lower: T.nilable(String)
+        lower: T.nilable(String),
       ).void
     end
     def create_type_variable(name, type:, variance: :invariant, fixed: nil, upper: nil, lower: nil)
@@ -82,7 +82,7 @@ module RBI
         parameters: T::Array[TypedParam],
         return_type: String,
         class_method: T::Boolean,
-        visibility: RBI::Visibility
+        visibility: RBI::Visibility,
       ).void
     end
     def create_method(name, parameters: [], return_type: "T.untyped", class_method: false, visibility: RBI::Public.new)

data/lib/tapioca/rbi_formatter.rb

@@ -9,7 +9,7 @@ module Tapioca
       params(
         file: RBI::File,
         command: String,
-        reason: T.nilable(String)
+        reason: T.nilable(String),
       ).void
     end
     def write_header!(file, command, reason: nil)
@@ -32,6 +32,6 @@ module Tapioca
     max_line_length: nil,
     nest_singleton_methods: true,
     nest_non_public_methods: true,
-    sort_nodes: true
+    sort_nodes: true,
   ), RBIFormatter)
 end

data/lib/tapioca/runtime/generic_type_registry.rb

@@ -23,14 +23,30 @@ module Tapioca
     module GenericTypeRegistry
       @generic_instances = T.let(
         {},
-        T::Hash[String, Module]
+        T::Hash[String, Module],
       )
 
       @type_variables = T.let(
         {}.compare_by_identity,
-        T::Hash[Module, T::Array[TypeVariableModule]]
+        T::Hash[Module, T::Array[TypeVariableModule]],
       )
 
+      class GenericType < T::Types::Simple
+        extend T::Sig
+
+        sig { params(raw_type: Module, underlying_type: Module).void }
+        def initialize(raw_type, underlying_type)
+          super(raw_type)
+
+          @underlying_type = T.let(underlying_type, Module)
+        end
+
+        sig { params(obj: T.untyped).returns(T::Boolean) }
+        def valid?(obj)
+          obj.is_a?(@underlying_type)
+        end
+      end
+
       class << self
         extend T::Sig
 
@@ -116,6 +132,10 @@ module Tapioca
           generic_type.define_singleton_method(:name, name_proc)
           generic_type.define_singleton_method(:to_s, name_proc)
 
+          override_type = GenericType.new(generic_type, constant)
+          override_type_proc = -> { override_type }
+          generic_type.define_singleton_method(:__tapioca_override_type, override_type_proc)
+
           # We need to define a `<=` method on the cloned constant, so that Sorbet
           # can do covariance/contravariance checks on the type variables.
           #

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) }

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