sorbet-runtime 0.5.5429 → 0.5.5794

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f7f54d40d5dbaf968c3ab004187df66db620ff62a74860b03f6c80f4cb59d0b2
-  data.tar.gz: 278a695d5bf4f93bfdd2a03f225850e0d7f54b6ee60fa9b838e07b16a55b0370
+  metadata.gz: ac9a48252c9529d0ca91f96108b141c85388c88180281e5c8a682b16c11a9d5a
+  data.tar.gz: 31dc95eabc00327b1672a8fc142da7dc47f0ee0699fd4112358042248628675b
 SHA512:
-  metadata.gz: 99bc296b66501a1e58616bbeebef572e8b7154bbeab2405a2c92290a9331e57be59670b081f27003270e32998666a6363da2d38e2d1dfa4489a01c04f3c46a19
-  data.tar.gz: e7b6c400aaa036ad2b9fa50d43061785cc4e6fdce0e2afefda2dc515b5875ab7b42c741249d5fd3d603c6f37d517b340b52cbbb13084396b3ef54e45553f07dc
+  metadata.gz: 21b1ef4ffdd76365effafe0c6a3eea4b15c1f9c36f2f402a1c8ba382d2f03d89f2202c1b8ac2aa82c315c7471f0989f7501d1888a49f67d401d33d26ac8e4d3a
+  data.tar.gz: 0f4c110725910ae452ea72fe6852538aa1c31cbb576dc242fe3631bd318e3b2bfda7b0fe3b05362584bd53885c9788a4f3eb2d5920d285c1c39ce727fb0ebd14

data/lib/sorbet-runtime.rb

@@ -80,6 +80,7 @@ require_relative 'types/private/abstract/hooks'
 require_relative 'types/private/casts'
 require_relative 'types/private/methods/decl_builder'
 require_relative 'types/private/methods/signature'
+require_relative 'types/private/retry'
 require_relative 'types/utils'
 require_relative 'types/boolean'
 
@@ -110,5 +111,6 @@ 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

@@ -103,7 +103,7 @@ module T
     end
   end
 
-  # References a type paramater which was previously defined with
+  # References a type parameter which was previously defined with
   # `type_parameters`.
   #
   # This is used for generic methods. Example usage:

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,73 @@ 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
+    end
+  end
+end
+
+# Work around for sorbet-runtime wrapped methods.
+#
+# When a sig is defined, sorbet-runtime will replace the sigged method
+# with a wrapper. Those wrapper methods look like `foo(*args, &blk)`
+# so that wrappers can handle and pass on all the arguments supplied.
+#
+# However, that creates a problem with runtime reflection on the methods,
+# since when a sigged method is introspected, it will always return its
+# `arity` as `-1`, its `parameters` as `[[:rest, :args], [:block, :blk]]`,
+# and its `source_location` as `[<some_file_in_sorbet>, <some_line_number>]`.
+#
+# This might be a problem for some applications that rely on getting the
+# correct information from these methods.
+#
+# This compatibility module, when prepended to the `Method` class, would fix
+# the return values of `arity`, `parameters` and `source_location`.
+#
+# @example
+#   require 'sorbet-runtime'
+#   ::Method.prepend(T::CompatibilityPatches::MethodExtensions)
+module T
+  module CompatibilityPatches
+    module MethodExtensions
+      def arity
+        arity = super
+        return arity if arity != -1 || self.is_a?(Proc)
+        sig = T::Private::Methods.signature_for_method(self)
+        sig ? sig.method.arity : arity
+      end
+
+      def source_location
+        sig = T::Private::Methods.signature_for_method(self)
+        sig ? sig.method.source_location : super
+      end
+
+      def parameters
+        sig = T::Private::Methods.signature_for_method(self)
+        sig ? sig.method.parameters : super
       end
-      ::RSpec::Mocks::AnyInstance::Recorder.prepend(RecorderExtensions)
     end
   end
 end

data/lib/types/configuration.rb

@@ -336,7 +336,7 @@ module T::Configuration
   #   T::Configuration.scalar_types = ["NilClass", "TrueClass", "FalseClass", ...]
   def self.scalar_types=(values)
     if values.nil?
-      @scalar_tyeps = values
+      @scalar_types = values
     else
       bad_values = values.select {|v| v.class != String}
       unless bad_values.empty?

data/lib/types/enum.rb

@@ -97,17 +97,8 @@ class T::Enum
     @mapping.include?(serialized_val)
   end
 
-
-  ## T::Props::CustomType
-
-  # Note: Failed CriticalMethodsNoRuntimeTypingTest
-  sig {params(value: T.untyped).returns(T::Boolean).checked(:never)}
-  def self.instance?(value)
-    value.is_a?(self)
-  end
-
   # Note: Failed CriticalMethodsNoRuntimeTypingTest
-  sig {params(instance: T.nilable(T::Enum)).returns(SerializedVal).checked(:never)}
+  sig {override.params(instance: T.nilable(T::Enum)).returns(SerializedVal).checked(:never)}
   def self.serialize(instance)
     # This is needed otherwise if a Chalk::ODM::Document with a property of the shape
     # T::Hash[T.nilable(MyEnum), Integer] and a value that looks like {nil => 0} is
@@ -124,7 +115,7 @@ class T::Enum
   end
 
   # Note: Failed CriticalMethodsNoRuntimeTypingTest
-  sig {params(mongo_value: SerializedVal).returns(T.attached_class).checked(:never)}
+  sig {override.params(mongo_value: SerializedVal).returns(T.attached_class).checked(:never)}
   def self.deserialize(mongo_value)
     if self == T::Enum
       raise "Cannot call T::Enum.deserialize directly. You must call on a specific child class."

data/lib/types/non_forcing_constants.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+# typed: strict
+
+module T::NonForcingConstants
+  # NOTE: This method is documented on the RBI in Sorbet's payload, so that it
+  # shows up in the hover/completion documentation via LSP.
+  T::Sig::WithoutRuntime.sig {params(val: BasicObject, klass: String).returns(T::Boolean)}
+  def self.non_forcing_is_a?(val, klass)
+    method_name = "T::NonForcingConstants.non_forcing_is_a?"
+    if klass.empty?
+      raise ArgumentError.new("The string given to `#{method_name}` must not be empty")
+    end
+
+    current_klass = T.let(nil, T.nilable(Module))
+    current_prefix = T.let(nil, T.nilable(String))
+
+    parts = klass.split('::')
+    parts.each do |part|
+      if current_klass.nil?
+        # First iteration
+        if part != ""
+          raise ArgumentError.new("The string given to `#{method_name}` must be an absolute constant reference that starts with `::`")
+        end
+
+        current_klass = Object
+        current_prefix = ''
+      else
+        if current_klass.autoload?(part)
+          # There's an autoload registered for that constant, which means it's not
+          # yet loaded. `value` can't be an instance of something not yet loaded.
+          return false
+        end
+
+        # Sorbet guarantees that the string is an absolutely resolved name.
+        search_inheritance_chain = false
+        if !current_klass.const_defined?(part, search_inheritance_chain)
+          return false
+        end
+
+        current_klass = current_klass.const_get(part)
+        current_prefix = "#{current_prefix}::#{part}"
+
+        if !Module.===(current_klass)
+          raise ArgumentError.new("#{current_prefix} is not a class or module")
+        end
+      end
+    end
+
+    return current_klass.===(val)
+  end
+end

data/lib/types/private/abstract/declare.rb

@@ -40,6 +40,9 @@ module T::Private::Abstract::Declare
         end
         super(*args, &blk)
       end
+      if mod.respond_to?(:ruby2_keywords, true)
+        mod.send(:ruby2_keywords, :initialize)
+      end
     end
   end
 end

data/lib/types/private/class_utils.rb

@@ -98,6 +98,9 @@ module T::Private::ClassUtils
     T::Configuration.without_ruby_warnings do
       T::Private::DeclState.current.without_on_method_added do
         mod.send(:define_method, name, &blk) # rubocop:disable PrisonGuard/UsePublicSend
+        if blk.arity < 0 && mod.respond_to?(:ruby2_keywords, true)
+          mod.send(:ruby2_keywords, name)
+        end
       end
     end
     mod.send(original_visibility, name) # rubocop:disable PrisonGuard/UsePublicSend

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

@@ -185,6 +185,9 @@ module T::Private::Methods::CallValidation
     mod.send(:define_method, method_sig.method_name) do |*args, &blk|
       CallValidation.validate_call(self, original_method, method_sig, args, blk)
     end
+    if mod.respond_to?(:ruby2_keywords, true)
+      mod.send(:ruby2_keywords, method_sig.method_name)
+    end
   end
 
   def self.create_validator_method_fast(mod, original_method, method_sig)

data/lib/types/private/retry.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Private::Retry
+
+  # A special singleton used for static analysis of exceptions.
+  module RETRY
+    freeze
+  end
+end

data/lib/types/props/_props.rb

@@ -39,7 +39,7 @@ module T::Props
     # a document class.
     #
     # @param name [Symbol] The name of this property
-    # @param cls [Class,T::Props::CustomType] (String) The type of this
+    # @param cls [Class,T::Types::Base] The type of this
     #   property. If the type is itself a {Document} subclass, this
     #   property will be recursively serialized/deserialized.
     # @param rules [Hash] Options to control this property's behavior.
@@ -90,10 +90,6 @@ module T::Props
     #   none is provided.
     # @option rules [T::Boolean] :immutable If true, this prop cannot be
     #   modified after an instance is created or loaded from a hash.
