sorbet-runtime 0.5.5843 → 0.5.5845

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4aa66cf13c6570f24fd5c7d394119fd49ce3bb595f85cc2cf2584232d3cb9ff4
-  data.tar.gz: b223ba693cdb5e2795f3adbfab10a7b1fc127457821011b26344510ada3495d2
+  metadata.gz: 7ed7cf6960b963bcdb3578b9c02558381dc17b409ac335e47737aa2c01f2bab9
+  data.tar.gz: da99d802502bbb2b64d6360bd2773559033dab41062e9ffbcc01699d55b8bc15
 SHA512:
-  metadata.gz: a58a518764c9fb4309a14f9174cf17080e4e5fca191d189c5562a3aad610f0c153e0a334b9ce6ce1aa78cd7906f52336a8795a1a3f1e513ce7c972a934605b33
-  data.tar.gz: 6f638789b8c7cdece2c89b82d7f49687dcc7183b04b5a3be85e655a809b5f97f2a7f8969a34ddf12016d52de5444d882cf50a7dca61df728e32ed8b1855391d1
+  metadata.gz: 84445df7b4c62dc7f2770c0751c4b5aa9ab67e4dd00e6df257497eb59dc6d399a0576154b221509e576a96ad2953e20b87509a3f229f691a088178163b5ff286
+  data.tar.gz: 14021ce8b6add25886a802dc6ace9cd4eb4d7495e8d44239ebf573aa2a5d27cdd97e579a0ee752e27afe10f0b5b6207e96c898b9000b7986869cba2f0904f109

data/lib/types/_types.rb

@@ -26,12 +26,15 @@
 module T
   # T.any(<Type>, <Type>, ...) -- matches any of the types listed
   def self.any(type_a, type_b, *types)
-    T::Types::Union.new([type_a, type_b] + types)
+    type_a = T::Utils.coerce(type_a)
+    type_b = T::Utils.coerce(type_b)
+    types = types.map {|t| T::Utils.coerce(t)} if !types.empty?
+    T::Types::Union::Private::Pool.union_of_types(type_a, type_b, types)
   end
 
   # Shorthand for T.any(type, NilClass)
   def self.nilable(type)
-    T::Types::Union.new([type, NilClass])
+    T::Types::Union::Private::Pool.union_of_types(T::Utils.coerce(type), T::Utils::Nilable::NIL_TYPE)
   end
 
   # Matches any object. In the static checker, T.untyped allows any

data/lib/types/private/casts.rb

@@ -2,6 +2,14 @@
 # typed: false
 
 module T::Private
+  # Dynamically confirm that `value` is recursively a valid value of
+  # type `type`, including recursively through collections. Note that
+  # in some cases this runtime check can be very expensive, especially
+  # with large collections of objects.
+  def self.check_type_recursive!(value, type)
+    T::Private::Casts.cast_recursive(value, type, cast_method: "T.check_type_recursive!")
+  end
+
   module Casts
     def self.cast(value, type, cast_method:)
       begin
@@ -18,5 +26,24 @@ module T::Private
         value
       end
     end
+
+    # there's a lot of shared logic with the above one, but factoring
+    # it out like this makes it easier to hopefully one day delete
+    # this one
+    def self.cast_recursive(value, type, cast_method:)
+      begin
+        error = T::Utils.coerce(type).error_message_for_obj_recursive(value)
+        return value unless error
+
+        caller_loc = T.must(caller_locations(2..2)).first
+
+        suffix = "Caller: #{T.must(caller_loc).path}:#{T.must(caller_loc).lineno}"
+
+        raise TypeError.new("#{cast_method}: #{error}\n#{suffix}")
+      rescue TypeError => e # raise into rescue to ensure e.backtrace is populated
+        T::Configuration.inline_type_error_handler(e)
+        value
+      end
+    end
   end
 end

data/lib/types/private/types/type_alias.rb

@@ -18,6 +18,11 @@ module T::Private::Types
       aliased_type.name
     end
 
+    # @override Base
+    def recursively_valid?(obj)
+      aliased_type.recursively_valid?(obj)
+    end
+
     # @override Base
     def valid?(obj)
       aliased_type.valid?(obj)

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

@@ -52,7 +52,12 @@ module T::Props
       end
       private_class_method def self.non_nil_proc(prop, accessor_key, non_nil_type, klass, validate)
         proc do |val|
-          if non_nil_type.valid?(val)
+          # this use of recursively_valid? is intentional: unlike for
+          # methods, we want to make sure data at the 'edge'
+          # (e.g. models that go into databases or structs serialized
+          # from disk) are correct, so we use more thorough runtime
+          # checks there
+          if non_nil_type.recursively_valid?(val)
             if validate
               validate.call(prop, val)
             end
@@ -83,7 +88,12 @@ module T::Props
         proc do |val|
           if val.nil?
             instance_variable_set(accessor_key, nil)
-          elsif non_nil_type.valid?(val)
+          # this use of recursively_valid? is intentional: unlike for
+          # methods, we want to make sure data at the 'edge'
+          # (e.g. models that go into databases or structs serialized
+          # from disk) are correct, so we use more thorough runtime
+          # checks there
+          elsif non_nil_type.recursively_valid?(val)
             if validate
               validate.call(prop, val)
             end

data/lib/types/types/base.rb

@@ -16,6 +16,11 @@ module T::Types
       end
     end
 
+    # this will be redefined in certain subclasses
+    def recursively_valid?(obj)
+      valid?(obj)
+    end
+
     def valid?(obj)
       raise NotImplementedError
     end
@@ -130,6 +135,14 @@ module T::Types
       end
     end
 
+    def error_message_for_obj_recursive(obj)
+      if recursively_valid?(obj)
+        nil
+      else
+        "Expected type #{self.name}, got #{describe_obj(obj)}"
+      end
+    end
+
     def validate!(obj)
       err = error_message_for_obj(obj)
       raise TypeError.new(err) if err

data/lib/types/types/fixed_array.rb

@@ -17,6 +17,22 @@ module T::Types
       "[#{@types.join(', ')}]"
     end
 
+    # @override Base
+    def recursively_valid?(obj)
+      if obj.is_a?(Array) && obj.length == @types.length
+        i = 0
+        while i < @types.length
+          if !@types[i].recursively_valid?(obj[i])
+            return false
+          end
+          i += 1
+        end
+        true
+      else
+        false
+      end
+    end
+
     # @override Base
     def valid?(obj)
       if obj.is_a?(Array) && obj.length == @types.length

data/lib/types/types/fixed_hash.rb

@@ -16,6 +16,14 @@ module T::Types
       "{#{@types.map {|(k, v)| "#{k}: #{v}"}.join(', ')}}"
     end
 
+    # @override Base
+    def recursively_valid?(obj)
+      return false unless obj.is_a?(Hash)
+      return false if @types.any? {|key, type| !type.recursively_valid?(obj[key])}
+      return false if obj.any? {|key, _| !@types[key]}
+      true
+    end
+
     # @override Base
     def valid?(obj)
       return false unless obj.is_a?(Hash)

data/lib/types/types/intersection.rb

@@ -23,6 +23,11 @@ module T::Types
       "T.all(#{@types.map(&:name).sort.join(', ')})"
     end
 
+    # @override Base
+    def recursively_valid?(obj)
+      @types.all? {|type| type.recursively_valid?(obj)}
+    end
+
     # @override Base
     def valid?(obj)
       @types.all? {|type| type.valid?(obj)}

data/lib/types/types/simple.rb

@@ -29,5 +29,22 @@ module T::Types
         false
       end
     end
+
+    def to_nilable
+      @nilable ||= T::Types::Union.new([self, T::Utils::Nilable::NIL_TYPE])
+    end
+
+    module Private
+      module Pool
+        def self.type_for_module(mod)
+          cached = mod.instance_variable_get(:@__as_sorbet_simple_type)
+          return cached if cached
+
+          type = Simple.new(mod)
+          mod.instance_variable_set(:@__as_sorbet_simple_type, type) unless mod.frozen?
+          type
+        end
+      end
+    end
   end
 end

data/lib/types/types/typed_array.rb

@@ -13,10 +13,15 @@ module T::Types
     end
 
     # @override Base
-    def valid?(obj)
+    def recursively_valid?(obj)
       obj.is_a?(Array) && super
     end
 
+    # @override Base
+    def valid?(obj)
+      obj.is_a?(Array)
+    end
+
     def new(*args) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
       Array.new(*T.unsafe(args))
     end

data/lib/types/types/typed_enumerable.rb

@@ -23,13 +23,18 @@ module T::Types
 
     # @override Base
     def valid?(obj)
+      obj.is_a?(Enumerable)
+    end
+
+    # @override Base
+    def recursively_valid?(obj)
       return false unless obj.is_a?(Enumerable)
       case obj
       when Array
         begin
           it = 0
           while it < obj.count
-            return false unless @type.valid?(obj[it])
+            return false unless @type.recursively_valid?(obj[it])
             it += 1
           end
           return true
@@ -42,8 +47,8 @@ module T::Types
         value_type = types[1]
         obj.each_pair do |key, val|
           # Some objects (I'm looking at you Rack::Utils::HeaderHash) don't
