sorbet-runtime 0.5.5843 → 0.5.5855

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4aa66cf13c6570f24fd5c7d394119fd49ce3bb595f85cc2cf2584232d3cb9ff4
-  data.tar.gz: b223ba693cdb5e2795f3adbfab10a7b1fc127457821011b26344510ada3495d2
+  metadata.gz: 05211daadd19374c8196176c89361938ef05fd1c5fa4c02f9e9d581bcf4114bf
+  data.tar.gz: 33f7feb752c822c281276f990b99c3ceeab66a4dd63359c00cfad66643680231
 SHA512:
-  metadata.gz: a58a518764c9fb4309a14f9174cf17080e4e5fca191d189c5562a3aad610f0c153e0a334b9ce6ce1aa78cd7906f52336a8795a1a3f1e513ce7c972a934605b33
-  data.tar.gz: 6f638789b8c7cdece2c89b82d7f49687dcc7183b04b5a3be85e655a809b5f97f2a7f8969a34ddf12016d52de5444d882cf50a7dca61df728e32ed8b1855391d1
+  metadata.gz: 908de44e4d49035037a83f508074c273af88c8ff465147e569ecb062e6a19c818bdd0e8812830f5ce23b582fec0010e04dd9191e24095b024e04bcb07ed9ef69
+  data.tar.gz: 8a77c89234429113ac224c877a02a0fefa81fc4cc066e1c2a3b0e1b7b94129372396523e260e5280a6487f7cc41b8de2cc0efb1af63214108b664407657fa97b

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/methods/_methods.rb

@@ -206,22 +206,12 @@ module T::Private::Methods
     # (or unwrap back to the original method).
     new_method = nil
     T::Private::ClassUtils.replace_method(mod, method_name) do |*args, &blk|
-      if !T::Private::Methods.has_sig_block_for_method(new_method)
-        # This should only happen if the user used alias_method to grab a handle
-        # to the original pre-unwound `sig` method. I guess we'll just proxy the
-        # call forever since we don't know who is holding onto this handle to
-        # replace it.
-        new_new_method = mod.instance_method(method_name)
-        if new_method == new_new_method
-          raise "`sig` not present for method `#{method_name}` but you're trying to run it anyways. " \
-          "This should only be executed if you used `alias_method` to grab a handle to a method after `sig`ing it, but that clearly isn't what you are doing. " \
-          "Maybe look to see if an exception was thrown in your `sig` lambda or somehow else your `sig` wasn't actually applied to the method. " \
-          "Contact #dev-productivity if you're really stuck."
-        end
-        return new_new_method.bind(self).call(*args, &blk)
-      end
-
-      method_sig = T::Private::Methods.run_sig_block_for_method(new_method)
+      method_sig = T::Private::Methods.maybe_run_sig_block_for_method(new_method)
+      method_sig ||= T::Private::Methods._handle_missing_method_signature(
+        is_singleton_method ? self.singleton_class : self.class,
+        original_method,
+        __callee__,
+      )
 
       # Should be the same logic as CallValidation.wrap_method_if_needed but we
       # don't want that extra layer of indirection in the callstack
@@ -252,6 +242,33 @@ module T::Private::Methods
     end
   end
 
+  def self._handle_missing_method_signature(klass, original_method, callee)
+    method_sig = T::Private::Methods.signature_for_method(original_method)
+
+    aliasing_method = klass.instance_method(callee)
+    aliasing_mod = aliasing_method.owner
+
+    if method_sig && aliasing_method != original_method && aliasing_method.original_name == original_method.name
+      # We're handling a case where `alias` or `alias_method` was called for a
+      # method which had already had a `sig` applied.
+      #
+      # Note, this logic is duplicated above, make sure to keep changes in sync.
+      if method_sig.check_level == :always || (method_sig.check_level == :tests && T::Private::RuntimeLevels.check_tests?)
+        # Checked, so copy the original signature to the aliased copy.
+        T::Private::Methods.unwrap_method(aliasing_mod, method_sig, aliasing_method)
+      else
+        # Unchecked, so just make `alias_method` behave as if it had been called pre-sig.
+        aliasing_mod.send(:alias_method, callee, original_method.name)
+      end
+    else
+      raise "`sig` not present for method `#{aliasing_method.name}` but you're trying to run it anyways. " \
+        "This should only be executed if you used `alias_method` to grab a handle to a method after `sig`ing it, but that clearly isn't what you are doing. " \
+        "Maybe look to see if an exception was thrown in your `sig` lambda or somehow else your `sig` wasn't actually applied to the method."
+    end
+
+    method_sig
+  end
+
   # Executes the `sig` block, and converts the resulting Declaration
   # to a Signature.
   def self.run_sig(hook_mod, method_name, original_method, declaration_block)

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

@@ -146,9 +146,10 @@ class T::Private::Methods::Signature
     # can't) match the definition of the method we're validating. In addition, Ruby has a bug that
     # causes forwarding **kwargs to do the wrong thing: see https://bugs.ruby-lang.org/issues/10708
     # and https://bugs.ruby-lang.org/issues/11860.
-    if (args.length > @req_arg_count) && (!@kwarg_types.empty? || @has_keyrest) && args[-1].is_a?(Hash)
+    args_length = args.length
+    if (args_length > @req_arg_count) && (!@kwarg_types.empty? || @has_keyrest) && args[-1].is_a?(Hash)
       kwargs = args[-1]
-      args = args[0...-1]
+      args_length -= 1
     else
       kwargs = EMPTY_HASH
     end
@@ -156,19 +157,19 @@ class T::Private::Methods::Signature
     arg_types = @arg_types
 
     if @has_rest
-      arg_types += [[@rest_name, @rest_type]] * (args.length - @arg_types.length)
+      arg_types += [[@rest_name, @rest_type]] * (args_length - @arg_types.length)
 
-    elsif (args.length < @req_arg_count) || (args.length > @arg_types.length)
+    elsif (args_length < @req_arg_count) || (args_length > @arg_types.length)
       expected_str = @req_arg_count.to_s
       if @arg_types.length != @req_arg_count
         expected_str += "..#{@arg_types.length}"
       end
-      raise ArgumentError.new("wrong number of arguments (given #{args.length}, expected #{expected_str})")
+      raise ArgumentError.new("wrong number of arguments (given #{args_length}, expected #{expected_str})")
     end
 
     begin
       it = 0
-      while it < args.length
+      while it < args_length
         yield arg_types[it][0], args[it], arg_types[it][1]
         it += 1
       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

@@ -12,7 +12,11 @@ module T::Types
 
     # @override Base
     def name
-      @raw_type.name
+      # Memoize to mitigate pathological performance with anonymous modules (https://bugs.ruby-lang.org/issues/11119)
+      #
+      # `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
     end
 
     # @override Base
@@ -29,5 +33,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.5855
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-23 00:00:00.000000000 Z
+date: 2020-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest