sorbet-runtime 0.5.10439 → 0.5.11120

data/lib/types/props/type_validation.rb

@@ -16,6 +16,7 @@ module T::Props::TypeValidation
       super || key == :DEPRECATED_underspecified_type
     end
 
+    # checked(:never) - Rules hash is expensive to check
     sig do
       params(
         name: T.any(Symbol, String),
@@ -24,12 +25,13 @@ module T::Props::TypeValidation
         type: T.any(T::Types::Base, Module)
       )
       .void
+      .checked(:never)
     end
     def prop_validate_definition!(name, _cls, rules, type)
       super
 
       if !rules[:DEPRECATED_underspecified_type]
-        validate_type(type, field_name: name)
+        validate_type(type, name)
       elsif rules[:DEPRECATED_underspecified_type] && find_invalid_subtype(type).nil?
         raise ArgumentError.new("DEPRECATED_underspecified_type set unnecessarily for #{@class.name}.#{name} - #{type} is a valid type")
       end
@@ -41,8 +43,9 @@ module T::Props::TypeValidation
         field_name: T.any(Symbol, String),
       )
       .void
+      .checked(:never)
     end
-    private def validate_type(type, field_name:)
+    private def validate_type(type, field_name)
       if (invalid_subtype = find_invalid_subtype(type))
         raise UnderspecifiedType.new(type_error_message(invalid_subtype, field_name, type))
       end

data/lib/types/struct.rb

@@ -10,7 +10,7 @@ end
 class T::Struct < T::InexactStruct
   def self.inherited(subclass)
     super(subclass)
-    T::Private::ClassUtils.replace_method(subclass.singleton_class, :inherited) do |s|
+    T::Private::ClassUtils.replace_method(subclass.singleton_class, :inherited, true) do |s|
       super(s)
       raise "#{self.name} is a subclass of T::Struct and cannot be subclassed"
     end
@@ -23,7 +23,7 @@ class T::ImmutableStruct < T::InexactStruct
   def self.inherited(subclass)
     super(subclass)
 
-    T::Private::ClassUtils.replace_method(subclass.singleton_class, :inherited) do |s|
+    T::Private::ClassUtils.replace_method(subclass.singleton_class, :inherited, true) do |s|
       super(s)
       raise "#{self.name} is a subclass of T::ImmutableStruct and cannot be subclassed"
     end

data/lib/types/types/anything.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  # The top type
+  class Anything < Base
+    def initialize; end
+
+    # overrides Base
+    def name
+      "T.anything"
+    end
+
+    # overrides Base
+    def valid?(obj)
+      true
+    end
+
+    # overrides Base
+    private def subtype_of_single?(other)
+      case other
+      when T::Types::Anything then true
+      else false
+      end
+    end
+
+    module Private
+      INSTANCE = Anything.new.freeze
+    end
+  end
+end

data/lib/types/types/base.rb

@@ -50,10 +50,20 @@ module T::Types
         t2 = t2.aliased_type
       end
 
+      if t2.is_a?(T::Types::Anything)
+        return true
+      end
+
       if t1.is_a?(T::Private::Types::TypeAlias)
         return t1.aliased_type.subtype_of?(t2)
       end
 
+      if t1.is_a?(T::Types::TypeVariable) || t2.is_a?(T::Types::TypeVariable)
+        # Generics are erased at runtime. Let's treat them like `T.untyped` for
+        # the purpose of things like override checking.
+        return true
+      end
+
       # pairs to cover: 1  (_, _)
       #                 2  (_, And)
       #                 3  (_, Or)
@@ -163,8 +173,12 @@ module T::Types
     # Type equivalence, defined by serializing the type to a string (with
     # `#name`) and comparing the resulting strings for equality.
     def ==(other)
-      (T::Utils.resolve_alias(other).class == T::Utils.resolve_alias(self).class) &&
+      case other
+      when T::Types::Base
         other.name == self.name
+      else
+        false
+      end
     end
 
     alias_method :eql?, :==

data/lib/types/types/class_of.rb

@@ -27,6 +27,8 @@ module T::Types
         @type <= other.type
       when Simple
         @type.is_a?(other.raw_type)
+      when TypedClass
+        true
       else
         false
       end
@@ -36,5 +38,14 @@ module T::Types
     def describe_obj(obj)
       obj.inspect
     end
+
+    # So that `T.class_of(...)[...]` syntax is valid.
+    # Mirrors the definition of T::Generic#[] (generics are erased).
+    #
+    # We avoid simply writing `include T::Generic` because we don't want any of
+    # the other methods to appear (`T.class_of(A).type_member` doesn't make sense)
+    def [](*types)
+      self
+    end
   end
 end

data/lib/types/types/enum.rb

@@ -29,7 +29,7 @@ module T::Types
 
     # overrides Base
     def name
-      "T.deprecated_enum([#{@values.map(&:inspect).join(', ')}])"
+      @name ||= "T.deprecated_enum([#{@values.map(&:inspect).join(', ')}])"
     end
 
     # overrides Base

data/lib/types/types/fixed_array.rb

@@ -59,6 +59,19 @@ module T::Types
         @types.size == other.types.size && @types.zip(other.types).all? do |t1, t2|
           t1.subtype_of?(t2)
         end
+      when TypedArray
+        # warning: covariant arrays
+
+        value1, value2, *values_rest = types
+        value_type = if !value2.nil?
+          T::Types::Union::Private::Pool.union_of_types(value1, value2, values_rest)
+        elsif value1.nil?
+          T.untyped
+        else
+          value1
+        end
+
+        T::Types::TypedArray.new(value_type).subtype_of?(other)
       else
         false
       end

data/lib/types/types/fixed_hash.rb

@@ -38,6 +38,28 @@ module T::Types
       when FixedHash
         # Using `subtype_of?` here instead of == would be unsound
         @types == other.types
+      when TypedHash
+        # warning: covariant hashes
+
+        key1, key2, *keys_rest = types.keys.map {|key| T::Utils.coerce(key.class)}
+        key_type = if !key2.nil?
+          T::Types::Union::Private::Pool.union_of_types(key1, key2, keys_rest)
+        elsif key1.nil?
+          T.untyped
+        else
+          key1
+        end
+
+        value1, value2, *values_rest = types.values
+        value_type = if !value2.nil?
+          T::Types::Union::Private::Pool.union_of_types(value1, value2, values_rest)
+        elsif value1.nil?
+          T.untyped
+        else
+          value1
+        end
+
+        T::Types::TypedHash.new(keys: key_type, values: value_type).subtype_of?(other)
       else
         false
       end

data/lib/types/types/intersection.rb

@@ -20,7 +20,7 @@ module T::Types
 
     # overrides Base
     def name
-      "T.all(#{@types.map(&:name).sort.join(', ')})"
+      "T.all(#{@types.map(&:name).compact.sort.join(', ')})"
     end
 
     # overrides Base

data/lib/types/types/noreturn.rb

@@ -4,7 +4,6 @@
 module T::Types
   # The bottom type
   class NoReturn < Base
-
     def initialize; end
 
     # overrides Base

data/lib/types/types/simple.rb

@@ -4,6 +4,9 @@
 module T::Types
   # Validates that an object belongs to the specified class.
   class Simple < Base
+    NAME_METHOD = Module.instance_method(:name)
+    private_constant(:NAME_METHOD)
+
     attr_reader :raw_type
 
     def initialize(raw_type)
@@ -16,7 +19,7 @@ module T::Types
       #
       # `name` isn't normally a hot path for types, but it is used in initializing a T::Types::Union,
       # and so in `T.nilable`, and so in runtime constructions like `x = T.let(nil, T.nilable(Integer))`.
-      @name ||= @raw_type.name.freeze
+      @name ||= (NAME_METHOD.bind(@raw_type).call || @raw_type.name).freeze
     end
 
     # overrides Base
@@ -29,6 +32,11 @@ module T::Types
       case other
       when Simple
         @raw_type <= other.raw_type
+      when TypedClass
+        # 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.
+        @raw_type <= other.underlying_class
       else
         false
       end
@@ -52,11 +60,21 @@ module T::Types
     end
 
     def to_nilable
-      @nilable ||= T::Types::Union.new([self, T::Utils::Nilable::NIL_TYPE])
+      @nilable ||= T::Private::Types::SimplePairUnion.new(
+        self,
+        T::Utils::Nilable::NIL_TYPE,
+      )
     end
 
     module Private
       module Pool
+        CACHE_FROZEN_OBJECTS = begin
+          ObjectSpace::WeakMap.new[1] = 1
+          true # Ruby 2.7 and newer
+                               rescue ArgumentError # Ruby 2.6 and older
+                                 false
+        end
+
         @cache = ObjectSpace::WeakMap.new
 
         def self.type_for_module(mod)
@@ -76,16 +94,21 @@ 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?
             Simple.new(mod)
           end
 
           # Unfortunately, we still need to check if the module is frozen,
-          # since WeakMap adds a finalizer to the key that is added
+          # since on 2.6 and older WeakMap adds a finalizer to the key that is added
           # to the map, so that it can clear the map entry when the key is
           # garbage collected.
           # For a frozen object, though, adding a finalizer is not a valid
           # operation, so this still raises if `mod` is frozen.
-          @cache[mod] = type unless mod.frozen?
+          if CACHE_FROZEN_OBJECTS || (!mod.frozen? && !type.frozen?)
+            @cache[mod] = type
+          end
           type
         end
       end

data/lib/types/types/type_parameter.rb

@@ -3,11 +3,30 @@
 
 module T::Types
   class TypeParameter < Base
+    module Private
+      @pool = {}
+
+      def self.cached_entry(name)
+        @pool[name]
+      end
+
+      def self.set_entry_for(name, type)
+        @pool[name] = type
+      end
+    end
+
     def initialize(name)
       raise ArgumentError.new("not a symbol: #{name}") unless name.is_a?(Symbol)
       @name = name
     end
 
+    def self.make(name)
+      cached = Private.cached_entry(name)
+      return cached if cached
+
+      Private.set_entry_for(name, new(name))
+    end
+
     def valid?(obj)
       true
     end

data/lib/types/types/typed_array.rb

@@ -26,6 +26,31 @@ module T::Types
       Array.new(*T.unsafe(args))
     end
 
+    module Private
+      module Pool
+        CACHE_FROZEN_OBJECTS = begin
+          ObjectSpace::WeakMap.new[1] = 1
+          true # Ruby 2.7 and newer
+                               rescue ArgumentError # Ruby 2.6 and older
+                                 false
+        end
+
+        @cache = ObjectSpace::WeakMap.new
+
+        def self.type_for_module(mod)
+          cached = @cache[mod]
+          return cached if cached
+
+          type = TypedArray.new(mod)
+
+          if CACHE_FROZEN_OBJECTS || (!mod.frozen? && !type.frozen?)
+            @cache[mod] = type
+          end
+          type
+        end
+      end
+    end
+
     class Untyped < TypedArray
       def initialize
         super(T.untyped)
@@ -34,6 +59,10 @@ module T::Types
       def valid?(obj)
         obj.is_a?(Array)
       end
+
+      module Private
+        INSTANCE = Untyped.new.freeze
+      end
     end
   end
 end

data/lib/types/types/typed_class.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  class TypedClass < T::Types::Base
+    attr_reader :type
+
+    def initialize(type)
+      @type = T::Utils.coerce(type)
+    end
+
+    # overrides Base
+    def name
+      "T::Class[#{@type.name}]"
+    end
+
+    def underlying_class
+      Class
+    end
+
+    # overrides Base
+    def valid?(obj)
+      Class.===(obj)
+    end
+
+    # overrides Base
+    private def subtype_of_single?(type)
+      case type
+      when TypedClass
+        # treat like generics are erased
+        true
+      when Simple
+        Class <= 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 = TypedClass.new(mod)
+
+          if CACHE_FROZEN_OBJECTS || (!mod.frozen? && !type.frozen?)
+            @cache[mod] = type
+          end
+          type
+        end
+      end
+    end
+
+    class Untyped < TypedClass
+      def initialize
+        super(T.untyped)
+      end
+
+      module Private
+        INSTANCE = Untyped.new.freeze
+      end
+    end
+
+    class Anything < TypedClass
+      def initialize
+        super(T.anything)
+      end
+
+      module Private
+        INSTANCE = Anything.new.freeze
+      end
+    end
+  end
+end

data/lib/types/types/typed_enumerable.rb

@@ -54,6 +54,9 @@ module T::Types
       when Enumerator::Lazy
         # Enumerators can be unbounded: see `[:foo, :bar].cycle`
         true
+      when Enumerator::Chain
+        # Enumerators can be unbounded: see `[:foo, :bar].cycle`
+        true
       when Enumerator
         # Enumerators can be unbounded: see `[:foo, :bar].cycle`
         true
@@ -88,6 +91,8 @@ module T::Types
         # both reading and writing. However, Sorbet treats *all*
         # Enumerable subclasses as covariant for ease of adoption.
         @type.subtype_of?(other.type)
+      elsif other.class <= Simple
+        underlying_class <= other.raw_type
       else
         false
       end
@@ -145,6 +150,8 @@ module T::Types
         end
       when Enumerator::Lazy
         T::Enumerator::Lazy[type_from_instances(obj)]
+      when Enumerator::Chain
+        T::Enumerator::Chain[type_from_instances(obj)]
       when Enumerator
         T::Enumerator[type_from_instances(obj)]
       when Set

data/lib/types/types/typed_enumerator_chain.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  class TypedEnumeratorChain < TypedEnumerable
+    attr_reader :type
+
+    def underlying_class
+      Enumerator::Chain
+    end
+
+    # overrides Base
+    def name
+      "T::Enumerator::Chain[#{@type.name}]"
+    end
+
+    # overrides Base
+    def recursively_valid?(obj)
+      obj.is_a?(Enumerator::Chain) && super
+    end
+
+    # overrides Base
+    def valid?(obj)
+      obj.is_a?(Enumerator::Chain)
+    end
+
+    def new(*args, &blk)
+      T.unsafe(Enumerator::Chain).new(*args, &blk)
+    end
+
+    class Untyped < TypedEnumeratorChain
+      def initialize
+        super(T.untyped)
+      end
+
+      def valid?(obj)
+        obj.is_a?(Enumerator::Chain)
+      end
+    end
+  end
+end

data/lib/types/types/union.rb

@@ -6,6 +6,8 @@ module T::Types
   class Union < Base
     attr_reader :types
 
+    # Don't use Union.new directly, use `Private::Pool.union_of_types`
+    # inside sorbet-runtime and `T.any` elsewhere.
     def initialize(types)
       @types = types.flat_map do |type|
         type = T::Utils.coerce(type)
@@ -20,11 +22,16 @@ module T::Types
 
     # overrides Base
     def name
-      type_shortcuts(@types)
+      # Use the attr_reader here so we can override it in SimplePairUnion
+      type_shortcuts(types)
     end
 
     private def type_shortcuts(types)
       if types.size == 1
+        # We shouldn't generally get here but it's possible if initializing the type
+        # evades Sorbet's static check and we end up on the slow path, or if someone
+        # is using the T:Types::Union constructor directly (the latter possibility
+        # is why we don't just move the `uniq` into `Private::Pool.union_of_types`).
         return types[0].name
       end
       nilable = T::Utils.coerce(NilClass)
@@ -57,32 +64,61 @@ module T::Types
       raise "This should never be reached if you're going through `subtype_of?` (and you should be)"
     end
 
+    def unwrap_nilable
+      non_nil_types = types.reject {|t| t == T::Utils::Nilable::NIL_TYPE}
+      return nil if types.length == non_nil_types.length
+      case non_nil_types.length
+      when 0 then nil
+      when 1 then non_nil_types.first
+      else
+        T::Types::Union::Private::Pool.union_of_types(non_nil_types[0], non_nil_types[1], non_nil_types[2..-1])
+      end
+    end
+
     module Private
       module Pool
         EMPTY_ARRAY = [].freeze
         private_constant :EMPTY_ARRAY
 
+        # Try to use `to_nilable` on a type to get memoization, or failing that
+        # try to at least use SimplePairUnion to get faster init and typechecking.
+        #
+        # We aren't guaranteed to detect a simple `T.nilable(<Module>)` type here
+        # in cases where there are duplicate types, nested unions, etc.
+        #
+        # That's ok, because returning is SimplePairUnion an optimization which
+        # isn't necessary for correctness.
+        #
         # @param type_a [T::Types::Base]
         # @param type_b [T::Types::Base]
         # @param types [Array] optional array of additional T::Types::Base instances
         def self.union_of_types(type_a, type_b, types=EMPTY_ARRAY)
-          if types.empty?
-            # We aren't guaranteed to detect a simple `T.nilable(<Module>)` type here
-            # in cases where there are duplicate types, nested unions, etc.
-            #
-            # That's ok, because this is an optimization which isn't necessary for
-            # correctness.
-            if type_b == T::Utils::Nilable::NIL_TYPE && type_a.is_a?(T::Types::Simple)
+          if !types.empty?
+            # Slow path
+            return Union.new([type_a, type_b] + types)
+          elsif !type_a.is_a?(T::Types::Simple) || !type_b.is_a?(T::Types::Simple)
+            # Slow path
+            return Union.new([type_a, type_b])
+          end
+
+          begin
+            if type_b == T::Utils::Nilable::NIL_TYPE
               type_a.to_nilable
-            elsif type_a == T::Utils::Nilable::NIL_TYPE && type_b.is_a?(T::Types::Simple)
+            elsif type_a == T::Utils::Nilable::NIL_TYPE
               type_b.to_nilable
             else
-              Union.new([type_a, type_b])
+              T::Private::Types::SimplePairUnion.new(type_a, type_b)
             end
-          else
-            # This can't be a `T.nilable(<Module>)` case unless there are duplicates,
-            # which is possible but unexpected.
-            Union.new([type_a, type_b] + types)
+          rescue T::Private::Types::SimplePairUnion::DuplicateType
+            # Slow path
+            #
+            # This shouldn't normally be possible due to static checks,
+            # but we can get here if we're constructing a type dynamically.
+            #
+            # Relying on the duplicate check in the constructor has the
+            # advantage that we avoid it when we hit the memoized case
+            # of `to_nilable`.
+            type_a
           end
         end
       end