-          # iterate over a [key, value] array, so we can't juse use the @type.valid?(v)
-          return false if !key_type.valid?(key) || !value_type.valid?(val)
+          # iterate over a [key, value] array, so we can't juse use the @type.recursively_valid?(v)
+          return false if !key_type.recursively_valid?(key) || !value_type.recursively_valid?(val)
         end
         return true
       when Enumerator
@@ -54,10 +59,10 @@ module T::Types
         # boundlessness, it does not express a type. For example `(nil...nil)` is not a T::Range[NilClass], its a range
         # of unknown types (T::Range[T.untyped]).
         # Similarly, `(nil...1)` is not a `T::Range[T.nilable(Integer)]`, it's a boundless range of Integer.
-        (obj.begin.nil? || @type.valid?(obj.begin)) && (obj.end.nil? || @type.valid?(obj.end))
+        (obj.begin.nil? || @type.recursively_valid?(obj.begin)) && (obj.end.nil? || @type.recursively_valid?(obj.end))
       when Set
         obj.each do |item|
-          return false unless @type.valid?(item)
+          return false unless @type.recursively_valid?(item)
         end
 
         return true

data/lib/types/types/typed_enumerator.rb

@@ -15,10 +15,15 @@ module T::Types
     end
 
     # @override Base
-    def valid?(obj)
+    def recursively_valid?(obj)
       obj.is_a?(Enumerator) && super
     end
 
+    # @override Base
+    def valid?(obj)
+      obj.is_a?(Enumerator)
+    end
+
     def new(*args, &blk) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
       T.unsafe(Enumerator).new(*args, &blk)
     end

data/lib/types/types/typed_hash.rb

@@ -22,10 +22,15 @@ module T::Types
     end
 
     # @override Base
-    def valid?(obj)
+    def recursively_valid?(obj)
       obj.is_a?(Hash) && super
     end
 
+    # @override Base
+    def valid?(obj)
+      obj.is_a?(Hash)
+    end
+
     def new(*args, &blk) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
       Hash.new(*T.unsafe(args), &blk) # rubocop:disable PrisonGuard/RestrictHashDefaults
     end

data/lib/types/types/typed_range.rb

@@ -15,10 +15,15 @@ module T::Types
     end
 
     # @override Base
-    def valid?(obj)
+    def recursively_valid?(obj)
       obj.is_a?(Range) && super
     end
 
+    # @override Base
+    def valid?(obj)
+      obj.is_a?(Range)
+    end
+
     def new(*args) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
       T.unsafe(Range).new(*args)
     end

data/lib/types/types/typed_set.rb

@@ -15,10 +15,15 @@ module T::Types
     end
 
     # @override Base
-    def valid?(obj)
+    def recursively_valid?(obj)
       obj.is_a?(Set) && super
     end
 
+    # @override Base
+    def valid?(obj)
+      obj.is_a?(Set)
+    end
+
     def new(*args) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
       Set.new(*T.unsafe(args))
     end

data/lib/types/types/union.rb

@@ -42,6 +42,11 @@ module T::Types
       end
     end
 
+    # @override Base
+    def recursively_valid?(obj)
+      @types.any? {|type| type.recursively_valid?(obj)}
+    end
+
     # @override Base
     def valid?(obj)
       @types.any? {|type| type.valid?(obj)}
@@ -52,5 +57,35 @@ module T::Types
       raise "This should never be reached if you're going through `subtype_of?` (and you should be)"
     end
 
+    module Private
+      module Pool
+        EMPTY_ARRAY = [].freeze
+        private_constant :EMPTY_ARRAY
+
+        # @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)
+              type_a.to_nilable
+            elsif type_a == T::Utils::Nilable::NIL_TYPE && type_b.is_a?(T::Types::Simple)
+              type_b.to_nilable
+            else
+              Union.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)
+          end
+        end
+      end
+    end
   end
 end

data/lib/types/utils.rb

@@ -21,7 +21,7 @@ module T::Utils
     elsif val == ::Range
       T::Range[T.untyped]
     elsif val.is_a?(Module)
-      T::Types::Simple.new(val) # rubocop:disable PrisonGuard/UseOpusTypesShortcut
+      T::Types::Simple::Private::Pool.type_for_module(val)
     elsif val.is_a?(::Array)
       T::Types::FixedArray.new(val) # rubocop:disable PrisonGuard/UseOpusTypesShortcut
     elsif val.is_a?(::Hash)
@@ -162,7 +162,7 @@ module T::Utils
     elsif classes.length > 1
       T::Types::Union.new(classes)
     else
-      T::Types::Simple.new(classes.first)
+      T::Types::Simple::Private::Pool.type_for_module(classes.first)
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.5.5843
+  version: 0.5.5845
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-23 00:00:00.000000000 Z
+date: 2020-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest