sorbet-runtime 0.5.5316 → 0.5.5325

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96ac3f40e289c8880e546f48cc793e4e12461e713ac5a6d5daf9777d91af2774
-  data.tar.gz: 425ccca3f410868f357385eba3bbf0e8cc9cdd4b2cdc252137b0da96b36d5002
+  metadata.gz: 4e0334f17e13c054564e58b5baae0c6d7af794f0f9bb2a6c009b8c66a3ca6c2c
+  data.tar.gz: 3dfd7376f2c8259102b83724f2536a9094724a8d3ec15f89e86c24dcd56655f8
 SHA512:
-  metadata.gz: 28df096a88491a837b89157f6b3fb2a779d0e61729e0c9363740a9fa8ddef7d23156f0c910fcc0b9569daba0826dfef9e22441bb82718872923a444c09b9536c
-  data.tar.gz: cae44a94689f106188a491200eccf8b0da90e61ce2b089f79dbf8bcbb0ac4c486c9a10934f3647762aa3c179df677bfeee571665e1154b5929ebb8275ed3d7cf
+  metadata.gz: 91ccdef7e77ca422b938d018b7c06f5f6d67da79589a1c06e5bfb87c65cd94f198512ad537e086b7810b4be3b51b0d264d236afc07d14034dd800dccf754f508
+  data.tar.gz: 14e060cef09fd1b3c2937b879e31a27755182e40d65803aa8a2d98db51ac73617d08ca92f1f4fd321a2d7fbf988b515414b8967ca805d9be09f8d98f33c870d5

data/lib/sorbet-runtime.rb

@@ -92,8 +92,10 @@ require_relative 'types/props/decorator'
 require_relative 'types/props/errors'
 require_relative 'types/props/plugin'
 require_relative 'types/props/utils'
+require_relative 'types/enum'
 # Props that run sigs statically so have to be after all the others :(
 require_relative 'types/props/private/setter_factory'
+require_relative 'types/props/private/apply_default'
 require_relative 'types/props/optional'
 require_relative 'types/props/weak_constructor'
 require_relative 'types/props/constructor'
@@ -102,6 +104,5 @@ require_relative 'types/props/serializable'
 require_relative 'types/props/type_validation'
 
 require_relative 'types/struct'
-require_relative 'types/enum'
 
 require_relative 'types/compatibility_patches'

data/lib/types/private/types/void.rb

@@ -8,13 +8,14 @@ class T::Private::Types::Void < T::Types::Base
 
   # The actual return value of `.void` methods.
   #
-  # Uses `Module.new` because in Ruby an anonymous module will inherit the name
-  # of the constant it's assigned to. This gives it a readable name someone
+  # Uses `module VOID` because this gives it a readable name when someone
   # examines it in Pry or with `#inspect` like:
   #
   #     T::Private::Types::Void::VOID
   #
-  VOID = Module.new.freeze
+  module VOID
+    freeze
+  end
 
   # @override Base
   def name

data/lib/types/props/constructor.rb

@@ -3,18 +3,32 @@
 
 module T::Props::Constructor
   include T::Props::WeakConstructor
+end
 
-  def initialize(hash={})
-    decorator = self.class.decorator
+module T::Props::Constructor::DecoratorMethods
+  extend T::Sig
 
-    decorator.props.each do |prop, rules|
-      # It's important to explicitly compare against `true` here; the value can also be :existing or
-      # :on_load (which are truthy) but we don't want to treat those as optional in this context.
-      if T::Props::Utils.required_prop?(rules) && !decorator.has_default?(rules) && !hash.key?(prop)
-        raise ArgumentError.new("Missing required prop `#{prop}` for class `#{self.class}`")
+  # Set values for all props that have no defaults. Override what `WeakConstructor`
+  # does in order to raise errors on nils instead of ignoring them.
+  #
+  # @return [Integer] A count of props that we successfully initialized (which
+  # we'll use to check for any unrecognized input.)
+  #
+  # checked(:never) - O(runtime object construction)
+  sig {params(instance: T::Props::Constructor, hash: T::Hash[Symbol, T.untyped]).returns(Integer).checked(:never)}
+  def construct_props_without_defaults(instance, hash)
+    @props_without_defaults&.count do |p, setter_proc|
+      begin
+        val = hash[p]
+        instance.instance_exec(val, &setter_proc)
+        val || hash.key?(p)
+      rescue TypeError, T::Props::InvalidValueError
+        if !hash.key?(p)
+          raise ArgumentError.new("Missing required prop `#{p}` for class `#{instance.class.name}`")
+        else
+          raise
+        end
       end
