sorbet-runtime 0.5.5255 → 0.5.5284

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5001cde809170dd114c21f38d060d0ea4d0c7447bd719020a28d8219c733593b
-  data.tar.gz: 8af071522bf9cfcfd89eea4ca0567e06ad6109cfe2e827f00542a00e971eaa26
+  metadata.gz: 6570883296df2b8c2f0f18bd126c932daeac62effd65b35544f04c5b467a66a2
+  data.tar.gz: 43f95a4fdd8d83076f72d3094438995b05440d222d487a67c20b328745eecc13
 SHA512:
-  metadata.gz: a7695bfaf0c47b193d1cccc99cb89159a7d29e2efbfb89c21c3dbbcd9c1ba4c5cb53ba12dbceb9589b2d51b6bc765854d45469931740a3c73f2c40517defa4c0
-  data.tar.gz: 812f4170808544d2d320fb834f28fcbdeba7d9ba26041b18cdece81aaae8feb1d924d7e942a60b4d305b5747867cd75abd6149da2be9ffc30ef966c3c89bb9f8
+  metadata.gz: 26308242fd0d09ba1585594cf116150ed3a3112c503e4f11ee96a3301450a9cf7742729200c8a4652d28a6b166eca32dd1c6e766c6a16099b6c403d67006c45b
+  data.tar.gz: c5e8e54c724a32857f50642cd18400a0886e66a33cc5a84ddc68d75919ebc576e5d7bd52365919f69b5a653591dced8c5566223fa375071af8ae3cd75f02297f

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

@@ -51,8 +51,14 @@ class T::Private::Methods::Signature
     @on_failure = on_failure
     @override_allow_incompatible = override_allow_incompatible
 
-    param_names = parameters.map {|_, name| name}
     declared_param_names = raw_arg_types.keys
+    # If sig params are declared but there is a single parameter with a missing name
+    # **and** the method ends with a "=", assume it is a writer method generated
+    # by attr_writer or attr_accessor
+    writer_method = declared_param_names != [nil] && parameters == [[:req]] && method_name[-1] == "="
+    # For writer methods, map the single parameter to the method name without the "=" at the end
+    parameters = [[:req, method_name[0...-1].to_sym]] if writer_method
+    param_names = parameters.map {|_, name| name}
     missing_names = param_names - declared_param_names
     extra_names = declared_param_names - param_names
     if !missing_names.empty?

data/lib/types/props/decorator.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: false
+# typed: strict
 
 # NB: This is not actually a decorator. It's just named that way for consistency
 # with DocumentDecorator and ModelDecorator (which both seem to have been written
@@ -11,26 +11,27 @@ class T::Props::Decorator
   extend T::Sig
 
   Rules = T.type_alias {T::Hash[Symbol, T.untyped]}
-  DecoratedClass = T.type_alias {T.untyped} # T.class_of(T::Props), but that produces circular reference errors in some circumstances
-  DecoratedInstance = T.type_alias {T.untyped} # Would be T::Props, but that produces circular reference errors in some circumstances
+  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)}
   PropTypeOrClass = T.type_alias {T.any(PropType, Module)}
 
   class NoRulesError < StandardError; end
 
-  sig {params(klass: DecoratedClass).void.checked(:never)}
+  EMPTY_PROPS = T.let({}.freeze, T::Hash[Symbol, Rules])
+  private_constant :EMPTY_PROPS
+
+  sig {params(klass: T.untyped).void}
   def initialize(klass)
-    @class = klass
-    klass.plugins.each do |mod|
-      Private.apply_decorator_methods(mod, self)
+    @class = T.let(klass, T.all(Module, T::Props::ClassMethods))
+    @class.plugins.each do |mod|
+      T::Props::Plugin::Private.apply_decorator_methods(mod, self)
     end
+    @props = T.let(EMPTY_PROPS, T::Hash[Symbol, Rules])
   end
 
   # checked(:never) - O(prop accesses)
   sig {returns(T::Hash[Symbol, Rules]).checked(:never)}
-  def props
-    @props ||= {}.freeze
-  end
+  attr_reader :props
 
   # Try to avoid using this; post-definition mutation of prop rules is
   # surprising and hard to reason about.
@@ -62,7 +63,7 @@ class T::Props::Decorator
     @props = @props.merge(prop => rules.freeze).freeze
   end
 
-  VALID_RULE_KEYS = %i{
+  VALID_RULE_KEYS = T.let(%i{
     enum
     foreign
     foreign_hint_only
@@ -76,16 +77,16 @@ class T::Props::Decorator
     extra
     optional
     _tnilable
-  }.map {|k| [k, true]}.to_h.freeze
+  }.map {|k| [k, true]}.to_h.freeze, T::Hash[Symbol, T::Boolean])
   private_constant :VALID_RULE_KEYS
 
   sig {params(key: Symbol).returns(T::Boolean).checked(:never)}
   def valid_rule_key?(key)
-    VALID_RULE_KEYS[key]
+    !!VALID_RULE_KEYS[key]
   end
 
   # checked(:never) - O(prop accesses)
-  sig {returns(DecoratedClass).checked(:never)}
+  sig {returns(T.all(Module, T::Props::ClassMethods)).checked(:never)}
   def decorated_class; @class; end
 
   # Accessors
@@ -109,87 +110,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,21 +127,24 @@ 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(
       instance: DecoratedInstance,
       prop: Symbol,
       val: T.untyped,
-      rules: T.nilable(Rules)
+      rules: Rules
     )
     .void
     .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.fetch(: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.
@@ -253,18 +185,18 @@ class T::Props::Decorator
       prop: Symbol,
       foreign_class: Module,
       rules: Rules,
-      opts: Hash
+      opts: T::Hash[Symbol, T.untyped],
     )
     .returns(T.untyped)
     .checked(:never)
   end
   def foreign_prop_get(instance, prop, foreign_class, rules=props[prop.to_sym], opts={})
     return if !(value = prop_get(instance, prop, rules))
-    foreign_class.load(value, {}, opts)
+    T.unsafe(foreign_class).load(value, {}, opts)
   end
 
   # TODO: we should really be checking all the methods on `cls`, not just Object
-  BANNED_METHOD_NAMES = Object.instance_methods.to_set.freeze
+  BANNED_METHOD_NAMES = T.let(Object.instance_methods.to_set.freeze, T::Set[Symbol])
 
   # checked(:never) - Rules hash is expensive to check
   sig do
@@ -314,6 +246,7 @@ class T::Props::Decorator
     nil
   end
 
+  sig {params(name: Symbol).void}
   private def validate_prop_name(name)
     if name !~ /\A[A-Za-z_][A-Za-z0-9_-]*\z/
       raise ArgumentError.new("Invalid prop name in #{@class.name}: #{name}")
@@ -440,7 +373,7 @@ class T::Props::Decorator
     # are ultimately included does.
     #
     if defined?(Opus) && defined?(Opus::Sensitivity) && defined?(Opus::Sensitivity::PIIable)
-      if sensitivity_and_pii[:pii] && @class.is_a?(Class) && !@class.contains_pii?
+      if sensitivity_and_pii[:pii] && @class.is_a?(Class) && !T.unsafe(@class).contains_pii?
         raise ArgumentError.new(
           'Cannot include a pii prop in a class that declares `contains_no_pii`'
         )
@@ -499,7 +432,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,18 +454,23 @@ 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|
+            T.unsafe(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.fetch(:setter_proc))
         end
       end
 
       if method(:prop_get).owner != T::Props::Decorator || rules.key?(:ifunset)
         @class.send(:define_method, name) do
-          self.class.decorator.prop_get(self, name, rules)
+          T.unsafe(self.class).decorator.prop_get(self, name, rules)
         end
       else
         # Fast path (~30x faster as of Ruby 2.6)
-        @class.attr_reader(name)
+        @class.send(:attr_reader, name) # send is used because `attr_reader` is private in 2.4
       end
     end
   end
@@ -597,10 +538,10 @@ class T::Props::Decorator
   end
 
   # From T::Props::Utils.deep_clone_object, plus String
-  TYPES_NOT_NEEDING_CLONE = [TrueClass, FalseClass, NilClass, Symbol, String, Numeric]
+  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::Boolean).checked(:never)}
+  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)
@@ -642,7 +583,7 @@ class T::Props::Decorator
   end
 
   # checked(:never) - Rules hash is expensive to check
-  sig {params(prop_name: Symbol, rules: Hash).void.checked(:never)}
+  sig {params(prop_name: Symbol, rules: Rules).void.checked(:never)}
   private def validate_not_missing_sensitivity(prop_name, rules)
     if rules[:sensitivity].nil?
       if rules[:redaction]
@@ -747,6 +688,7 @@ class T::Props::Decorator
     # *haven't* allowed additional options in the past and want to
     # default to keeping this interface narrow.
     @class.send(:define_method, fk_method) do |allow_direct_mutation: nil|
+      foreign = T.let(foreign, T.untyped)
       if foreign.is_a?(Proc)
         resolved_foreign = foreign.call
         if !resolved_foreign.respond_to?(:load)
@@ -765,7 +707,7 @@ class T::Props::Decorator
         opts = {allow_direct_mutation: allow_direct_mutation}
       end
 
-      self.class.decorator.foreign_prop_get(self, prop_name, foreign, rules, opts)
+      T.unsafe(self.class).decorator.foreign_prop_get(self, prop_name, foreign, rules, opts)
     end
 
     force_fk_method = "#{fk_method}!"