-    # @option rules [Class,T::Props::CustomType] :array If set, specifies the
-    #   type of individual members of a prop with `type` `Array`. This
-    #   allows for typechecking of arrays, and also for recursive
-    #   serialization of arrays of sub-{Document}s.
     # @option rules [T::Boolean] :override It is an error to redeclare a
     #   `prop` that has already been declared (including on a
     #   superclass), unless `:override` is set to `true`.

data/lib/types/props/custom_type.rb

@@ -1,20 +1,35 @@
 # frozen_string_literal: true
-# typed: false
+# typed: strict
 
 module T::Props
   module CustomType
+    extend T::Sig
+    extend T::Helpers
+
+    abstract!
+
     include Kernel # for `is_a?`
 
-    # Returns true if the given Ruby value can be assigned to a T::Props field
-    # of this type.
-    #
-    # @param [Object] _value
-    # @return T::Boolean
-    def instance?(_value)
-      raise NotImplementedError.new('Must override in included class')
+    # Alias for backwards compatibility
+    sig(:final) do
+      params(
+        value: BasicObject,
+      )
+      .returns(T::Boolean)
+      .checked(:never)
+    end
+    def instance?(value)
+      self.===(value)
     end
 
-    # Alias for consistent interface with T::Types::Base
+    # Alias for backwards compatibility
+    sig(:final) do
+      params(
+        value: BasicObject,
+      )
+      .returns(T::Boolean)
+      .checked(:never)
+    end
     def valid?(value)
       instance?(value)
     end
@@ -24,30 +39,30 @@ module T::Props
     #
     # @param [Object] _instance
     # @return An instance of one of T::Configuration.scalar_types
-    def serialize(_instance)
-      raise NotImplementedError.new('Must override in included class')
-    end
+    sig {abstract.params(instance: T.untyped).returns(T.untyped).checked(:never)}
+    def serialize(instance); end
 
     # Given the serialized form of your type, this returns an instance
     # of that custom type representing that value.
     #
-    # @param _mongo_scalar One of T::Configuration.scalar_types
+    # @param scalar One of T::Configuration.scalar_types
     # @return Object
-    def deserialize(_mongo_scalar)
-      raise NotImplementedError.new('Must override in included class')
-    end
+    sig {abstract.params(scalar: T.untyped).returns(T.untyped).checked(:never)}
+    def deserialize(scalar); end
 
+    sig {override.params(_base: Module).void}
     def self.included(_base)
       super
 
       raise 'Please use "extend", not "include" to attach this module'
     end
 
+    sig(:final) {params(val: Object).returns(T::Boolean).checked(:never)}
     def self.scalar_type?(val)
       # We don't need to check for val's included modules in
       # T::Configuration.scalar_types, because T::Configuration.scalar_types
       # are all classes.
-      klass = val.class
+      klass = T.let(val.class, T.nilable(Class))
       until klass.nil?
         return true if T::Configuration.scalar_types.include?(klass.to_s)
         klass = klass.superclass
@@ -59,16 +74,8 @@ module T::Props
     # implement set-like fields that store a unique-array, but forbid
     # hashes; Custom hash types should be implemented via an emebdded
     # T::Struct (or a subclass like Chalk::ODM::Document) or via T.
-    def self.valid_serialization?(val, type=nil)
-      if type&.name == 'Chalk::ODM::BsonTypes::BsonObject'
-        # Special case we allow for backwards compatibility with props formerly
-        # typed as "Object" or "Hash", which contain arbitrarily-nested BSON
-        # data (e.g. parsed API request bodies). In general, we aren't pushing
-        # to convert these to Chalk::ODM::BsonTypes - we'd rather delurk them -
-        # but this lets us convert events with these types to Proto.
-        return true
-      end
-
+    sig(:final) {params(val: Object).returns(T::Boolean).checked(:never)}
+    def self.valid_serialization?(val)
       case val
       when Array
         val.each do |v|
@@ -81,14 +88,19 @@ module T::Props
       end
     end
 
-    def self.checked_serialize(type, instance)
-      val = type.serialize(instance)
-      unless valid_serialization?(val, type)
-        msg = "#{type} did not serialize to a valid scalar type. It became a: #{val.class}"
+    sig(:final) do
+      params(instance: Object)
+      .returns(T.untyped)
+      .checked(:never)
+    end
+    def self.checked_serialize(instance)
+      val = T.cast(instance.class, T::Props::CustomType).serialize(instance)
+      unless valid_serialization?(val)
+        msg = "#{instance.class} did not serialize to a valid scalar type. It became a: #{val.class}"
         if val.is_a?(Hash)
           msg += "\nIf you want to store a structured Hash, consider using a T::Struct as your type."
         end
-        raise T::Props::InvalidValueError.new(msg)
+        raise TypeError.new(msg)
       end
       val
     end

data/lib/types/props/decorator.rb

@@ -12,7 +12,7 @@ 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.any(T::Types::Base, T::Props::CustomType)}
+  PropType = T.type_alias {T::Types::Base}
   PropTypeOrClass = T.type_alias {T.any(PropType, Module)}
 
   class NoRulesError < StandardError; end
@@ -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])
@@ -119,6 +118,21 @@ class T::Props::Decorator
   end
   alias_method :set, :prop_set
 
+  # Only Models have any custom get logic but we need to call this on
+  # non-Models since we don't know at code gen time what we have.
+  sig do
+    params(
+      instance: DecoratedInstance,
+      prop: Symbol,
+      value: T.untyped
+    )
+    .returns(T.untyped)
+    .checked(:never)
+  end
+  def prop_get_logic(instance, prop, value)
+    value
+  end
+
   # For performance, don't use named params here.
   # Passing in rules here is purely a performance optimization.
   #
@@ -174,7 +188,7 @@ class T::Props::Decorator
     .returns(T.untyped)
     .checked(:never)
   end
-  def foreign_prop_get(instance, prop, foreign_class, rules=props[prop.to_sym], opts={})
+  def foreign_prop_get(instance, prop, foreign_class, rules=prop_rules(prop), opts={})
     return if !(value = prop_get(instance, prop, rules))
     T.unsafe(foreign_class).load(value, {}, opts)
   end
@@ -205,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(
@@ -280,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
@@ -335,21 +302,13 @@ class T::Props::Decorator
     if !cls.is_a?(Module)
       cls = convert_type_to_class(cls)
     end
-    type_object = type
-    if !(type_object.singleton_class < T::Props::CustomType)
-      type_object = smart_coerce(type_object, array: rules[:array], enum: rules[:enum])
-    end
+    type_object = smart_coerce(type, enum: rules[:enum])
 
     prop_validate_definition!(name, cls, rules, type_object)
 
     # Retrive the possible underlying object with T.nilable.
-    underlying_type_object = T::Utils::Nilable.get_underlying_type_object(type_object)
     type = T::Utils::Nilable.get_underlying_type(type)
 
-    array_subdoc_type = array_subdoc_type(underlying_type_object)
-    hash_value_subdoc_type = hash_value_subdoc_type(underlying_type_object)
-    hash_key_custom_type = hash_key_custom_type(underlying_type_object)
-
     sensitivity_and_pii = {sensitivity: rules[:sensitivity]}
     if defined?(Opus) && defined?(Opus::Sensitivity) && defined?(Opus::Sensitivity::Utils)
       sensitivity_and_pii = Opus::Sensitivity::Utils.normalize_sensitivity_and_pii_annotation(sensitivity_and_pii)
@@ -367,27 +326,11 @@ class T::Props::Decorator
       end
     end
 
-    needs_clone =
-      if cls <= Array || cls <= Hash || cls <= Set
-        shallow_clone_ok(underlying_type_object) ? :shallow : true
-      else
-        false
-      end
-
     rules = rules.merge(
       # TODO: The type of this element is confusing. We should refactor so that
       # it can be always `type_object` (a PropType) or always `cls` (a Module)
       type: type,
-      # These are precomputed for performance
-      # TODO: A lot of these are only needed by T::Props::Serializable or T::Struct
-      # and can/should be moved accordingly.
-      type_is_custom_type: cls.singleton_class < T::Props::CustomType,
-      type_is_serializable: cls < T::Props::Serializable,
-      type_is_array_of_serializable: !array_subdoc_type.nil?,
-      type_is_hash_of_serializable_values: !hash_value_subdoc_type.nil?,
-      type_is_hash_of_custom_type_keys: !hash_key_custom_type.nil?,
       type_object: type_object,
-      type_needs_clone: needs_clone,
       accessor_key: "@#{name}".to_sym,
       sensitivity: sensitivity_and_pii[:sensitivity],
       pii: sensitivity_and_pii[:pii],
@@ -397,26 +340,13 @@ class T::Props::Decorator
 
     validate_not_missing_sensitivity(name, rules)
 
-    # for backcompat
-    if type.is_a?(T::Types::TypedArray) && type.type.is_a?(T::Types::Simple)
-      rules[:array] = type.type.raw_type
-    elsif array_subdoc_type
-      rules[:array] = array_subdoc_type
-    end
-
-    if rules[:type_is_serializable]
-      rules[:serializable_subtype] = cls
-    elsif array_subdoc_type
-      rules[:serializable_subtype] = array_subdoc_type
-    elsif hash_value_subdoc_type && hash_key_custom_type
-      rules[:serializable_subtype] = {
-        keys: hash_key_custom_type,
-        values: hash_value_subdoc_type,
-      }
-    elsif hash_value_subdoc_type
-      rules[:serializable_subtype] = hash_value_subdoc_type
-    elsif hash_key_custom_type
-      rules[:serializable_subtype] = hash_key_custom_type
+    # for backcompat (the `:array` key is deprecated but because the name is
+    # so generic it's really hard to be sure it's not being relied on anymore)
+    if type.is_a?(T::Types::TypedArray)
+      inner = T::Utils::Nilable.get_underlying_type(type.type)
+      if inner.is_a?(Module)
+        rules[:array] = inner
+      end
     end
 
     rules[:setter_proc] = T::Props::Private::SetterFactory.build_setter_proc(@class, name, rules).freeze
@@ -462,110 +392,22 @@ class T::Props::Decorator
     end
   end
 
-  # returns the subdoc of the array type, or nil if it's not a Document type
-  #
-  # checked(:never) - Typechecks internally
-  sig do
-    params(type: PropType)
-    .returns(T.nilable(Module))
-    .checked(:never)
-  end
-  private def array_subdoc_type(type)
-    if type.is_a?(T::Types::TypedArray)
-      el_type = T::Utils.unwrap_nilable(type.type) || type.type
-
-      if el_type.is_a?(T::Types::Simple) &&
-          (el_type.raw_type < T::Props::Serializable || el_type.raw_type.is_a?(T::Props::CustomType))
-        return el_type.raw_type
-      end
-    end
-
-    nil
-  end
-
-  # returns the subdoc of the hash value type, or nil if it's not a Document type
-  #
-  # checked(:never) - Typechecks internally
   sig do
-    params(type: PropType)
-    .returns(T.nilable(Module))
-    .checked(:never)
-  end
-  private def hash_value_subdoc_type(type)
-    if type.is_a?(T::Types::TypedHash)
-      values_type = T::Utils.unwrap_nilable(type.values) || type.values
-
-      if values_type.is_a?(T::Types::Simple) &&
-          (values_type.raw_type < T::Props::Serializable || values_type.raw_type.is_a?(T::Props::CustomType))
-        return values_type.raw_type
-      end
-    end
-
-    nil
-  end
-
-  # returns the type of the hash key, or nil. Any CustomType could be a key, but we only expect T::Enum right now.
-  #
-  # checked(:never) - Typechecks internally
-  sig do
-    params(type: PropType)
-    .returns(T.nilable(Module))
-    .checked(:never)
-  end
-  private def hash_key_custom_type(type)
-    if type.is_a?(T::Types::TypedHash)
-      keys_type = T::Utils.unwrap_nilable(type.keys) || type.keys
-
-      if keys_type.is_a?(T::Types::Simple) && keys_type.raw_type.is_a?(T::Props::CustomType)
-        return keys_type.raw_type
-      end
-    end
-
-    nil
-  end
-
-  # From T::Props::Utils.deep_clone_object, plus String
-  TYPES_NOT_NEEDING_CLONE = T.let([TrueClass, FalseClass, NilClass, Symbol, String, Numeric], T::Array[Module])
-
-  # checked(:never) - Typechecks internally
-  sig {params(type: PropType).returns(T.nilable(T::Boolean)).checked(:never)}
-  private def shallow_clone_ok(type)
-    inner_type =
-      if type.is_a?(T::Types::TypedArray)
-        type.type
-      elsif type.is_a?(T::Types::TypedSet)
-        type.type
-      elsif type.is_a?(T::Types::TypedHash)
-        type.values
-      end
-
-    inner_type.is_a?(T::Types::Simple) && TYPES_NOT_NEEDING_CLONE.any? do |cls|
-      inner_type.raw_type <= cls
-    end
-  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
 
@@ -602,7 +444,7 @@ class T::Props::Decorator
   sig do
     params(
       prop_name: Symbol,
-      redaction: Chalk::Tools::RedactionUtils::RedactionDirectiveSpec,
+      redaction: T.untyped,
     )
     .void
   end
@@ -724,14 +566,6 @@ class T::Props::Decorator
       end
       loaded_foreign
     end
-
-    @class.send(:define_method, "#{prop_name}_record") do |allow_direct_mutation: nil|
-      T::Configuration.soft_assert_handler(
-        "Using deprecated 'model.#{prop_name}_record' foreign key syntax. You should replace this with 'model.#{prop_name}_'",
-        notify: 'vasi'
-      )
-      send(fk_method, allow_direct_mutation: allow_direct_mutation)
-    end
   end
 
   # checked(:never) - Rules hash is expensive to check

data/lib/types/props/generated_code_validation.rb

@@ -148,13 +148,30 @@ module T::Props
       assert_equal(s(:op_asgn, s(:lvasgn, :found), :-, s(:int, 1)), found_else_body)
 
       validate_deserialize_handle_nil(handle_nil)
-      validate_lack_of_side_effects(else_body, whitelisted_methods_for_deserialize)
+
+      if else_body.type == :kwbegin
+        rescue_expression, = else_body.children
+        assert_equal(:rescue, rescue_expression.type)
+
+        try, rescue_body = rescue_expression.children
+        validate_lack_of_side_effects(try, whitelisted_methods_for_deserialize)
+
+        assert_equal(:resbody, rescue_body.type)
+        exceptions, assignment, handler =  rescue_body.children
+        assert_equal(:array, exceptions.type)
+        exceptions.children.each {|c| assert_equal(:const, c.type)}
+        assert_equal(:lvasgn, assignment.type)
+        assert_equal([:e], assignment.children)
+        validate_lack_of_side_effects(handler, whitelisted_methods_for_deserialize)
+      else
+        validate_lack_of_side_effects(else_body, whitelisted_methods_for_deserialize)
+      end
     end
 
     private_class_method def self.validate_deserialize_handle_nil(node)
       case node.type
-      when :hash, :array, :str, :sym, :int, :float, :true, :false, :nil
-        # Primitives are safe
+      when :hash, :array, :str, :sym, :int, :float, :true, :false, :nil, :const
+        # Primitives and constants are safe
       when :send
         receiver, method, arg = node.children
         if receiver.nil?
@@ -243,8 +260,8 @@ module T::Props
     # Method calls generated by SerdeTransform
     private_class_method def self.whitelisted_methods_for_deserialize
       @whitelisted_methods_for_deserialize ||= {
-        :lvar => %i{dup map transform_values transform_keys each_with_object nil? []=},
-        :const => %i{deserialize from_hash deep_clone_object},
+        :lvar => %i{dup map transform_values transform_keys each_with_object nil? []= to_f},
+        :const => %i{deserialize from_hash deep_clone_object soft_assert_handler},
       }
     end
   end

data/lib/types/props/has_lazily_specialized_methods.rb

@@ -66,10 +66,13 @@ module T::Props
         lazily_defined_methods[name] = blk
 
         cls = decorated_class
-        cls.define_method(name) do |*args|
+        cls.send(:define_method, name) do |*args|
           self.class.decorator.send(:eval_lazily_defined_method!, name)
           send(name, *args)
         end
+        if cls.respond_to?(:ruby2_keywords, true)
+          cls.send(:ruby2_keywords, name)
+        end
         cls.send(:private, name)
       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/deserializer_generator.rb

@@ -43,11 +43,36 @@ module T::Props
           ivar_name = rules.fetch(:accessor_key).to_s
           raise unless ivar_name.start_with?('@') && T::Props::Decorator::SAFE_NAME.match?(ivar_name[1..-1])
 
-          transformed_val = SerdeTransform.generate(
+          transformation = SerdeTransform.generate(
             T::Utils::Nilable.get_underlying_type_object(rules.fetch(:type_object)),
             SerdeTransform::Mode::DESERIALIZE,
             'val'
-          ) || 'val'
+          )
+          if transformation
+            # Rescuing exactly NoMethodError is intended as a temporary hack
+            # to preserve the semantics from before codegen. More generally
+            # we are inconsistent about typechecking on deser and need to decide
+            # our strategy here.
+            transformed_val = <<~RUBY
+              begin
+                #{transformation}
+              rescue NoMethodError => e
+                T::Configuration.soft_assert_handler(
+                  'Deserialization error (probably unexpected stored type)',
+                  storytime: {
+                    klass: self.class,
+                    prop: #{prop.inspect},
+                    value: val,
+                    error: e.message,
+                    notify: 'djudd'
+                  }
+                )
+                val
+              end
+            RUBY
+          else
+            transformed_val = 'val'
+          end
 
           nil_handler = generate_nil_handler(
             prop: prop,

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

@@ -19,14 +19,14 @@ module T::Props
       end
 
       NO_TRANSFORM_TYPES = T.let(
-        [TrueClass, FalseClass, NilClass, Symbol, String, Numeric].freeze,
+        [TrueClass, FalseClass, NilClass, Symbol, String].freeze,
         T::Array[Module],
       )
       private_constant :NO_TRANSFORM_TYPES
 
       sig do
         params(
-          type: T.any(T::Types::Base, Module),
+          type: T::Types::Base,
           mode: ModeType,
           varname: String,
         )
@@ -65,10 +65,28 @@ module T::Props
           raw = type.raw_type
           if NO_TRANSFORM_TYPES.any? {|cls| raw <= cls}
             nil
+          elsif raw <= Float
+            case mode
+            when Deserialize then "#{varname}.to_f"
+            when Serialize then nil
+            else T.absurd(mode)
+            end
+          elsif raw <= Numeric
+            nil
           elsif raw < T::Props::Serializable
             handle_serializable_subtype(varname, raw, mode)
           elsif raw.singleton_class < T::Props::CustomType
             handle_custom_type(varname, T.unsafe(raw), mode)
+          elsif T::Configuration.scalar_types.include?(raw.name)
+            # It's a bit of a hack that this is separate from NO_TRANSFORM_TYPES
+            # and doesn't check inheritance (like `T::Props::CustomType.scalar_type?`
+            # does), but it covers the main use case (pay-server's custom `Boolean`
+            # module) without either requiring `T::Configuration.scalar_types` to
+            # accept modules instead of strings (which produces load-order issues
+            # and subtle behavior changes) or eating the performance cost of doing
+            # an inheritance check by manually crawling a class hierarchy and doing
+            # string comparisons.
+            nil
           else
             "T::Props::Utils.deep_clone_object(#{varname})"
           end
@@ -82,17 +100,56 @@ module T::Props
               "#{varname}.nil? ? nil : #{inner}"
             end
           else
-            "T::Props::Utils.deep_clone_object(#{varname})"
+            # Handle, e.g., T::Boolean
+            if type.types.all? {|t| generate(t, mode, varname).nil?}
+              nil
+            else
+              # We currently deep_clone_object if the type was T.any(Integer, Float).
+              # When we get better support for union types (maybe this specific
+              # union type, because it would be a replacement for
+              # Chalk::ODM::DeprecatedNumemric), we could opt to special case
+              # this union to have no specific serde transform (the only reason
+              # why Float has a special case is because round tripping through
+              # JSON might normalize Floats to Integers)
+              "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
 
@@ -113,8 +170,7 @@ module T::Props
       private_class_method def self.handle_custom_type(varname, type, mode)
         case mode
         when Serialize
-          type_name = T.must(module_name(type))
-          "T::Props::CustomType.checked_serialize(#{type_name}, #{varname})"
+          "T::Props::CustomType.checked_serialize(#{varname})"
         when Deserialize
           type_name = T.must(module_name(type))
           "#{type_name}.deserialize(#{varname})"

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

@@ -20,17 +20,10 @@ module T::Props
       end
       def self.build_setter_proc(klass, prop, rules)
         # Our nil check works differently than a simple T.nilable for various
-        # reasons (including the `raise_on_nil_write` setting, the existence
-        # of defaults & factories, and the fact that we allow `T.nilable(Foo)`
-        # where Foo < T::Props::CustomType as a prop type even though calling
-        # `valid?` on it won't work as expected), so unwrap any T.nilable and
-        # do a check manually. (Note this hack does not fix custom types as
-        # collection elements.)
-        non_nil_type = if rules[:type_is_custom_type]
-          rules.fetch(:type)
-        else
-          T::Utils::Nilable.get_underlying_type_object(rules.fetch(:type_object))
-        end
+        # reasons (including the `raise_on_nil_write` setting and the existence
+        # of defaults & factories), so unwrap any T.nilable and do a check
+        # manually.
+        non_nil_type = T::Utils::Nilable.get_underlying_type_object(rules.fetch(:type_object))
         accessor_key = rules.fetch(:accessor_key)
         validate = rules[:setter_validate]
 
@@ -51,7 +44,7 @@ module T::Props
         params(
           prop: Symbol,
           accessor_key: Symbol,
-          non_nil_type: T.any(T::Types::Base, T.all(T::Props::CustomType, Module)),
+          non_nil_type: T::Types::Base,
           klass: T.all(Module, T::Props::ClassMethods),
           validate: T.nilable(ValidateProc)
         )
@@ -71,6 +64,7 @@ module T::Props
               non_nil_type,
               val,
             )
+            instance_variable_set(accessor_key, val)
           end
         end
       end
@@ -79,7 +73,7 @@ module T::Props
         params(
           prop: Symbol,
           accessor_key: Symbol,
-          non_nil_type: T.any(T::Types::Base, T.all(T::Props::CustomType, Module)),
+          non_nil_type: T::Types::Base,
           klass: T.all(Module, T::Props::ClassMethods),
           validate: T.nilable(ValidateProc),
         )
@@ -101,6 +95,7 @@ module T::Props
               non_nil_type,
               val,
             )
+            instance_variable_set(accessor_key, val)
           end
         end
       end

data/lib/types/props/serializable.rb

@@ -16,7 +16,25 @@ module T::Props::Serializable
   #   values.
   # @return [Hash] A serialization of this object.
   def serialize(strict=true)
-    h = __t_props_generated_serialize(strict)
+    begin
+      h = __t_props_generated_serialize(strict)
+    rescue => e
+      msg = self.class.decorator.message_with_generated_source_context(
+        e,
+        :__t_props_generated_serialize,
+        :generate_serialize_source
+      )
+      if msg
+        begin
+          raise e.class.new(msg)
+        rescue ArgumentError
+          raise TypeError.new(msg)
+        end
+      else
+        raise
+      end
+    end
+
     h.merge!(@_extra_props) if @_extra_props
     h
   end
@@ -39,7 +57,25 @@ module T::Props::Serializable
   #  props on this instance.
   # @return [void]
   def deserialize(hash, strict=false)
-    hash_keys_matching_props = __t_props_generated_deserialize(hash)
+    begin
+      hash_keys_matching_props = __t_props_generated_deserialize(hash)
+    rescue => e
+      msg = self.class.decorator.message_with_generated_source_context(
+        e,
+        :__t_props_generated_deserialize,
+        :generate_deserialize_source
+      )
+      if msg
+        begin
+          raise e.class.new(msg)
+        rescue ArgumentError
+          raise TypeError.new(msg)
+        end
+      else
+        raise
+      end
+    end
+
     if hash.size > hash_keys_matching_props
       serialized_forms = self.class.decorator.prop_by_serialized_forms
       extra = hash.reject {|k, _| serialized_forms.key?(k)}
@@ -110,7 +146,7 @@ module T::Props::Serializable
         prop: prop, class: self.class.name, id: self.class.decorator.get_id(self)
       )
     else
-      raise T::Props::InvalidValueError.new("#{self.class.name}.#{prop} not set for non-optional prop")
+      raise TypeError.new("#{self.class.name}.#{prop} not set for non-optional prop")
     end
   end
 
@@ -181,6 +217,24 @@ module T::Props::Serializable::DecoratorMethods
     )
   end
 
+  def message_with_generated_source_context(error, generated_method, generate_source_method)
+    line_label = error.backtrace.find {|l| l.end_with?("in `#{generated_method}'")}
+    return unless line_label
+
+    line_num = line_label.split(':')[1]&.to_i
+    return unless line_num
+
+    source_lines = self.send(generate_source_method).split("\n")
+    previous_blank = source_lines[0...line_num].rindex(&:empty?) || 0
+    next_blank = line_num + (source_lines[line_num..-1]&.find_index(&:empty?) || 0)
+    context = "  " + source_lines[(previous_blank + 1)...(next_blank)].join("\n  ")
+    <<~MSG
+      Error in #{decorated_class.name}##{generated_method}: #{error.message}
+      at line #{line_num-previous_blank-1} in:
+      #{context}
+    MSG
+  end
+
   def raise_nil_deserialize_error(hkey)
     msg = "Tried to deserialize a required prop from a nil value. It's "\
       "possible that a nil value exists in the database, so you should "\

data/lib/types/props/type_validation.rb

@@ -28,7 +28,7 @@ module T::Props::TypeValidation
     def prop_validate_definition!(name, _cls, rules, type)
       super
 
-      if !rules[:DEPRECATED_underspecified_type] && !(type.singleton_class <= T::Props::CustomType)
+      if !rules[:DEPRECATED_underspecified_type]
         validate_type(type, field_name: 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")
@@ -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

data/lib/types/types/t_enum.rb

@@ -12,7 +12,12 @@ module T::Types
 
     # @override Base
     def name
-      @val.inspect
+      # Strips the #<...> off, just leaving the ...
+      # Reasoning: the user will have written something like
+      #   T.any(MyEnum::A, MyEnum::B)
+      # in the type, so we should print what they wrote in errors, not:
+      #   T.any(#<MyEnum::A>, #<MyEnum::B>)
+      @val.inspect[2..-2]
     end
 
     # @override Base

data/lib/types/types/type_parameter.rb

@@ -17,7 +17,7 @@ module T::Types
     end
 
     def name
-      "T.type_parameter(#{@name})"
+      "T.type_parameter(:#{@name})"
     end
   end
 end

data/lib/types/types/typed_enumerable.rb

@@ -50,7 +50,11 @@ module T::Types
         # Enumerators can be unbounded: see `[:foo, :bar].cycle`
         return true
       when Range
-        @type.valid?(obj.first) && @type.valid?(obj.last)
+        # A nil beginning or a nil end does not provide any type information. That is, nil in a range represents
+        # 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))
       when Set
         obj.each do |item|
           return false unless @type.valid?(item)
@@ -124,7 +128,13 @@ module T::Types
         inferred_val = type_from_instances(obj.values)
         T::Hash[inferred_key, inferred_val]
       when Range
-        T::Range[type_from_instances([obj.first, obj.last])]
+        # We can't get any information from `NilClass` in ranges (since nil is used to represent boundlessness).
+        typeable_objects = [obj.begin, obj.end].compact
+        if typeable_objects.empty?
+          T::Range[T.untyped]
+        else
+          T::Range[type_from_instances(typeable_objects)]
+        end
       when Enumerator
         T::Enumerator[type_from_instances(obj)]
       when Set

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.5.5429
+  version: 0.5.5794
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-10 00:00:00.000000000 Z
+date: 2020-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -124,6 +124,7 @@ files:
 - lib/types/generic.rb
 - lib/types/helpers.rb
 - lib/types/interface_wrapper.rb
+- lib/types/non_forcing_constants.rb
 - lib/types/private/abstract/data.rb
 - lib/types/private/abstract/declare.rb
 - lib/types/private/abstract/hooks.rb
@@ -139,6 +140,7 @@ files:
 - lib/types/private/methods/signature.rb
 - lib/types/private/methods/signature_validation.rb
 - lib/types/private/mixins/mixins.rb
+- lib/types/private/retry.rb
 - lib/types/private/runtime_levels.rb
 - lib/types/private/sealed.rb
 - lib/types/private/types/not_typed.rb