-    end
-
-    super
+    end || 0
   end
 end

data/lib/types/props/optional.rb

@@ -12,6 +12,8 @@ end
 # NB: This must stay in the same file where T::Props::Optional is defined due to
 # T::Props::Decorator#apply_plugin; see https://git.corp.stripe.com/stripe-internal/pay-server/blob/fc7f15593b49875f2d0499ffecfd19798bac05b3/chalk/odm/lib/chalk-odm/document_decorator.rb#L716-L717
 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[
@@ -28,6 +30,9 @@ module T::Props::Optional::DecoratorMethods
   }.freeze
   private_constant :VALID_RULE_KEYS
 
+  DEFAULT_SETTER_RULE_KEY = :_t_props_private_apply_default
+  private_constant :DEFAULT_SETTER_RULE_KEY
+
   def valid_rule_key?(key)
     super || VALID_RULE_KEYS[key]
   end
@@ -39,8 +44,30 @@ module T::Props::Optional::DecoratorMethods
     rules[:need_nil_read_check] = T::Props::Utils.need_nil_read_check?(rules)
   end
 
+  # checked(:never) - O(runtime object construction)
+  sig {returns(T::Hash[Symbol, T::Props::Private::ApplyDefault]).checked(:never)}
+  attr_reader :props_with_defaults
+
+  # checked(:never) - O(runtime object construction)
+  sig {returns(T::Hash[Symbol, T::Props::Private::SetterFactory::SetterProc]).checked(:never)}
+  attr_reader :props_without_defaults
+
   def add_prop_definition(prop, rules)
     compute_derived_rules(rules)
+
+    default_setter = T::Props::Private::ApplyDefault.for(decorated_class, rules)
+    if default_setter
+      @props_with_defaults ||= {}
+      @props_with_defaults[prop] = default_setter
+      @props_without_defaults&.delete(prop) # Handle potential override
+
+      rules[DEFAULT_SETTER_RULE_KEY] = default_setter
+    else
+      @props_without_defaults ||= {}
+      @props_without_defaults[prop] = rules.fetch(:setter_proc)
+      @props_with_defaults&.delete(prop) # Handle potential override
+    end
+
     super
   end
 
@@ -61,21 +88,10 @@ module T::Props::Optional::DecoratorMethods
   end
 
   def has_default?(rules)
-    rules.include?(:default) || rules.include?(:factory)
+    rules.include?(DEFAULT_SETTER_RULE_KEY)
   end
 
   def get_default(rules, instance_class)
-    if rules.include?(:default)
-      default = rules[:default]
-      T::Props::Utils.deep_clone_object(default)
-    elsif rules.include?(:factory)
-      # Factory should never be nil if the key is specified, but
-      # we do this rather than 'elsif rules[:factory]' for
-      # consistency with :default.
-      factory = rules[:factory]
-      instance_class.class_exec(&factory)
-    else
-      nil
-    end
+    rules[DEFAULT_SETTER_RULE_KEY]&.default
   end
 end

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

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+# typed: strict
+
+module T::Props
+  module Private
+    class ApplyDefault
+      extend T::Sig
+      extend T::Helpers
+      abstract!
+
+      # checked(:never) - O(object construction x prop count)
+      sig {returns(SetterFactory::SetterProc).checked(:never)}
+      attr_reader :setter_proc
+
+      # checked(:never) - We do this with `T.let` instead
+      sig {params(accessor_key: Symbol, setter_proc: SetterFactory::SetterProc).void.checked(:never)}
+      def initialize(accessor_key, setter_proc)
+        @accessor_key = T.let(accessor_key, Symbol)
+        @setter_proc = T.let(setter_proc, SetterFactory::SetterProc)
+      end
+
+      # checked(:never) - O(object construction x prop count)
+      sig {abstract.returns(T.untyped).checked(:never)}
+      def default; end
+
+      # checked(:never) - O(object construction x prop count)
+      sig {abstract.params(instance: T.all(T::Props::Optional, Object)).void.checked(:never)}
+      def set_default(instance); end
+
+      NO_CLONE_TYPES = T.let([TrueClass, FalseClass, NilClass, Symbol, Numeric, T::Enum].freeze, T::Array[Module])
+
+      # checked(:never) - Rules hash is expensive to check
+      sig {params(cls: Module, rules: T::Hash[Symbol, T.untyped]).returns(T.nilable(ApplyDefault)).checked(:never)}
+      def self.for(cls, rules)
+        accessor_key = rules.fetch(:accessor_key)
+        setter = rules.fetch(:setter_proc)
+
+        if rules.key?(:factory)
+          ApplyDefaultFactory.new(cls, rules.fetch(:factory), accessor_key, setter)
+        elsif rules.key?(:default)
+          default = rules.fetch(:default)
+          case default
+          when *NO_CLONE_TYPES
+            return ApplyPrimitiveDefault.new(default, accessor_key, setter)
+          when String
+            if default.frozen?
+              return ApplyPrimitiveDefault.new(default, accessor_key, setter)
+            end
+          when Array
+            if default.empty? && default.class == Array
+              return ApplyEmptyArrayDefault.new(accessor_key, setter)
+            end
+          when Hash
+            if default.empty? && default.default.nil? && T.unsafe(default).default_proc.nil? && default.class == Hash
+              return ApplyEmptyHashDefault.new(accessor_key, setter)
+            end
+          end
+
+          ApplyComplexDefault.new(default, accessor_key, setter)
+        else
+          nil
+        end
+      end
+    end
+
+    class ApplyFixedDefault < ApplyDefault
+      abstract!
+
+      # checked(:never) - We do this with `T.let` instead
+      sig {params(default: BasicObject, accessor_key: Symbol, setter_proc: SetterFactory::SetterProc).void.checked(:never)}
+      def initialize(default, accessor_key, setter_proc)
+        # FIXME: Ideally we'd check here that the default is actually a valid
+        # value for this field, but existing code relies on the fact that we don't.
+        #
+        # :(
+        #
+        # setter_proc.call(default)
+        @default = T.let(default, BasicObject)
+        super(accessor_key, setter_proc)
+      end
+
+      # checked(:never) - O(object construction x prop count)
+      sig {override.params(instance: T.all(T::Props::Optional, Object)).void.checked(:never)}
+      def set_default(instance)
+        instance.instance_variable_set(@accessor_key, default)
+      end
+    end
+
+    class ApplyPrimitiveDefault < ApplyFixedDefault
+      # checked(:never) - O(object construction x prop count)
+      sig {override.returns(T.untyped).checked(:never)}
+      attr_reader :default
+    end
+
+    class ApplyComplexDefault < ApplyFixedDefault
+      # checked(:never) - O(object construction x prop count)
+      sig {override.returns(T.untyped).checked(:never)}
+      def default
+        T::Props::Utils.deep_clone_object(@default)
+      end
+    end
+
+    # Special case since it's so common, and a literal `[]` is meaningfully
+    # faster than falling back to ApplyComplexDefault or even calling
+    # `some_empty_array.dup`
+    class ApplyEmptyArrayDefault < ApplyDefault
+      # checked(:never) - O(object construction x prop count)
+      sig {override.params(instance: T.all(T::Props::Optional, Object)).void.checked(:never)}
+      def set_default(instance)
+        instance.instance_variable_set(@accessor_key, [])
+      end
+
+      # checked(:never) - O(object construction x prop count)
+      sig {override.returns(T::Array[T.untyped]).checked(:never)}
+      def default
+        []
+      end
+    end
+
+    # Special case since it's so common, and a literal `{}` is meaningfully
+    # faster than falling back to ApplyComplexDefault or even calling
+    # `some_empty_hash.dup`
+    class ApplyEmptyHashDefault < ApplyDefault
+      # checked(:never) - O(object construction x prop count)
+      sig {override.params(instance: T.all(T::Props::Optional, Object)).void.checked(:never)}
+      def set_default(instance)
+        instance.instance_variable_set(@accessor_key, {})
+      end
+
+      # checked(:never) - O(object construction x prop count)
+      sig {override.returns(T::Hash[T.untyped, T.untyped]).checked(:never)}
+      def default
+        {}
+      end
+    end
+
+    class ApplyDefaultFactory < ApplyDefault
+      # checked(:never) - We do this with `T.let` instead
+      sig do
+        params(
+          cls: Module,
+          factory: T.any(Proc, Method),
+          accessor_key: Symbol,
+          setter_proc: SetterFactory::SetterProc,
+        )
+        .void
+        .checked(:never)
+      end
+      def initialize(cls, factory, accessor_key, setter_proc)
+        @class = T.let(cls, Module)
+        @factory = T.let(factory, T.any(Proc, Method))
+        super(accessor_key, setter_proc)
+      end
+
+      # checked(:never) - O(object construction x prop count)
+      sig {override.params(instance: T.all(T::Props::Optional, Object)).void.checked(:never)}
+      def set_default(instance)
+        # Use the actual setter to validate the factory returns a legitimate
+        # value every time
+        instance.instance_exec(default, &@setter_proc)
+      end
+
+      # checked(:never) - O(object construction x prop count)
+      sig {override.returns(T.untyped).checked(:never)}
+      def default
+        @class.class_exec(&@factory)
+      end
+    end
+  end
+end

data/lib/types/props/weak_constructor.rb

@@ -3,28 +3,60 @@
 
 module T::Props::WeakConstructor
   include T::Props::Optional
+  extend T::Sig
 
+  # checked(:never) - O(runtime object construction)
+  sig {params(hash: T::Hash[Symbol, T.untyped]).void.checked(:never)}
   def initialize(hash={})
-    expected_keys = {}
-    hash.each_key {|key| expected_keys[key] = true}
-
     decorator = self.class.decorator
 
-    decorator.props.each do |p, rules|
+    hash_keys_matching_props = decorator.construct_props_with_defaults(self, hash) +
+      decorator.construct_props_without_defaults(self, hash)
+
+    if hash_keys_matching_props < hash.size
+      raise ArgumentError.new("#{self.class}: Unrecognized properties: #{(hash.keys - decorator.props.keys).join(', ')}")
+    end
+  end
+end
+
+module T::Props::WeakConstructor::DecoratorMethods
+  extend T::Sig
+
+  # Set values for all props that have no defaults. Ignore any not present.
+  #
+  # @return [Integer] A count of props that we successfully initialized (which
+  # we'll use to check for any unrecognized input.)
+  #
+  # checked(:never) - O(runtime object construction)
+  sig {params(instance: T::Props::WeakConstructor, hash: T::Hash[Symbol, T.untyped]).returns(Integer).checked(:never)}
+  def construct_props_without_defaults(instance, hash)
+    @props_without_defaults&.count do |p, setter_proc|
       if hash.key?(p)
-        expected_keys.delete(p)
-        val = hash[p]
-      elsif decorator.has_default?(rules)
-        val = decorator.get_default(rules, self.class)
+        instance.instance_exec(hash[p], &setter_proc)
+        true
       else
-        next
+        false
       end
+    end || 0
+  end
 
-      decorator.prop_set(self, p, val, rules)
-    end
-
-    unless expected_keys.empty?
-      raise ArgumentError.new("#{@class}: Unrecognized properties in #with_props: #{expected_keys.keys.join(', ')}")
-    end
+  # Set values for all props that have defaults. Use the default if and only if
+  # the prop key isn't in the input.
+  #
+  # @return [Integer] A count of props that we successfully initialized (which
+  # we'll use to check for any unrecognized input.)
+  #
+  # checked(:never) - O(runtime object construction)
+  sig {params(instance: T::Props::WeakConstructor, hash: T::Hash[Symbol, T.untyped]).returns(Integer).checked(:never)}
+  def construct_props_with_defaults(instance, hash)
+    @props_with_defaults&.count do |p, default_struct|
+      if hash.key?(p)
+        instance.instance_exec(hash[p], &default_struct.setter_proc)
+        true
+      else
+        default_struct.set_default(instance)
+        false
+      end
+    end || 0
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.5.5316
+  version: 0.5.5325
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-31 00:00:00.000000000 Z
+date: 2020-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -112,6 +112,7 @@ files:
 - lib/types/props/optional.rb
 - lib/types/props/plugin.rb
 - lib/types/props/pretty_printable.rb
+- lib/types/props/private/apply_default.rb
 - lib/types/props/private/setter_factory.rb
 - lib/types/props/serializable.rb
 - lib/types/props/type_validation.rb