@@ -777,7 +719,7 @@ class T::Props::Decorator
           storytime: {method: force_fk_method, class: self.class}
         )
       end
-      T.must(loaded_foreign)
+      loaded_foreign
     end
 
     @class.send(:define_method, "#{prop_name}_record") do |allow_direct_mutation: nil|
@@ -826,16 +768,17 @@ class T::Props::Decorator
   #
   # This gets called when a module or class that extends T::Props gets included, extended,
   # prepended, or inherited.
-  sig {params(child: DecoratedClass).void.checked(:never)}
+  sig {params(child: Module).void.checked(:never)}
   def model_inherited(child)
     child.extend(T::Props::ClassMethods)
-    child.plugins.concat(decorated_class.plugins)
+    child = T.cast(child, T.all(Module, T::Props::ClassMethods))
 
+    child.plugins.concat(decorated_class.plugins)
     decorated_class.plugins.each do |mod|
       # NB: apply_class_methods must not be an instance method on the decorator itself,
       # otherwise we'd have to call child.decorator here, which would create the decorator
       # before any `decorator_class` override has a chance to take effect (see the comment below).
-      Private.apply_class_methods(mod, child)
+      T::Props::Plugin::Private.apply_class_methods(mod, child)
     end
 
     props.each do |name, rules|
@@ -855,9 +798,18 @@ class T::Props::Decorator
       #
       unless rules[:without_accessors]
         if child.decorator.method(:prop_get).owner != method(:prop_get).owner &&
-            child.instance_method(name).source_location.first == __FILE__
+            child.instance_method(name).source_location&.first == __FILE__
           child.send(:define_method, name) do
-            self.class.decorator.prop_get(self, name, rules)
+            T.unsafe(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|
+              T.unsafe(self.class).decorator.prop_set(self, name, val, rules)
+            end
           end
         end
       end
@@ -867,27 +819,7 @@ class T::Props::Decorator
   sig {params(mod: Module).void.checked(:never)}
   def plugin(mod)
     decorated_class.plugins << mod
-    Private.apply_class_methods(mod, decorated_class)
-    Private.apply_decorator_methods(mod, self)
-  end
-
-  module Private
-    # These need to be non-instance methods so we can use them without prematurely creating the
-    # child decorator in `model_inherited` (see comments there for details).
-    def self.apply_class_methods(plugin, target)
-      if plugin.const_defined?('ClassMethods')
-        # FIXME: This will break preloading, selective test execution, etc if `mod::ClassMethods`
-        # is ever defined in a separate file from `mod`.
-        target.extend(plugin::ClassMethods) # rubocop:disable PrisonGuard/NoDynamicConstAccess
-      end
-    end
-
-    def self.apply_decorator_methods(plugin, target)
-      if plugin.const_defined?('DecoratorMethods')
-        # FIXME: This will break preloading, selective test execution, etc if `mod::DecoratorMethods`
-        # is ever defined in a separate file from `mod`.
-        target.extend(plugin::DecoratorMethods) # rubocop:disable PrisonGuard/NoDynamicConstAccess
-      end
-    end
+    T::Props::Plugin::Private.apply_class_methods(mod, decorated_class)
+    T::Props::Plugin::Private.apply_decorator_methods(mod, self)
   end
 end

data/lib/types/props/plugin.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: true
+# typed: false
 
 module T::Props::Plugin
   include T::Props
@@ -12,4 +12,26 @@ module T::Props::Plugin
     end
   end
   mixes_in_class_methods(ClassMethods)
+
+  module Private
+    # These need to be non-instance methods so we can use them without prematurely creating the
+    # child decorator in `model_inherited` (see comments there for details).
+    #
+    # The dynamic constant access below forces this file to be `typed: false`
+    def self.apply_class_methods(plugin, target)
+      if plugin.const_defined?('ClassMethods')
+        # FIXME: This will break preloading, selective test execution, etc if `mod::ClassMethods`
+        # is ever defined in a separate file from `mod`.
+        target.extend(plugin::ClassMethods) # rubocop:disable PrisonGuard/NoDynamicConstAccess
+      end
+    end
+
+    def self.apply_decorator_methods(plugin, target)
+      if plugin.const_defined?('DecoratorMethods')
+        # FIXME: This will break preloading, selective test execution, etc if `mod::DecoratorMethods`
+        # is ever defined in a separate file from `mod`.
+        target.extend(plugin::DecoratorMethods) # rubocop:disable PrisonGuard/NoDynamicConstAccess
+      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.5255
+  version: 0.5.5284
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-16 00:00:00.000000000 Z
+date: 2020-01-25 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