sorbet-runtime 0.5.5267 → 0.5.5278

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e80e62f05cff1ad901687fffed408a7f499960c8f6f1eb385e1c718da5c22f5
-  data.tar.gz: 4f3a1278a70cf33a7b089169822f8f112fab2f9fb4163971259fd2706e6a83c5
+  metadata.gz: 351ff337a29d85d7adcd563eb352cc9516be5d80ac8d4c7eda271e51ed295d52
+  data.tar.gz: 2d1f3e87d3b84650f4bcf3ca1eae08385999e1c9e9cbe930cb42db7289c9497d
 SHA512:
-  metadata.gz: 299a7722c03ca6ad39c8f6ef613baeee4cbe5dc5876d603de8735dc68ef9f4c4cd172b33e6ef8f4a5a6aa31ec344536c6b3da7d017573270e5d14fd7c59a8e1f
-  data.tar.gz: c344d7b552ea719a41e76e01aab817910442cf80a78dcac81aa5c0037365212bed2d06fedbb412252076812170f983b3763dfd6e3b99d0bf746187f76f8f88dc
+  metadata.gz: ece19477f2ce3df3d12a314a90eeed696b4168ddae9fd78e052d3f60a21c6bb618aeda3db95fd30e5947369f6bf04be07f8856b4781259d9693d157128f219eb
+  data.tar.gz: fa6c021527b7d372c4f648103245117c6b2998ffd7bb63ada0dc6216d3ae6dfd077c53a4659132c6d38aec6b3b3415eabfd49f81055f6dd06dce821b9da15f91

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
@@ -135,13 +136,13 @@ class T::Props::Decorator
       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))
-    instance.instance_exec(val, &rules[:setter_proc])
+    instance.instance_exec(val, &rules.fetch(:setter_proc))
   end
   alias_method :set, :prop_set
 
@@ -184,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
@@ -245,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}")
@@ -371,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`'
         )
@@ -454,21 +456,21 @@ class T::Props::Decorator
       if !rules[:immutable]
         if method(:prop_set).owner != T::Props::Decorator
           @class.send(:define_method, "#{name}=") do |val|
-            self.class.decorator.prop_set(self, name, val, rules)
+            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[:setter_proc])
+          @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
@@ -536,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)
@@ -581,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]
@@ -686,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)
@@ -704,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}!"
@@ -716,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|
@@ -765,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|
@@ -794,17 +798,17 @@ 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.instance_method("#{name}=").source_location&.first == __FILE__
             child.send(:define_method, "#{name}=") do |val|
-              self.class.decorator.prop_set(self, name, val, rules)
+              T.unsafe(self.class).decorator.prop_set(self, name, val, rules)
             end
           end
         end
@@ -815,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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.5.5267
+  version: 0.5.5278
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-22 00:00:00.000000000 Z
+date: 2020-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest