sorbet-runtime 0.5.5262 → 0.5.5265

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 04ffc124de39ff9df564bcefc3535063ae7416d3a468f565b199b0f2359838fd
-  data.tar.gz: 74284ac5b08f7be2e1cc85b5f7415051643e7d5d9b77cd9c07934b8d85c5495e
+  metadata.gz: 8ece434fac1367289d5e0cba4706f2163bffe4875e5c55aa6a2e926398777961
+  data.tar.gz: 7ecbe46eb8bb3531dc649711e09a7f3c0a4ea357bea901c754ea240491f0a9bc
 SHA512:
-  metadata.gz: 0ac146a8172fdd2374fb35e0ea4de6fe2b04bdcce79c79f1133eeabf395f9a8c703e1fe881389f3b497e787258d7c1fad324629c40f6e1daefd18fec56a2dc7d
-  data.tar.gz: 296a6b1b1099111c83e8e859119eb76a36ca1499b2d0e89abb06ab07ea73575b606c5d0b54e7231330d1a27fb6fa0f78f09dcbd7bcd5dcfeb6b8f3e09df8703a
+  metadata.gz: 3b3a3a27c2ec61f17702301ee54e944aee9c9aaa534072ba9769466ef1c3bbae8aac3da46d631ac9ad66273fda1cb728c24ab07d37f35e58dc12bbf63c8fa7ce
+  data.tar.gz: b2ba393fd64aab9b5f0a1cd2fded2d9fa0639d5d8fb5355b5d96f13682af9c9802571a1f81ba1dfd3c85ef884195fb5f3a950a9511518b44e2bb099126595f8c

data/lib/sorbet-runtime.rb

@@ -93,6 +93,7 @@ require_relative 'types/props/errors'
 require_relative 'types/props/plugin'
 require_relative 'types/props/utils'
 # Props that run sigs statically so have to be after all the others :(
+require_relative 'types/props/private/setter_factory'
 require_relative 'types/props/optional'
 require_relative 'types/props/weak_constructor'
 require_relative 'types/props/constructor'

data/lib/types/props/decorator.rb

@@ -109,87 +109,15 @@ class T::Props::Decorator
     instance.instance_variable_get(rules ? rules[:accessor_key] : '@' + prop.to_s) # rubocop:disable PrisonGuard/NoLurkyInstanceVariableAccess
   end
 
-  # For performance, don't use named params here.
-  # Passing in rules here is purely a performance optimization.
-  #
-  # checked(:never) - O(prop accesses)
-  sig do
-    params(
-      instance: DecoratedInstance,
-      prop: Symbol,
-      value: T.untyped,
-      rules: T.nilable(Rules)
-    )
-    .void
-    .checked(:never)
-  end
-  def set(instance, prop, value, rules=props[prop.to_sym])
-    # For backwards compatibility, fall back to reconstructing the accessor key
-    # (though it would probably make more sense to raise in that case).
-    instance.instance_variable_set(rules ? rules[:accessor_key] : '@' + prop.to_s, value) # rubocop:disable PrisonGuard/NoLurkyInstanceVariableAccess
-  end
-
   # Use this to validate that a value will validate for a given prop. Useful for knowing whether a value can be set on a model without setting it.
   #
   # checked(:never) - potentially O(prop accesses) depending on usage pattern
   sig {params(prop: Symbol, val: T.untyped).void.checked(:never)}
   def validate_prop_value(prop, val)
-    # This implements a 'public api' on document so that we don't allow callers to pass in rules
-    # Rules seem like an implementation detail so it seems good to now allow people to specify them manually.
-    check_prop_type(prop, val)
-  end
-
-  # Passing in rules here is purely a performance optimization.
-  #
-  # checked(:never) - O(prop accesses)
-  sig {params(prop: Symbol, val: T.untyped, rules: Rules).void.checked(:never)}
-  private def check_prop_type(prop, val, rules=prop_rules(prop))
-    type_object = rules.fetch(:type_object)
-    type = rules.fetch(:type)
-
-    # TODO: ideally we'd add `&& rules[:optional] != :existing` to this check
-    # (it makes sense to treat those props required in this context), but we'd need
-    # to be sure that doesn't break any existing code first.
-    if val.nil?
-      if !T::Props::Utils.need_nil_write_check?(rules) || (rules.key?(:default) && rules[:default].nil?)
-        return
-      end
-
-      if rules[:raise_on_nil_write]
-        raise T::Props::InvalidValueError.new("Can't set #{@class.name}.#{prop} to #{val.inspect} " \
-        "(instance of #{val.class}) - need a #{type}")
-      end
-    end
-
-    # T::Props::CustomType is not a real object based class so that we can not run real type check call.
-    # T::Props::CustomType.valid?() is only a helper function call.
-    valid =
-      if type.is_a?(T::Props::CustomType) && T::Props::Utils.optional_prop?(rules)
-        type.valid?(val)
-      else
-        type_object.valid?(val)
-      end
-
-    if !valid
-      raise T::Props::InvalidValueError.new("Can't set #{@class.name}.#{prop} to #{val.inspect} " \
-        "(instance of #{val.class}) - need a #{type_object}")
-    end
-  rescue T::Props::InvalidValueError => err
-    caller_loc = T.must(caller_locations(8, 1))[0]
-
-    pretty_message = "Parameter '#{prop}': #{err.message}\n" \
-      "Caller: #{caller_loc.path}:#{caller_loc.lineno}\n"
-
-    T::Configuration.call_validation_error_handler(
-      nil,
-      message: err.message,
-      pretty_message: pretty_message,
-      kind: 'Parameter',
-      name: prop,
-      type: type,
-      value: val,
-      location: caller_loc,
-    )
+    # We call `setter_proc` here without binding to an instance, so it'll run
+    # `instance_variable_set` if validation passes, but nothing will care.
+    # We only care about the validation.
+    prop_rules(prop).fetch(:setter_proc).call(val)
   end
 
   # For performance, don't use named params here.
@@ -198,6 +126,9 @@ class T::Props::Decorator
   # the default, which raises if the prop doesn't exist (this maintains
   # preexisting behavior).
   #
+  # Note this path is NOT used by generated setters on instances,
+  # which are defined using `setter_proc` directly.
+  #
   # checked(:never) - O(prop accesses)
   sig do
     params(
@@ -210,9 +141,9 @@ class T::Props::Decorator
     .checked(:never)
   end
   def prop_set(instance, prop, val, rules=prop_rules(prop))
-    check_prop_type(prop, val, T.must(rules))
-    set(instance, prop, val, rules)
+    instance.instance_exec(val, &rules[:setter_proc])
   end
+  alias_method :set, :prop_set
 
   # For performance, don't use named params here.
   # Passing in rules here is purely a performance optimization.
@@ -499,7 +430,10 @@ class T::Props::Decorator
       rules[:serializable_subtype] = hash_key_custom_type
     end
 
+    rules[:setter_proc] = T::Props::Private::SetterFactory.build_setter_proc(@class, name, rules).freeze
+
     add_prop_definition(name, rules)
+
     # NB: using `without_accessors` doesn't make much sense unless you also define some other way to
     # get at the property (e.g., Chalk::ODM::Document exposes `get` and `set`).
     define_getter_and_setter(name, rules) unless rules[:without_accessors]
@@ -518,8 +452,13 @@ class T::Props::Decorator
   private def define_getter_and_setter(name, rules)
     T::Configuration.without_ruby_warnings do
       if !rules[:immutable]
-        @class.send(:define_method, "#{name}=") do |x|
-          self.class.decorator.prop_set(self, name, x, rules)
+        if method(:prop_set).owner != T::Props::Decorator
+          @class.send(:define_method, "#{name}=") do |val|
+            self.class.decorator.prop_set(self, name, val, rules)
+          end
+        else
+          # Fast path (~4x faster as of Ruby 2.6)
+          @class.send(:define_method, "#{name}=", &rules[:setter_proc])
         end
       end
 
@@ -860,6 +799,15 @@ class T::Props::Decorator
             self.class.decorator.prop_get(self, name, rules)
           end
         end
+
+        unless rules[:immutable]
+          if child.decorator.method(:prop_set).owner != method(:prop_set).owner &&
+              child.instance_method("#{name}=").source_location.first == __FILE__
+            child.send(:define_method, "#{name}=") do |val|
+              self.class.decorator.prop_set(self, name, val, rules)
+            end
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+# typed: strict
+
+module T::Props
+  module Private
+    module SetterFactory
+      extend T::Sig
+
+      SetterProc = T.type_alias {T.proc.params(val: T.untyped).void}
+
+      sig do
+        params(
+          klass: T.all(Module, T::Props::ClassMethods),
+          prop: Symbol,
+          rules: T::Hash[Symbol, T.untyped]
+        )
+        .returns(SetterProc)
+        .checked(:never)
+      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
+        accessor_key = rules.fetch(:accessor_key)
+        raise_error = ->(val) {raise_pretty_error(klass, prop, non_nil_type, val)}
+
+        # It seems like a bug that this affects the behavior of setters, but
+        # some existing code relies on this behavior
+        has_explicit_nil_default = rules.key?(:default) && rules.fetch(:default).nil?
+
+        if !T::Props::Utils.need_nil_write_check?(rules) || has_explicit_nil_default
+          proc do |val|
+            if val.nil?
+              instance_variable_set(accessor_key, nil)
+            elsif non_nil_type.valid?(val)
+              instance_variable_set(accessor_key, val)
+            else
+              raise_error.call(val)
+            end
+          end
+        else
+          proc do |val|
+            if non_nil_type.valid?(val)
+              instance_variable_set(accessor_key, val)
+            else
+              raise_error.call(val)
+            end
+          end
+        end
+      end
+
+      sig do
+        params(
+          klass: T.all(Module, T::Props::ClassMethods),
+          prop: Symbol,
+          type: T.any(T::Types::Base, Module),
+          val: T.untyped,
+        )
+        .void
+      end
+      private_class_method def self.raise_pretty_error(klass, prop, type, val)
+        base_message = "Can't set #{klass.name}.#{prop} to #{val.inspect} (instance of #{val.class}) - need a #{type}"
+
+        pretty_message = "Parameter '#{prop}': #{base_message}\n"
+        caller_loc = caller_locations&.find {|l| !l.to_s.include?('sorbet-runtime/lib/types/props')}
+        if caller_loc
+          pretty_message += "Caller: #{caller_loc.path}:#{caller_loc.lineno}\n"
+        end
+
+        T::Configuration.call_validation_error_handler(
+          nil,
+          message: base_message,
+          pretty_message: pretty_message,
+          kind: 'Parameter',
+          name: prop,
+          type: type,
+          value: val,
+          location: caller_loc,
+        )
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.5.5262
+  version: 0.5.5265
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-17 00:00:00.000000000 Z
+date: 2020-01-18 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/setter_factory.rb
 - lib/types/props/serializable.rb
 - lib/types/props/type_validation.rb
 - lib/types/props/utils.rb