tapioca 0.6.1 → 0.7.0

data/lib/tapioca/runtime/generic_type_registry.rb

@@ -0,0 +1,166 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Runtime
+    # This class is responsible for storing and looking up information related to generic types.
+    #
+    # The class stores 2 different kinds of data, in two separate lookup tables:
+    #   1. a lookup of generic type instances by name: `@generic_instances`
+    #   2. a lookup of type variable serializer by constant and type variable
+    #      instance: `@type_variables`
+    #
+    # By storing the above data, we can cheaply query each constant against this registry
+    # to see if it declares any generic type variables. This becomes a simple lookup in the
+    # `@type_variables` hash table with the given constant.
+    #
+    # If there is no entry, then we can cheaply know that we can skip generic type
+    # information generation for this type.
+    #
+    # On the other hand, if we get a result, then the result will be a hash of type
+    # variable to type variable serializers. This allows us to associate type variables
+    # to the constant names that represent them, easily.
+    module GenericTypeRegistry
+      @generic_instances = T.let(
+        {},
+        T::Hash[String, Module]
+      )
+
+      @type_variables = T.let(
+        {}.compare_by_identity,
+        T::Hash[Module, T::Array[TypeVariableModule]]
+      )
+
+      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.
+        #
+        # We cache those cloned instances by their name in `@generic_instances`, so that
+        # we don't keep instantiating a new type every single time it is referenced.
+        # For example, `[Foo[Integer], Foo[Integer], Foo[Integer], Foo[String]]` will only
+        # result in 2 clones (1 for `Foo[Integer]` and another for `Foo[String]`) and
+        # 2 hash lookups (for the other two `Foo[Integer]`s).
+        #
+        # This method returns the created or cached clone of the constant.
+        sig { params(constant: T.untyped, types: T.untyped).returns(Module) }
+        def register_type(constant, types)
+          # Build the name of the instantiated generic type,
+          # something like `"Foo[X, Y, Z]"`
+          type_list = types.map { |type| T::Utils.coerce(type).name }.join(", ")
+          name = "#{Reflection.name_of(constant)}[#{type_list}]"
+
+          # Create a generic type with an overridden `name`
+          # method that returns the name we constructed above.
+          #
+          # Also, we try to memoize the generic type based on the name, so that
+          # we don't have to keep recreating them all the time.
+          @generic_instances[name] ||= create_generic_type(constant, name)
+        end
+
+        sig { params(instance: Object).returns(T::Boolean) }
+        def generic_type_instance?(instance)
+          @generic_instances.values.any? { |generic_type| generic_type === instance }
+        end
+
+        sig { params(constant: Module).returns(T.nilable(T::Array[TypeVariableModule])) }
+        def lookup_type_variables(constant)
+          @type_variables[constant]
+        end
+
+        # This method is called from intercepted calls to `type_member` and `type_template`.
+        # We get passed all the arguments to those methods, as well as the `T::Types::TypeVariable`
+        # instance generated by the Sorbet defined `type_member`/`type_template` call on `T::Generic`.
+        #
+        # This method creates a `String` with that data and stores it in the
+        # `@type_variables` lookup table, keyed by the `constant` and `type_variable`.
+        #
+        # Finally, the original `type_variable` is returned from this method, so that the caller
+        # can return it from the original methods as well.
+        sig do
+          params(
+            constant: T.untyped,
+            type_variable: TypeVariableModule,
+          ).void
+        end
+        def register_type_variable(constant, type_variable)
+          type_variables = lookup_or_initialize_type_variables(constant)
+
+          type_variables << type_variable
+        end
+
+        private
+
+        sig { params(constant: Module, name: String).returns(Module) }
+        def create_generic_type(constant, name)
+          generic_type = case constant
+          when Class
+            # For classes, we want to create a subclass, so that an instance of
+            # the generic class `Foo[Bar]` is still a `Foo`. That is:
+            # `Foo[Bar].new.is_a?(Foo)` should be true, which isn't the case
+            # if we just clone the class. But subclassing works just fine.
+            create_safe_subclass(constant)
+          else
+            # This can only be a module and it is fine to just clone modules
+            # since they can't have instances and will not have `is_a?` relationships.
+            # Moreover, we never `include`/`extend` any generic modules into the
+            # ancestor tree, so this doesn't become a problem with checking the
+            # instance of a class being `is_a?` of a module type.
+            constant.clone
+          end
+
+          # Let's set the `name` method to return the proper generic name
+          generic_type.define_singleton_method(:name) { name }
+
+          # We need to define a `<=` method on the cloned constant, so that Sorbet
+          # can do covariance/contravariance checks on the type variables.
+          #
+          # Normally, we would be doing proper covariance/contravariance checks here, but
+          # that is not necessary, since we are not implementing a runtime type checker
+          # here. It is just enough for the checks to pass, so that we can serialize the
+          # signatures, assuming the sigs were well-formed.
+          #
+          # So we act like all subtype checks pass.
+          generic_type.define_singleton_method(:<=) { |_| true }
+
+          # Return the generic type we created
+          generic_type
+        end
+
+        sig { params(constant: Class).returns(Class) }
+        def create_safe_subclass(constant)
+          # Lookup the "inherited" class method
+          inherited_method = constant.method(:inherited)
+          # and the module that defines it
+          owner = inherited_method.owner
+
+          # If no one has overriden the inherited method yet, just subclass
+          return Class.new(constant) if Class == owner
+
+          begin
+            # Otherwise, some inherited method could be preventing us
+            # from creating subclasses, so let's override it and rescue
+            owner.send(:define_method, :inherited) do |s|
+              inherited_method.call(s)
+            rescue
+              # Ignoring errors
+            end
+
+            # return a subclass
+            Class.new(constant)
+          ensure
+            # Reinstate the original inherited method back.
+            owner.send(:define_method, :inherited, inherited_method)
+          end
+        end
+
+        sig { params(constant: Module).returns(T::Array[TypeVariableModule]) }
+        def lookup_or_initialize_type_variables(constant)
+          @type_variables[constant] ||= []
+        end
+      end
+    end
+  end
+end

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"