sorbet-runtime 0.5.5651 → 0.5.5676

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 181d169545984c142df587bedf3995e13a6c18c15b59fb04816e712104a11dc3
-  data.tar.gz: 47fecc926152e65fd6db14c2df9ed8f870105272bc09c07ef9bbf11e2748aade
+  metadata.gz: baa75d2b35b1bf7be0cbf722cb142f6ef3084cfc4cef71930d1f347fd12ef7d8
+  data.tar.gz: 620be4e8cb01307b5e25d73db2744d989c98efd5f47a9bba078eb13df45dc622
 SHA512:
-  metadata.gz: a741a233e4bc0e8b4efb1b0fdbaa785c361828ff8eb93d7effc1e90cdfc4166b6aa0e4e1356487294b33049ecefd070b060bf46b307172f787181b55223419b6
-  data.tar.gz: 85ba00d5ed36916c261d5d1ccb752def465eb4276a230477135f995b47c7fb180d53dd15262d2b9d5d85a5a0682f6bdfabe7ccd3d0d80c874025bdf710cec096
+  metadata.gz: 7f5ac551c51e9a29e970860007e9e9d994e602810202a453005210ff78fdc6f800e37aa6bc52496718e88fed140bad4dddf33e44a8d4ec8ea51a2b6e87b6be1b
+  data.tar.gz: cbb25f6f9e0f0d13fb6e2a7ff97618fdc13d7ac689070af079a5e1078d3ea5c0f6efe77b5d312c1fa424b514acda3bafda69a818a5342a930b42f039f51b1bb9

data/lib/types/compatibility_patches.rb

@@ -4,7 +4,8 @@
 require_relative 'private/methods/_methods'
 
 # Work around an interaction bug with sorbet-runtime and rspec-mocks,
-# which occurs when using *_any_instance_of and and_call_original.
+# which occurs when using message expectations (*_any_instance_of,
+# expect, allow) and and_call_original.
 #
 # When a sig is defined, sorbet-runtime will replace the sigged method
 # with a wrapper that, upon first invocation, re-wraps the method with a faster
@@ -22,17 +23,30 @@ require_relative 'private/methods/_methods'
 #
 # We work around this by forcing re-wrapping before rspec stores a reference
 # to the method.
-if defined? ::RSpec::Mocks::AnyInstance
+if defined? ::RSpec::Mocks
   module T
     module CompatibilityPatches
-      module RecorderExtensions
-        def observe!(method_name)
-          method = @klass.instance_method(method_name.to_sym)
-          T::Private::Methods.maybe_run_sig_block_for_method(method)
-          super(method_name)
+      module RSpecCompatibility
+        module RecorderExtensions
+          def observe!(method_name)
+            method = @klass.instance_method(method_name.to_sym)
+            T::Private::Methods.maybe_run_sig_block_for_method(method)
+            super(method_name)
+          end
         end
+        ::RSpec::Mocks::AnyInstance::Recorder.prepend(RecorderExtensions) if defined?(::RSpec::Mocks::AnyInstance::Recorder)
+
+        module MethodDoubleExtensions
+          def initialize(object, method_name, proxy)
+            if ::Kernel.instance_method(:respond_to?).bind(object).call(method_name, true)
+              method = ::RSpec::Support.method_handle_for(object, method_name)
+              T::Private::Methods.maybe_run_sig_block_for_method(method)
+            end
+            super(object, method_name, proxy)
+          end
+        end
+        ::RSpec::Mocks::MethodDouble.prepend(MethodDoubleExtensions) if defined?(::RSpec::Mocks::MethodDouble)
       end
-      ::RSpec::Mocks::AnyInstance::Recorder.prepend(RecorderExtensions)
     end
   end
 end

data/lib/types/props/decorator.rb

@@ -66,7 +66,6 @@ class T::Props::Decorator
     without_accessors
     clobber_existing_method!
     extra
-    optional
     setter_validate
     _tnilable
   }.map {|k| [k, true]}.to_h.freeze, T::Hash[Symbol, T::Boolean])
@@ -220,12 +219,6 @@ class T::Props::Decorator
       raise ArgumentError.new("At least one invalid prop arg supplied in #{self}: #{rules.keys.inspect}")
     end
 
-    if (array = rules[:array])
-      unless array.is_a?(Module)
-        raise ArgumentError.new("Bad class as subtype in prop #{@class.name}.#{name}: #{array.inspect}")
-      end
-    end
-
     if !(rules[:clobber_existing_method!]) && !(rules[:without_accessors])
       if BANNED_METHOD_NAMES.include?(name.to_sym)
         raise ArgumentError.new(
@@ -295,47 +288,6 @@ class T::Props::Decorator
   end
   def prop_defined(name, cls, rules={})
     cls = T::Utils.resolve_alias(cls)
-    if rules[:optional] == true
-      T::Configuration.hard_assert_handler(
-        'Use of `optional: true` is deprecated, please use `T.nilable(...)` instead.',
-        storytime: {
-          name: name,
-          cls_or_args: cls.to_s,
-          args: rules,
-          klass: decorated_class.name,
-        },
-      )
-    elsif rules[:optional] == false
-      T::Configuration.hard_assert_handler(
-        'Use of `optional: :false` is deprecated as it\'s the default value.',
-        storytime: {
-          name: name,
-          cls_or_args: cls.to_s,
-          args: rules,
-          klass: decorated_class.name,
-        },
-      )
-    elsif rules[:optional] == :on_load
-      T::Configuration.hard_assert_handler(
-        'Use of `optional: :on_load` is deprecated. You probably want `T.nilable(...)` with :raise_on_nil_write instead.',
-        storytime: {
-          name: name,
-          cls_or_args: cls.to_s,
-          args: rules,
-          klass: decorated_class.name,
-        },
-      )
-    elsif rules[:optional] == :existing
-      T::Configuration.hard_assert_handler(
-        'Use of `optional: :existing` is not allowed: you should use use T.nilable (http://go/optional)',
-        storytime: {
-          name: name,
-          cls_or_args: cls.to_s,
-          args: rules,
-          klass: decorated_class.name,
-        },
-      )
-    end
 
     if T::Utils::Nilable.is_union_with_nilclass(cls)
       # :_tnilable is introduced internally for performance purpose so that clients do not need to call
@@ -350,7 +302,7 @@ class T::Props::Decorator
     if !cls.is_a?(Module)
       cls = convert_type_to_class(cls)
     end
-    type_object = smart_coerce(type, array: rules[:array], enum: rules[:enum])
+    type_object = smart_coerce(type, enum: rules[:enum])
 
     prop_validate_definition!(name, cls, rules, type_object)
 
@@ -441,27 +393,21 @@ class T::Props::Decorator
   end
 
   sig do
-    params(type: PropTypeOrClass, array: T.untyped, enum: T.untyped)
+    params(type: PropTypeOrClass, enum: T.untyped)
     .returns(T::Types::Base)
   end
-  private def smart_coerce(type, array:, enum:)
+  private def smart_coerce(type, enum:)
     # Backwards compatibility for pre-T::Types style
-    if !array.nil? && !enum.nil?
-      raise ArgumentError.new("Cannot specify both :array and :enum options")
-    elsif !array.nil?
-      if type == Set
-        T::Set[array]
-      else
-        T::Array[array]
-      end
-    elsif !enum.nil?
-      if T::Utils.unwrap_nilable(type)
-        T.nilable(T.enum(enum))
+    type = T::Utils.coerce(type)
+    if enum.nil?
+      type
+    else
+      nonnil_type = T::Utils.unwrap_nilable(type)
+      if nonnil_type
+        T.nilable(T.all(nonnil_type, T.enum(enum)))
       else
-        T.enum(enum)
+        T.all(type, T.enum(enum))
       end
-    else
-      T::Utils.coerce(type)
     end
   end
 

data/lib/types/props/optional.rb

@@ -14,19 +14,9 @@ end
 module T::Props::Optional::DecoratorMethods
   extend T::Sig
 
-  # TODO: clean this up. This set of options is confusing, and some of them are not universally
-  # applicable (e.g., :on_load only applies when using T::Serializable).
-  VALID_OPTIONAL_RULES = Set[
-    :existing, # deprecated
-    :on_load,
-    false,
-    true,
-  ].freeze
-
   VALID_RULE_KEYS = {
     default: true,
     factory: true,
-    optional: true,
   }.freeze
   private_constant :VALID_RULE_KEYS
 
@@ -74,12 +64,6 @@ module T::Props::Optional::DecoratorMethods
   def prop_validate_definition!(name, cls, rules, type)
     result = super
 
-    if (rules_optional = rules[:optional])
-      if !VALID_OPTIONAL_RULES.include?(rules_optional)
-        raise ArgumentError.new(":optional must be one of #{VALID_OPTIONAL_RULES.inspect}")
-      end
-    end
-
     if rules.key?(:default) && rules.key?(:factory)
       raise ArgumentError.new("Setting both :default and :factory is invalid. See: go/chalk-docs")
     end

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

@@ -26,7 +26,7 @@ module T::Props
 
       sig do
         params(
-          type: T.any(T::Types::Base, Module),
+          type: T::Types::Base,
           mode: ModeType,
           varname: String,
         )
@@ -99,15 +99,42 @@ module T::Props
               "T::Props::Utils.deep_clone_object(#{varname})"
             end
           end
+        when T::Types::Intersection
+          dynamic_fallback = "T::Props::Utils.deep_clone_object(#{varname})"
+
+          # Transformations for any members of the intersection type where we
+          # know what we need to do and did not have to fall back to the
+          # dynamic deep clone method.
+          #
+          # NB: This deliberately does include `nil`, which means we know we
+          # don't need to do any transforming.
+          inner_known = type.types
+            .map {|t| generate(t, mode, varname)}
+            .reject {|t| t == dynamic_fallback}
+            .uniq
+
+          if inner_known.size != 1
+            # If there were no cases where we could tell what we need to do,
+            # e.g. if this is `T.all(SomethingWeird, WhoKnows)`, just use the
+            # dynamic fallback.
+            #
+            # If there were multiple cases and they weren't consistent, e.g.
+            # if this is `T.all(String, T::Array[Integer])`, the type is probably
+            # bogus/uninhabited, but use the dynamic fallback because we still
+            # don't have a better option, and this isn't the place to raise that
+            # error.
+            dynamic_fallback
+          else
+            # This is probably something like `T.all(String, SomeMarker)` or
+            # `T.all(SomeEnum, T.enum(SomeEnum::FOO))` and we should treat it
+            # like String or SomeEnum even if we don't know what to do with
+            # the rest of the type.
+            inner_known.first
+          end
         when T::Types::Enum
           generate(T::Utils.lift_enum(type), mode, varname)
         else
-          if type.singleton_class < T::Props::CustomType
-            # Sometimes this comes wrapped in a T::Types::Simple and sometimes not
-            handle_custom_type(varname, T.unsafe(type), mode)
-          else
-            "T::Props::Utils.deep_clone_object(#{varname})"
-          end
+          "T::Props::Utils.deep_clone_object(#{varname})"
         end
       end
 

data/lib/types/props/type_validation.rb

@@ -63,7 +63,16 @@ module T::Props::TypeValidation
       when T::Types::FixedHash
         type.types.values.map {|subtype| find_invalid_subtype(subtype)}.compact.first
       when T::Types::Union, T::Types::FixedArray
+        # `T.any` is valid if all of the members are valid
         type.types.map {|subtype| find_invalid_subtype(subtype)}.compact.first
+      when T::Types::Intersection
+        # `T.all` is valid if at least one of the members is valid
+        invalid = type.types.map {|subtype| find_invalid_subtype(subtype)}.compact
+        if invalid.length == type.types.length
+          invalid.first
+        else
+          nil
+        end
       when T::Types::Enum, T::Types::ClassOf
         nil
       when T::Private::Types::TypeAlias

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.5.5651
+  version: 0.5.5676
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-19 00:00:00.000000000 Z
+date: 2020-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest