sorbet-runtime 0.6.12645 → 0.6.12793

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 175eb48572fc002a5d56441bd62522b66f8a83364dbdcd4d7600f7e3792308b5
-  data.tar.gz: 961dbe8f3e80ab8f494004c1eab1adc11c180463405a8d01554421687960657c
+  metadata.gz: cebe71c475edd5bcf34591ff0144ff3830b27cdfafa46abe60baff07d92e8d89
+  data.tar.gz: 37b350eeae2cc1ab69f24f944a56a42582855f1c39e86bfd4d39cba685b75b0a
 SHA512:
-  metadata.gz: 87a91dd727979933d8371337fdba628951020ffe5226d48f362a7734c6d9795d1e3de6d4c5193726e89b74f243ddc710fa6fee4a432f2655b3bd8f798a447f8a
-  data.tar.gz: 44040ae432325a2cba5452e84e79c0e6138ef5e13afbcc844d8b55ad86ab481a73f293e580050d8143c041d51e851b3c6aa4956e62ca5ff9bac05dc0e841615d
+  metadata.gz: 273367cb15c029f3a777051605387a4b6e800edf45ee05f80eadd5a65c6d8a357dbe25ec31533992835fd9f8a96cff2369408e2572027c666bc7896d993f790c
+  data.tar.gz: c237722b26b2456014f2347b16b64d159603d4081664a519cb029aa6d719c64ed56c47c50fa4543d8de8f63717956cd6b5c56c333d85cc4f7725db7726f9ce1f

data/lib/sorbet-runtime.rb

@@ -85,6 +85,7 @@ require_relative 'types/boolean'
 
 # Depends on types/utils
 require_relative 'types/types/typed_array'
+require_relative 'types/types/typed_module'
 require_relative 'types/types/typed_class'
 
 # Props dependencies
@@ -114,6 +115,5 @@ require_relative 'types/props/private/parser'
 require_relative 'types/props/generated_code_validation'
 
 require_relative 'types/struct'
-require_relative 'types/non_forcing_constants'
 
 require_relative 'types/compatibility_patches'

data/lib/types/_types.rb

@@ -367,4 +367,16 @@ module T
       end
     end
   end
+
+  module Module
+    def self.[](type)
+      if type.is_a?(T::Types::Untyped)
+        T::Types::TypedModule::Untyped::Private::INSTANCE
+      elsif type.is_a?(T::Types::Anything)
+        T::Types::TypedModule::Anything::Private::INSTANCE
+      else
+        T::Types::TypedModule::Private::Pool.type_for_module(type)
+      end
+    end
+  end
 end

data/lib/types/configuration.rb

@@ -2,9 +2,6 @@
 # frozen_string_literal: true
 
 module T::Configuration
-  # Cache this comparisonn to avoid two allocations all over the place.
-  AT_LEAST_RUBY_2_7 = Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.7')
-
   # Announces to Sorbet that we are currently in a test environment, so it
   # should treat any sigs which are marked `.checked(:tests)` as if they were
   # just a normal sig.
@@ -448,11 +445,7 @@ module T::Configuration
   MODULE_NAME = Module.instance_method(:name)
   private_constant :MODULE_NAME
 
-  @default_module_name_mangler = if T::Configuration::AT_LEAST_RUBY_2_7
-    ->(type) { MODULE_NAME.bind_call(type) }
-  else
-    ->(type) { MODULE_NAME.bind(type).call } # rubocop:disable Performance/BindCall
-  end
+  @default_module_name_mangler = ->(type) { MODULE_NAME.bind_call(type) }
 
   @module_name_mangler = nil
 
@@ -462,7 +455,7 @@ module T::Configuration
 
   # Set to override the default behavior for converting types
   #   to names in generated code. Used by the runtime implementation
-  #   associated with `--stripe-packages` mode.
+  #   associated with `--sorbet-packages` mode.
   #
   # @param [Lambda, Proc, nil] handler Proc that converts a type (Class/Module)
   #   to a String (pass nil to reset to default behavior)

data/lib/types/enum.rb

@@ -273,7 +273,7 @@ class T::Enum
 
   ### Private implementation ###
 
-  UNSET = T.let(Module.new.freeze, Module)
+  UNSET = T.let(Module.new.freeze, T::Module[T.anything])
   private_constant :UNSET
 
   sig { params(serialized_val: SerializedVal).void }

data/lib/types/private/methods/_methods.rb

@@ -257,10 +257,8 @@ module T::Private::Methods
         # make sure to keep changes in sync.
         elsif method_sig.check_level == :always || (method_sig.check_level == :tests && T::Private::RuntimeLevels.check_tests?)
           CallValidation.validate_call(self, original_method, method_sig, args, blk)
-        elsif T::Configuration::AT_LEAST_RUBY_2_7
-          original_method.bind_call(self, *args, &blk)
         else
-          original_method.bind(self).call(*args, &blk) # rubocop:disable Performance/BindCall
+          original_method.bind_call(self, *args, &blk)
         end
       end
     end
@@ -530,27 +528,15 @@ module T::Private::Methods
       @old_hooks = nil
     else
       old_included = T::Private::ClassUtils.replace_method(Module, :included, true) do |arg|
-        if T::Configuration::AT_LEAST_RUBY_2_7
-          old_included.bind_call(self, arg)
-        else
-          old_included.bind(self).call(arg) # rubocop:disable Performance/BindCall
-        end
+        old_included.bind_call(self, arg)
         ::T::Private::Methods._hook_impl(arg, false, self)
       end
       old_extended = T::Private::ClassUtils.replace_method(Module, :extended, true) do |arg|
-        if T::Configuration::AT_LEAST_RUBY_2_7
-          old_extended.bind_call(self, arg)
-        else
-          old_extended.bind(self).call(arg) # rubocop:disable Performance/BindCall
-        end
+        old_extended.bind_call(self, arg)
         ::T::Private::Methods._hook_impl(arg, true, self)
       end
       old_inherited = T::Private::ClassUtils.replace_method(Class, :inherited, true) do |arg|
-        if T::Configuration::AT_LEAST_RUBY_2_7
-          old_inherited.bind_call(self, arg)
-        else
-          old_inherited.bind(self).call(arg) # rubocop:disable Performance/BindCall
-        end
+        old_inherited.bind_call(self, arg)
         ::T::Private::Methods._hook_impl(arg, false, self)
       end
       @old_hooks = [old_included, old_extended, old_inherited]

data/lib/types/private/methods/call_validation.rb

@@ -79,13 +79,13 @@ module T::Private::Methods::CallValidation
 
     # All the types for which valid? unconditionally returns `true`
     return_is_ignorable =
-      (method_sig.return_type.equal?(T::Types::Untyped::Private::INSTANCE) ||
-       method_sig.return_type.equal?(T::Types::Anything::Private::INSTANCE) ||
-       method_sig.return_type.equal?(T::Types::AttachedClassType::Private::INSTANCE) ||
-       method_sig.return_type.equal?(T::Types::SelfType::Private::INSTANCE) ||
-       method_sig.return_type.is_a?(T::Types::TypeParameter) ||
-       method_sig.return_type.is_a?(T::Types::TypeVariable) ||
-       (method_sig.return_type.is_a?(T::Types::Simple) && method_sig.return_type.raw_type.equal?(BasicObject)))
+      method_sig.return_type.equal?(T::Types::Untyped::Private::INSTANCE) ||
+      method_sig.return_type.equal?(T::Types::Anything::Private::INSTANCE) ||
+      method_sig.return_type.equal?(T::Types::AttachedClassType::Private::INSTANCE) ||
+      method_sig.return_type.equal?(T::Types::SelfType::Private::INSTANCE) ||
+      method_sig.return_type.is_a?(T::Types::TypeParameter) ||
+      method_sig.return_type.is_a?(T::Types::TypeVariable) ||
+      (method_sig.return_type.is_a?(T::Types::Simple) && method_sig.return_type.raw_type.equal?(BasicObject))
 
     returns_anything_method = all_args_are_simple && return_is_ignorable
 
@@ -176,7 +176,7 @@ module T::Private::Methods::CallValidation
     # this code is sig validation code.
     # Please issue `finish` to step out of it
 
-    return_value = T::Configuration::AT_LEAST_RUBY_2_7 ? original_method.bind_call(instance, *args, &blk) : original_method.bind(instance).call(*args, &blk)
+    return_value = original_method.bind_call(instance, *args, &blk)
 
     # The only type that is allowed to change the return value is `.void`.
     # It ignores what you returned and changes it to be a private singleton.
@@ -279,7 +279,7 @@ module T::Private::Methods::CallValidation
     # this code is sig validation code.
     # Please issue `finish` to step out of it
 
-    return_value = T::Configuration::AT_LEAST_RUBY_2_7 ? original_method.bind_call(instance, *args, &blk) : original_method.bind(instance).call(*args, &blk)
+    return_value = original_method.bind_call(instance, *args, &blk)
 
     # The only type that is allowed to change the return value is `.void`.
     # It ignores what you returned and changes it to be a private singleton.
@@ -332,8 +332,4 @@ module T::Private::Methods::CallValidation
   end
 end
 
-if T::Configuration::AT_LEAST_RUBY_2_7
-  require_relative './call_validation_2_7'
-else
-  require_relative './call_validation_2_6'
-end
+require_relative './call_validation_2_7'

data/lib/types/props/custom_type.rb

@@ -50,7 +50,7 @@ module T::Props
     sig { abstract.params(scalar: T.untyped).returns(T.untyped).checked(:never) }
     def deserialize(scalar); end
 
-    sig { override.params(_base: Module).void }
+    sig { override.params(_base: T::Module[T.anything]).void }
     def self.included(_base)
       super
 

data/lib/types/props/decorator.rb

@@ -13,8 +13,10 @@ class T::Props::Decorator
   Rules = T.type_alias { T::Hash[Symbol, T.untyped] }
   DecoratedInstance = T.type_alias { Object } # Would be T::Props, but that produces circular reference errors in some circumstances
   PropType = T.type_alias { T::Types::Base }
-  PropTypeOrClass = T.type_alias { T.any(PropType, Module) }
+  PropTypeOrClass = T.type_alias { T.any(PropType, T::Module[T.anything]) }
   OverrideRules = T.type_alias { T::Hash[Symbol, {allow_incompatible: T::Boolean}] }
+  DecoratedClassType = T.type_alias { T.all(T::Module[T.anything], T::Props::ClassMethods) }
+  private_constant :DecoratedClassType
 
   class NoRulesError < StandardError; end
 
@@ -38,7 +40,7 @@ class T::Props::Decorator
 
   sig { params(klass: T.untyped).void.checked(:never) }
   def initialize(klass)
-    @class = T.let(klass, T.all(Module, T::Props::ClassMethods))
+    @class = T.let(klass, DecoratedClassType)
     @class.plugins.each do |mod|
       T::Props::Plugin::Private.apply_decorator_methods(mod, self)
     end
@@ -102,7 +104,7 @@ class T::Props::Decorator
   end
 
   # checked(:never) - O(prop accesses)
-  sig { returns(T.all(Module, T::Props::ClassMethods)).checked(:never) }
+  sig { returns(DecoratedClassType).checked(:never) }
   def decorated_class
     @class
   end
@@ -207,7 +209,7 @@ class T::Props::Decorator
     params(
       instance: DecoratedInstance,
       prop: Symbol,
-      foreign_class: Module,
+      foreign_class: T::Module[T.anything],
       rules: Rules,
       opts: T::Hash[Symbol, T.untyped],
     )
@@ -226,7 +228,7 @@ class T::Props::Decorator
   sig do
     params(
       name: Symbol,
-      cls: Module,
+      cls: T::Module[T.anything],
       rules: Rules,
       type: PropTypeOrClass
     )
@@ -264,9 +266,9 @@ class T::Props::Decorator
     nil
   end
 
-  SAFE_NAME = T.let(/\A[A-Za-z_][A-Za-z0-9_-]*\z/.freeze, Regexp, checked: false)
+  SAFE_NAME = T.let(/\A[A-Za-z_][A-Za-z0-9_-]*\z/, Regexp, checked: false)
   # Should be exactly the same as `SAFE_NAME`, but with a leading `@`.
-  SAFE_ACCESSOR_KEY_NAME = T.let(/\A@[A-Za-z_][A-Za-z0-9_-]*\z/.freeze, Regexp, checked: false)
+  SAFE_ACCESSOR_KEY_NAME = T.let(/\A@[A-Za-z_][A-Za-z0-9_-]*\z/, Regexp, checked: false)
 
   # Used to validate both prop names and serialized forms
   sig { params(name: T.any(Symbol, String)).void.checked(:never) }
@@ -277,7 +279,7 @@ class T::Props::Decorator
   end
 
   # This converts the type from a T::Type to a regular old ruby class.
-  sig { params(type: T::Types::Base).returns(Module).checked(:never) }
+  sig { params(type: T::Types::Base).returns(T::Module[T.anything]).checked(:never) }
   private def convert_type_to_class(type)
     case type
     when T::Types::TypedArray, T::Types::FixedArray
@@ -327,9 +329,9 @@ class T::Props::Decorator
   sig(:final) { params(name: Symbol).returns(T::Boolean).checked(:never) }
   private def method_defined_on_ancestor?(name)
     (@class.method_defined?(name) || @class.private_method_defined?(name)) &&
-    # Unfortunately, older versions of ruby don't allow the second parameter on
-    # `private_method_defined?`.
-    (!@class.method_defined?(name, false) && !@class.private_method_defined?(name, false))
+      # Unfortunately, older versions of ruby don't allow the second parameter on
+      # `private_method_defined?`.
+      !@class.method_defined?(name, false) && !@class.private_method_defined?(name, false)
   end
 
   sig(:final) { params(name: Symbol, rules: Rules).void.checked(:never) }
@@ -586,7 +588,7 @@ class T::Props::Decorator
   sig do
     params(
       prop_name: Symbol,
-      prop_cls: Module,
+      prop_cls: T::Module[T.anything],
       rules: Rules,
       foreign: T.untyped,
     )
@@ -629,10 +631,10 @@ class T::Props::Decorator
   #
   # This gets called when a module or class that extends T::Props gets included, extended,
   # prepended, or inherited.
-  sig { params(child: Module).void.checked(:never) }
+  sig { params(child: T::Module[T.anything]).void.checked(:never) }
   def model_inherited(child)
     child.extend(T::Props::ClassMethods)
-    child = T.cast(child, T.all(Module, T::Props::ClassMethods))
+    child = T.cast(child, DecoratedClassType)
 
     child.plugins.concat(decorated_class.plugins)
     decorated_class.plugins.each do |mod|
@@ -719,19 +721,19 @@ class T::Props::Decorator
     result
   end
 
-  sig { params(child: T.all(Module, T::Props::ClassMethods), prop: Symbol).returns(T::Boolean).checked(:never) }
+  sig { params(child: DecoratedClassType, prop: Symbol).returns(T::Boolean).checked(:never) }
   private def clobber_getter?(child, prop)
     !!(child.decorator.method(:prop_get).owner != method(:prop_get).owner &&
        child.instance_method(prop).source_location&.first == __FILE__)
   end
 
-  sig { params(child: T.all(Module, T::Props::ClassMethods), prop: Symbol).returns(T::Boolean).checked(:never) }
+  sig { params(child: DecoratedClassType, prop: Symbol).returns(T::Boolean).checked(:never) }
   private def clobber_setter?(child, prop)
     !!(child.decorator.method(:prop_set).owner != method(:prop_set).owner &&
        child.instance_method("#{prop}=").source_location&.first == __FILE__)
   end
 
