tapioca 0.6.4 → 0.7.0

data/lib/tapioca/runtime/loader.rb

@@ -0,0 +1,123 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Runtime
+    class Loader
+      extend(T::Sig)
+
+      sig do
+        params(gemfile: Tapioca::Gemfile, initialize_file: T.nilable(String), require_file: T.nilable(String)).void
+      end
+      def load_bundle(gemfile, initialize_file, require_file)
+        require_helper(initialize_file)
+
+        load_rails_application
+
+        gemfile.require_bundle
+
+        require_helper(require_file)
+
+        load_rails_engines
+      end
+
+      sig { params(environment_load: T::Boolean, eager_load: T::Boolean).void }
+      def load_rails_application(environment_load: false, eager_load: false)
+        return unless File.exist?("config/application.rb")
+
+        silence_deprecations
+
+        if environment_load
+          safe_require("./config/environment")
+        else
+          safe_require("./config/application")
+        end
+
+        eager_load_rails_app if eager_load
+      end
+
+      private
+
+      sig { params(file: T.nilable(String)).void }
+      def require_helper(file)
+        return unless file
+        file = File.absolute_path(file)
+        return unless File.exist?(file)
+
+        require(file)
+      end
+
+      sig { returns(T::Array[T.untyped]) }
+      def rails_engines
+        return [] unless Object.const_defined?("Rails::Engine")
+
+        # We can use `Class#descendants` here, since we know Rails is loaded
+        Object.const_get("Rails::Engine").descendants.reject(&:abstract_railtie?)
+      end
+
+      sig { params(path: String).void }
+      def safe_require(path)
+        require path
+      rescue LoadError
+        nil
+      end
+
+      sig { void }
+      def silence_deprecations
+        # Stop any ActiveSupport Deprecations from being reported
+        Object.const_get("ActiveSupport::Deprecation").silenced = true
+      rescue NameError
+        nil
+      end
+
+      sig { void }
+      def eager_load_rails_app
+        rails = Object.const_get("Rails")
+        application = rails.application
+
+        if Object.const_defined?("ActiveSupport")
+          Object.const_get("ActiveSupport").run_load_hooks(
+            :before_eager_load,
+            application
+          )
+        end
+
+        if Object.const_defined?("Zeitwerk::Loader")
+          zeitwerk_loader = Object.const_get("Zeitwerk::Loader")
+          zeitwerk_loader.eager_load_all
+        end
+
+        if rails.respond_to?(:autoloaders) && rails.autoloaders.zeitwerk_enabled?
+          rails.autoloaders.each(&:eager_load)
+        end
+
+        if application.config.respond_to?(:eager_load_namespaces)
+          application.config.eager_load_namespaces.each(&:eager_load!)
+        end
+      end
+
+      sig { void }
+      def load_rails_engines
+        rails_engines.each do |engine|
+          errored_files = []
+
+          engine.config.eager_load_paths.each do |load_path|
+            Dir.glob("#{load_path}/**/*.rb").sort.each do |file|
+              require(file)
+            rescue LoadError, StandardError
+              errored_files << file
+            end
+          end
+
+          # Try files that have errored one more time
+          # It might have been a load order problem
+          errored_files.each do |file|
+            require(file)
+          rescue LoadError, StandardError
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/runtime/reflection.rb

@@ -0,0 +1,153 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Runtime
+    module Reflection
+      extend T::Sig
+      extend self
+
+      CLASS_METHOD = T.let(Kernel.instance_method(:class), UnboundMethod)
+      CONSTANTS_METHOD = T.let(Module.instance_method(:constants), UnboundMethod)
+      NAME_METHOD = T.let(Module.instance_method(:name), UnboundMethod)
+      SINGLETON_CLASS_METHOD = T.let(Object.instance_method(:singleton_class), UnboundMethod)
+      ANCESTORS_METHOD = T.let(Module.instance_method(:ancestors), UnboundMethod)
+      SUPERCLASS_METHOD = T.let(Class.instance_method(:superclass), UnboundMethod)
+      OBJECT_ID_METHOD = T.let(BasicObject.instance_method(:__id__), UnboundMethod)
+      EQUAL_METHOD = T.let(BasicObject.instance_method(:equal?), UnboundMethod)
+      PUBLIC_INSTANCE_METHODS_METHOD = T.let(Module.instance_method(:public_instance_methods), UnboundMethod)
+      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)
+
+      sig do
+        params(
+          symbol: String,
+          inherit: T::Boolean,
+          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
+      end
+
+      sig { params(object: BasicObject).returns(Class).checked(:never) }
+      def class_of(object)
+        CLASS_METHOD.bind(object).call
+      end
+
+      sig { params(constant: Module).returns(T::Array[Symbol]) }
+      def constants_of(constant)
+        CONSTANTS_METHOD.bind(constant).call(false)
+      end
+
+      sig { params(constant: Module).returns(T.nilable(String)) }
+      def name_of(constant)
+        name = NAME_METHOD.bind(constant).call
+        name&.start_with?("#<") ? nil : name
+      end
+
+      sig { params(constant: Module).returns(Class) }
+      def singleton_class_of(constant)
+        SINGLETON_CLASS_METHOD.bind(constant).call
+      end
+
+      sig { params(constant: Module).returns(T::Array[Module]) }
+      def ancestors_of(constant)
+        ANCESTORS_METHOD.bind(constant).call
+      end
+
+      sig { params(constant: Class).returns(T.nilable(Class)) }
+      def superclass_of(constant)
+        SUPERCLASS_METHOD.bind(constant).call
+      end
+
+      sig { params(object: BasicObject).returns(Integer).checked(:never) }
+      def object_id_of(object)
+        OBJECT_ID_METHOD.bind(object).call
+      end
+
+      sig { params(object: BasicObject, other: BasicObject).returns(T::Boolean).checked(:never) }
+      def are_equal?(object, other)
+        EQUAL_METHOD.bind(object).call(other)
+      end
+
+      sig { params(constant: Module).returns(T::Array[Symbol]) }
+      def public_instance_methods_of(constant)
+        PUBLIC_INSTANCE_METHODS_METHOD.bind(constant).call
+      end
+
+      sig { params(constant: Module).returns(T::Array[Symbol]) }
+      def protected_instance_methods_of(constant)
+        PROTECTED_INSTANCE_METHODS_METHOD.bind(constant).call
+      end
+
+      sig { params(constant: Module).returns(T::Array[Symbol]) }
+      def private_instance_methods_of(constant)
+        PRIVATE_INSTANCE_METHODS_METHOD.bind(constant).call
+      end
+
+      sig { params(constant: Module).returns(T::Array[Module]) }
+      def inherited_ancestors_of(constant)
+        if Class === constant
+          ancestors_of(superclass_of(constant) || Object)
+        else
+          Module.ancestors
+        end
+      end
+
+      sig { params(constant: Module).returns(T.nilable(String)) }
+      def qualified_name_of(constant)
+        name = name_of(constant)
+        return if name.nil?
+
+        if name.start_with?("::")
+          name
+        else
+          "::#{name}"
+        end
+      end
+
+      sig { params(method: T.any(UnboundMethod, Method)).returns(T.untyped) }
+      def signature_of(method)
+        T::Utils.signature_for_method(method)
+      rescue LoadError, StandardError
+        nil
+      end
+
+      sig { params(type: T::Types::Base).returns(String) }
+      def name_of_type(type)
+        type.to_s.gsub(/\bAttachedClass\b/, "T.attached_class")
+      end
+
+      sig { params(constant: Module, method: Symbol).returns(Method) }
+      def method_of(constant, method)
+        METHOD_METHOD.bind(constant).call(method)
+      end
+
+      # Returns an array with all classes that are < than the supplied class.
+      #
+      #   class C; end
+      #   descendants_of(C) # => []
+      #
+      #   class B < C; end
+      #   descendants_of(C) # => [B]
+      #
+      #   class A < B; end
+      #   descendants_of(C) # => [B, A]
+      #
+      #   class D < C; end
+      #   descendants_of(C) # => [B, A, D]
+      sig { type_parameters(:U).params(klass: T.type_parameter(:U)).returns(T::Array[T.type_parameter(:U)]) }
+      def descendants_of(klass)
+        result = ObjectSpace.each_object(klass.singleton_class).reject do |k|
+          T.cast(k, Module).singleton_class? || T.unsafe(k) == klass
+        end
+
+        T.unsafe(result)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# typed: true
+# frozen_string_literal: true
+
+module Tapioca
+  module Runtime
+    module Trackers
+      module Autoload
+        extend T::Sig
+
+        NOOP_METHOD = ->(*_args, **_kwargs, &_block) {}
+
+        @constant_names_registered_for_autoload = T.let([], T::Array[String])
+
+        class << self
+          extend T::Sig
+
+          sig { void }
+          def eager_load_all!
+            with_disabled_exits do
+              until @constant_names_registered_for_autoload.empty?
+                # Grab the next constant name
+                constant_name = T.must(@constant_names_registered_for_autoload.shift)
+                # Trigger autoload by constantizing the registered name
+                Reflection.constantize(constant_name, inherit: true)
+              end
+            end
+          end
+
+          sig { params(constant_name: String).void }
+          def register(constant_name)
+            @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
+          def with_disabled_exits(&block)
+            original_abort = Kernel.instance_method(:abort)
+            original_exit = Kernel.instance_method(:exit)
+
+            begin
+              Kernel.define_method(:abort, NOOP_METHOD)
+              Kernel.define_method(:exit, NOOP_METHOD)
+
+              block.call
+            ensure
+              Kernel.define_method(:exit, original_exit)
+              Kernel.define_method(:abort, original_abort)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+# We need to do the alias-method-chain dance since Bootsnap does the same,
+# and prepended modules and alias-method-chain don't play well together.
+#
+# So, why does Bootsnap do alias-method-chain and not prepend? Glad you asked!
+# That's because RubyGems does alias-method-chain for Kernel#require and such,
+# so, if Bootsnap were to do prepend, it might end up breaking RubyGems.
+class Module
+  alias_method(:autoload_without_tapioca, :autoload)
+
+  def autoload(const_name, path)
+    Tapioca::Runtime::Trackers::Autoload.register("#{self}::#{const_name}")
+    autoload_without_tapioca(const_name, path)
+  end
+end

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

@@ -0,0 +1,44 @@
+# typed: true
+# frozen_string_literal: true
+
+require "set"
+
+module Tapioca
+  module Runtime
+    module Trackers
+      # Registers a TracePoint immediately upon load to track points at which
+      # classes and modules are opened for definition. This is used to track
+      # correspondence between classes/modules and files, as this information isn't
+      # available in the ruby runtime without extra accounting.
+      module ConstantDefinition
+        extend Reflection
+
+        @class_files = {}
+
+        # Immediately activated upon load. Observes class/module definition.
+        TracePoint.trace(:class) do |tp|
+          unless tp.self.singleton_class?
+            key = name_of(tp.self)
+            file = tp.path
+            if file == "(eval)"
+              file = T.must(caller_locations)
+                .drop_while { |loc| loc.path == "(eval)" }
+                .first&.path
+            end
+            @class_files[key] ||= Set.new
+            @class_files[key] << file
+          end
+        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.
+        def self.files_for(klass)
+          name = String === klass ? klass : name_of(klass)
+          files = @class_files[name]
+          files || Set.new
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# typed: true
+# frozen_string_literal: true
+
+module Tapioca
+  module Runtime
+    module Trackers
+      module Mixin
+        extend T::Sig
+
+        @mixin_map = {}.compare_by_identity
+
+        class Type < T::Enum
+          enums do
+            Prepend = new
+            Include = new
+            Extend = new
+          end
+        end
+
+        sig do
+          params(
+            constant: Module,
+            mod: Module,
+            mixin_type: Type,
+            locations: T.nilable(T::Array[Thread::Backtrace::Location])
+          ).void
+        end
+        def self.register(constant, mod, mixin_type, locations)
+          locations ||= []
+          locations.map!(&:absolute_path).uniq!
+          locs = mixin_locations_for(constant)
+          locs.fetch(mixin_type).store(mod, T.cast(locations, T::Array[String]))
+        end
+
+        sig { params(constant: Module).returns(T::Hash[Type, T::Hash[Module, T::Array[String]]]) }
+        def self.mixin_locations_for(constant)
+          @mixin_map[constant] ||= {
+            Type::Prepend => {}.compare_by_identity,
+            Type::Include => {}.compare_by_identity,
+            Type::Extend => {}.compare_by_identity,
+          }
+        end
+      end
+    end
+  end
+end
+
+class Module
+  prepend(Module.new do
+    def prepend_features(constant)
+      Tapioca::Runtime::Trackers::Mixin.register(
+        constant,
+        self,
+        Tapioca::Runtime::Trackers::Mixin::Type::Prepend,
+        caller_locations
+      )
+      super
+    end
+
+    def append_features(constant)
+      Tapioca::Runtime::Trackers::Mixin.register(
+        constant,
+        self,
+        Tapioca::Runtime::Trackers::Mixin::Type::Include,
+        caller_locations
+      )
+      super
+    end
+
+    def extend_object(obj)
+      Tapioca::Runtime::Trackers::Mixin.register(
+        obj,
+        self,
+        Tapioca::Runtime::Trackers::Mixin::Type::Extend,
+        caller_locations
+      ) if Module === obj
+      super
+    end
+  end)
+end

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

@@ -0,0 +1,50 @@
+# typed: true
+# frozen_string_literal: true
+
+module Tapioca
+  module Runtime
+    module Trackers
+      module RequiredAncestor
+        extend T::Sig
+
+        @required_ancestors_map = {}.compare_by_identity
+
+        sig { params(requiring: T::Helpers, block: T.proc.returns(Module)).void }
+        def self.register(requiring, block)
+          ancestors = @required_ancestors_map[requiring] ||= []
+          ancestors << block
+        end
+
+        sig { params(mod: Module).returns(T::Array[T.proc.returns(Module)]) }
+        def self.required_ancestors_blocks_by(mod)
+          @required_ancestors_map[mod] || []
+        end
+
+        sig { params(mod: Module).returns(T::Array[T.nilable(Module)]) }
+        def self.required_ancestors_by(mod)
+          blocks = required_ancestors_blocks_by(mod)
+          blocks.map do |block|
+            block.call
+          rescue NameError
+            # The ancestor required doesn't exist, let's return nil and let the compiler decide what to do.
+            nil
+          end
+        end
+      end
+    end
+  end
+end
+
+module T
+  module Helpers
+    prepend(Module.new do
+      def requires_ancestor(&block)
+        # We can't directly call the block since the ancestor might not be loaded yet.
+        # We save the block in the map and will resolve it later.
+        Tapioca::Runtime::Trackers::RequiredAncestor.register(self, block)
+
+        super
+      end
+    end)
+  end
+end

data/lib/tapioca/{trackers.rb → runtime/trackers.rb}

@@ -9,6 +9,7 @@
 # catch and filter those mixins as coming from Tapioca, we need
 # the mixin tracker to be in place, before any mixin operations
 # are performed.
-require "tapioca/trackers/mixin"
-require "tapioca/trackers/constant_definition"
-require "tapioca/trackers/autoload"
+require "tapioca/runtime/trackers/mixin"
+require "tapioca/runtime/trackers/constant_definition"
+require "tapioca/runtime/trackers/autoload"
+require "tapioca/runtime/trackers/required_ancestor"

data/lib/tapioca/sorbet_ext/generic_name_patch.rb

@@ -17,7 +17,7 @@ module T
         constant = super
         # `register_type` method builds and returns an instantiated clone of the generic type
         # so, we just return that from this method as well.
-        Tapioca::GenericTypeRegistry.register_type(constant, types)
+        Tapioca::Runtime::GenericTypeRegistry.register_type(constant, types)
       end
 
       def type_member(variance = :invariant, fixed: nil, lower: T.untyped, upper: BasicObject)
@@ -31,7 +31,7 @@ module T
           lower,
           upper
         ).tap do |type_variable|
-          Tapioca::GenericTypeRegistry.register_type_variable(self, type_variable)
+          Tapioca::Runtime::GenericTypeRegistry.register_type_variable(self, type_variable)
         end
       end
 
@@ -46,7 +46,7 @@ module T
           lower,
           upper
         ).tap do |type_variable|
-          Tapioca::GenericTypeRegistry.register_type_variable(self, type_variable)
+          Tapioca::Runtime::GenericTypeRegistry.register_type_variable(self, type_variable)
         end
       end
     end
@@ -57,18 +57,6 @@ module T
   module Types
     class Simple
       module GenericPatch
-        def valid?(obj)
-          # Since `Tapioca::TypeVariable` is a `Module`, it will be wrapped by a
-          # `Simple` type. We want to always make type variable types valid, so we
-          # need to explicitly check that `raw_type` is a `Tapioca::TypeVariable`
-          # and return `true`
-          if defined?(Tapioca::TypeVariableModule) && Tapioca::TypeVariableModule === @raw_type
-            return true
-          end
-
-          obj.is_a?(@raw_type)
-        end
-
         # This method intercepts calls to the `name` method for simple types, so that
         # it can ask the name to the type if the type is generic, since, by this point,
         # we've created a clone of that type with the `name` method returning the
@@ -88,9 +76,34 @@ module T
       prepend GenericPatch
     end
   end
+
+  module Utils
+    module CoercePatch
+      def coerce(val)
+        if val.is_a?(Tapioca::TypeVariableModule)
+          val.coerce_to_type_variable
+        else
+          super
+        end
+      end
+    end
+
+    class << self
+      prepend(CoercePatch)
+    end
+  end
 end
 
 module Tapioca
+  class TypeVariable < ::T::Types::TypeVariable
+    def initialize(name, variance)
+      @name = name
+      super(variance)
+    end
+
+    attr_reader :name
+  end
+
   # This is subclassing from `Module` so that instances of this type will be modules.
   # The reason why we want that is because that means those instances will automatically
   # get bound to the constant names they are assigned to by Ruby. As a result, we don't
@@ -153,6 +166,11 @@ module Tapioca
       serialized
     end
 
+    sig { returns(Tapioca::TypeVariable) }
+    def coerce_to_type_variable
+      TypeVariable.new(name, @variance)
+    end
+
     private
 
     sig do

data/lib/tapioca/sorbet_ext/name_patch.rb

@@ -1,12 +1,18 @@
 # typed: true
 # frozen_string_literal: true
 
+# We need sorbet to compile the signature for `qualified_name_of` before applying
+# the patch to avoid an infinite loop.
+T::Utils.signature_for_method(::Tapioca::Runtime::Reflection.method(:qualified_name_of))
+
 module T
   module Types
     class Simple
       module NamePatch
         def name
-          @name ||= ::Tapioca::Reflection.name_of(@raw_type).freeze
+          # Sorbet memoizes this method into the `@name` instance variable but
+          # doing so means that types get memoized before this patch is applied
+          ::Tapioca::Runtime::Reflection.qualified_name_of(@raw_type)
         end
       end
 

data/lib/tapioca/{compilers → static}/requires_compiler.rb

@@ -4,7 +4,7 @@
 require "spoom"
 
 module Tapioca
-  module Compilers
+  module Static
     class RequiresCompiler
       extend T::Sig
 
@@ -17,7 +17,7 @@ module Tapioca
       def compile
         config = Spoom::Sorbet::Config.parse_file(@sorbet_path)
         files = collect_files(config)
-        names_in_project = files.map { |file| [File.basename(file, ".rb"), true] }.to_h
+        names_in_project = files.to_h { |file| [File.basename(file, ".rb"), true] }
         files.flat_map do |file|
           collect_requires(file).reject { |req| names_in_project[req] }
         end.sort.uniq.map do |name|