-  sig { params(mod: Module).void.checked(:never) }
+  sig { params(mod: T::Module[T.anything]).void.checked(:never) }
   def plugin(mod)
     decorated_class.plugins << mod
     T::Props::Plugin::Private.apply_class_methods(mod, decorated_class)

data/lib/types/props/private/apply_default.rb

@@ -27,10 +27,10 @@ module T::Props
       sig { abstract.params(instance: T.all(T::Props::Optional, Object)).void.checked(:never) }
       def set_default(instance); end
 
-      NO_CLONE_TYPES = T.let([TrueClass, FalseClass, NilClass, Symbol, Numeric, T::Enum].freeze, T::Array[Module])
+      NO_CLONE_TYPES = T.let([TrueClass, FalseClass, NilClass, Symbol, Numeric, T::Enum].freeze, T::Array[T::Module[T.anything]])
 
       # checked(:never) - Rules hash is expensive to check
-      sig { params(cls: Module, rules: T::Hash[Symbol, T.untyped]).returns(T.nilable(ApplyDefault)).checked(:never) }
+      sig { params(cls: T::Module[T.anything], rules: T::Hash[Symbol, T.untyped]).returns(T.nilable(ApplyDefault)).checked(:never) }
       def self.for(cls, rules)
         accessor_key = rules.fetch(:accessor_key)
         setter = rules.fetch(:setter_proc)
@@ -138,7 +138,7 @@ module T::Props
       # checked(:never) - We do this with `T.let` instead
       sig do
         params(
-          cls: Module,
+          cls: T::Module[T.anything],
           factory: T.any(Proc, Method),
           accessor_key: Symbol,
           setter_proc: SetterFactory::SetterProc,
@@ -147,7 +147,7 @@ module T::Props
         .checked(:never)
       end
       def initialize(cls, factory, accessor_key, setter_proc)
-        @class = T.let(cls, Module)
+        @class = T.let(cls, T::Module[T.anything])
         @factory = T.let(factory, T.any(Proc, Method))
         super(accessor_key, setter_proc)
       end

data/lib/types/props/private/serde_transform.rb

@@ -20,7 +20,7 @@ module T::Props
 
       NO_TRANSFORM_TYPES = T.let(
         [TrueClass, FalseClass, NilClass, Symbol, String].freeze,
-        T::Array[Module],
+        T::Array[T::Module[T.anything]],
       )
       private_constant :NO_TRANSFORM_TYPES
 
@@ -151,7 +151,7 @@ module T::Props
         end
       end
 
-      sig { params(varname: String, type: Module, mode: ModeType).returns(String).checked(:never) }
+      sig { params(varname: String, type: T::Module[T.anything], mode: ModeType).returns(String).checked(:never) }
       private_class_method def self.handle_serializable_subtype(varname, type, mode)
         case mode
         when Serialize
@@ -164,7 +164,7 @@ module T::Props
         end
       end
 
-      sig { params(varname: String, type: Module, mode: ModeType).returns(String).checked(:never) }
+      sig { params(varname: String, type: T::Module[T.anything], mode: ModeType).returns(String).checked(:never) }
       private_class_method def self.handle_custom_type(varname, type, mode)
         case mode
         when Serialize
@@ -177,7 +177,7 @@ module T::Props
         end
       end
 
-      sig { params(type: Module).returns(T.nilable(String)).checked(:never) }
+      sig { params(type: T::Module[T.anything]).returns(T.nilable(String)).checked(:never) }
       private_class_method def self.module_name(type)
         T::Configuration.module_name_mangler.call(type)
       end

data/lib/types/props/private/setter_factory.rb

@@ -12,7 +12,7 @@ module T::Props
 
       sig do
         params(
-          klass: T.all(Module, T::Props::ClassMethods),
+          klass: T.all(T::Module[T.anything], T::Props::ClassMethods),
           prop: Symbol,
           rules: T::Hash[Symbol, T.untyped]
         )
@@ -53,8 +53,8 @@ module T::Props
         params(
           prop: Symbol,
           accessor_key: Symbol,
-          non_nil_type: Module,
-          klass: T.all(Module, T::Props::ClassMethods),
+          non_nil_type: T::Module[T.anything],
+          klass: T.all(T::Module[T.anything], T::Props::ClassMethods),
         )
         .returns([SetterProc, ValueValidationProc])
       end
@@ -89,7 +89,7 @@ module T::Props
           prop: Symbol,
           accessor_key: Symbol,
           non_nil_type: T::Types::Base,
-          klass: T.all(Module, T::Props::ClassMethods),
+          klass: T.all(T::Module[T.anything], T::Props::ClassMethods),
           validate: T.nilable(ValidateProc)
         )
         .returns([SetterProc, ValueValidationProc])
@@ -138,8 +138,8 @@ module T::Props
         params(
           prop: Symbol,
           accessor_key: Symbol,
-          non_nil_type: Module,
-          klass: T.all(Module, T::Props::ClassMethods),
+          non_nil_type: T::Module[T.anything],
+          klass: T.all(T::Module[T.anything], T::Props::ClassMethods),
         )
         .returns([SetterProc, ValueValidationProc])
       end
@@ -174,7 +174,7 @@ module T::Props
           prop: Symbol,
           accessor_key: Symbol,
           non_nil_type: T::Types::Base,
-          klass: T.all(Module, T::Props::ClassMethods),
+          klass: T.all(T::Module[T.anything], T::Props::ClassMethods),
           validate: T.nilable(ValidateProc),
         )
         .returns([SetterProc, ValueValidationProc])
@@ -225,9 +225,9 @@ module T::Props
 
       sig do
         params(
-          klass: T.all(Module, T::Props::ClassMethods),
+          klass: T.all(T::Module[T.anything], T::Props::ClassMethods),
           prop: Symbol,
-          type: T.any(T::Types::Base, Module),
+          type: T.any(T::Types::Base, T::Module[T.anything]),
           val: T.untyped,
         )
         .void

data/lib/types/props/type_validation.rb

@@ -20,9 +20,9 @@ module T::Props::TypeValidation
     sig do
       params(
         name: T.any(Symbol, String),
-        _cls: Module,
+        _cls: T::Module[T.anything],
         rules: T::Hash[Symbol, T.untyped],
-        type: T.any(T::Types::Base, Module)
+        type: T.any(T::Types::Base, T::Module[T.anything])
       )
       .void
       .checked(:never)

data/lib/types/types/class_of.rb

@@ -31,7 +31,7 @@ module T::Types
         @type.is_a?(other.type.singleton_class)
       when Simple
         @type.is_a?(other.raw_type)
-      when TypedClass
+      when TypedClass, TypedModule
         @type.is_a?(other.underlying_class)
       else
         false

data/lib/types/types/simple.rb

@@ -41,7 +41,7 @@ module T::Types
       case other
       when Simple
         @raw_type <= other.raw_type
-      when TypedClass
+      when TypedClass, TypedModule
         # This case is a bit odd--we would have liked to solve this like we do
         # for `T::Array` et al., but don't for backwards compatibility.
         # See `type_for_module` below.
@@ -103,9 +103,9 @@ module T::Types
           elsif !Object.autoload?(:Set) && Object.const_defined?(:Set) && mod == ::Set
             T::Set[T.untyped]
           else
-            # ideally we would have a case mapping from ::Class -> T::Class here
-            # but for backwards compatibility we don't have that, and instead
-            # have a special case in subtype_of_single?
+            # ideally we would have a case mapping from ::Class -> T::Class and
+            # ::Module -> T::Module here but for backwards compatibility we
+            # don't have that, and instead have a special case in subtype_of_single?
             Simple.new(mod)
           end
 

data/lib/types/types/typed_class.rb

@@ -33,7 +33,7 @@ module T::Types
     # overrides Base
     private def subtype_of_single?(type)
       case type
-      when TypedClass
+      when TypedClass, TypedModule
         # treat like generics are erased
         true
       when Simple

data/lib/types/types/typed_enumerable.rb

@@ -38,14 +38,12 @@ module T::Types
       return false unless obj.is_a?(Enumerable)
       case obj
       when Array
-        begin
-          it = 0
-          while it < obj.count
-            return false unless type.recursively_valid?(obj[it])
-            it += 1
-          end
-          true
+        it = 0
+        while it < obj.count
+          return false unless type.recursively_valid?(obj[it])
+          it += 1
         end
+        true
       when Hash
         type_ = self.type
         return false unless type_.is_a?(FixedArray)
@@ -168,11 +166,7 @@ module T::Types
         obj.class
       else
         # This is a specialized enumerable type, just return the class.
-        if T::Configuration::AT_LEAST_RUBY_2_7
-          Object.instance_method(:class).bind_call(obj)
-        else
-          Object.instance_method(:class).bind(obj).call # rubocop:disable Performance/BindCall
-        end
+        Object.instance_method(:class).bind_call(obj)
       end
     end
 

data/lib/types/types/typed_module.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  class TypedModule < T::Types::Base
+    def initialize(type)
+      @inner_type = type
+    end
+
+    def type
+      @type ||= T::Utils.coerce(@inner_type)
+    end
+
+    def build_type
+      type
+      nil
+    end
+
+    # overrides Base
+    def name
+      "T::Module[#{type.name}]"
+    end
+
+    def underlying_class
+      Module
+    end
+
+    # overrides Base
+    def valid?(obj)
+      Module.===(obj)
+    end
+
+    # overrides Base
+    private def subtype_of_single?(type)
+      case type
+      when TypedModule
+        # treat like generics are erased
+        true
+      when Simple
+        Module <= type.raw_type
+      else
+        false
+      end
+    end
+
+    module Private
+      module Pool
+        CACHE_FROZEN_OBJECTS =
+          begin
+            ObjectSpace::WeakMap.new[1] = 1
+            true # Ruby 2.7 and newer
+          rescue ArgumentError
+            false # Ruby 2.6 and older
+          end
+
+        @cache = ObjectSpace::WeakMap.new
+
+        def self.type_for_module(mod)
+          cached = @cache[mod]
+          return cached if cached
+
+          type = TypedModule.new(mod)
+
+          if CACHE_FROZEN_OBJECTS || (!mod.frozen? && !type.frozen?)
+            @cache[mod] = type
+          end
+          type
+        end
+      end
+    end
+
+    class Untyped < TypedModule
+      def initialize
+        super(T::Types::Untyped::Private::INSTANCE)
+      end
+
+      def freeze
+        build_type # force lazy initialization before freezing the object
+        super
+      end
+
+      module Private
+        INSTANCE = Untyped.new.freeze
+      end
+    end
+
+    class Anything < TypedModule
+      def initialize
+        super(T.anything)
+      end
+
+      def freeze
+        build_type # force lazy initialization before freezing the object
+        super
+      end
+
+      module Private
+        INSTANCE = Anything.new.freeze
+      end
+    end
+  end
+end

data/lib/types/types/typed_set.rb

@@ -14,7 +14,6 @@ module T::Types
 
     # overrides Base
     def recursively_valid?(obj)
-      # Re-implements non_forcing_is_a?
       return false if Object.autoload?(:Set) # Set is meant to be autoloaded but not yet loaded, this value can't be a Set
       return false unless Object.const_defined?(:Set) # Set is not loaded yet
       obj.is_a?(Set) && super
@@ -22,7 +21,6 @@ module T::Types
 
     # overrides Base
     def valid?(obj)
-      # Re-implements non_forcing_is_a?
       return false if Object.autoload?(:Set) # Set is meant to be autoloaded but not yet loaded, this value can't be a Set
       return false unless Object.const_defined?(:Set) # Set is not loaded yet
       obj.is_a?(Set)
@@ -41,7 +39,6 @@ module T::Types
       end
 
       def valid?(obj)
-        # Re-implements non_forcing_is_a?
         return false if Object.autoload?(:Set) # Set is meant to be autoloaded but not yet loaded, this value can't be a Set
         return false unless Object.const_defined?(:Set) # Set is not loaded yet
         obj.is_a?(Set)