sorbet-runtime 0.5.5200 → 0.5.5226

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80710bef2aa0399340fc377530a27026e271cd80f4a290b76ba56d4fc7a90094
-  data.tar.gz: 6e35bef9804041e6a23a05b503b213e1a4052af7260f785162af3c20d04c0bff
+  metadata.gz: ce5d31efe70f4a4a9fedee60cddc4545cce308285d1a92e9b75f7c6c5cfd0ead
+  data.tar.gz: 8ff1cb8a2b9a7c0f1987925899bfcf674c27b594156c9dd8e60ee27ec51d1dd1
 SHA512:
-  metadata.gz: 1ecde44bd9fed96fabc8d2f9b8249375daa79d9f97b9c662daac690c54fee1d96f8eb41571ba83e8508f7c28ab0cb8fbe2dbbf75148195dba93aa1b619b11327
-  data.tar.gz: f0e44dc08ec3d2eca82db242634b2eea7f128f582369f11b1554c61407a08840dacf8c93121cbe758ccfc1965b3f26cfa2dddaa6801a8f62a91485d9c2aaa3a6
+  metadata.gz: bc94cf76fd49747ab049a66bfbd30dc4a0b037ac0f8988a4c6f6a5e6421abf92f209c14a8fe42c0268ca34d8fa5e77cc4fcddc24f08bd8cc6e7175068cc0285e
+  data.tar.gz: 38dc583fc54332f763cb1982bce24e5c23e2d2125a0dfd451354eb16f5adc8bab07ee2c4cfda1642b83795bc1539d153b7063df2ffd367faa4d1798ca856cd13

data/lib/types/_types.rb

@@ -65,12 +65,8 @@ module T
     T::Types::SelfType.new
   end
 
-  # TODO(jez) Matches the instance type in a singleton-class context
-  def self.attached_class
-    T::Types::AttachedClassType.new
-  end
   # Matches the instance type in a singleton-class context
-  def self.experimental_attached_class
+  def self.attached_class
     T::Types::AttachedClassType.new
   end
 

data/lib/types/enum.rb

@@ -48,7 +48,7 @@ class T::Enum
   private_constant :SerializedVal
 
   ## Enum class methods ##
-  sig {returns(T::Array[T.experimental_attached_class])}
+  sig {returns(T::Array[T.attached_class])}
   def self.values
     if @values.nil?
       raise "Attempting to access values of #{self.class} before it has been initialized." \
@@ -61,7 +61,7 @@ class T::Enum
   #
   # Note: It would have been nice to make this method final before people started overriding it.
   # Note: Failed CriticalMethodsNoRuntimeTypingTest
-  sig {params(serialized_val: SerializedVal).returns(T.nilable(T.experimental_attached_class)).checked(:never)}
+  sig {params(serialized_val: SerializedVal).returns(T.nilable(T.attached_class)).checked(:never)}
   def self.try_deserialize(serialized_val)
     if @mapping.nil?
       raise "Attempting to access serialization map of #{self.class} before it has been initialized." \
@@ -77,7 +77,7 @@ class T::Enum
   #
   # @return [self]
   # @raise [KeyError] if serialized value does not match any instance.
-  sig {overridable.params(serialized_val: SerializedVal).returns(T.experimental_attached_class).checked(:never)}
+  sig {overridable.params(serialized_val: SerializedVal).returns(T.attached_class).checked(:never)}
   def self.from_serialized(serialized_val)
     res = try_deserialize(serialized_val)
     if res.nil?
@@ -124,7 +124,7 @@ class T::Enum
   end
 
   # Note: Failed CriticalMethodsNoRuntimeTypingTest
-  sig {params(mongo_value: SerializedVal).returns(T.experimental_attached_class).checked(:never)}
+  sig {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."
@@ -310,8 +310,8 @@ class T::Enum
 
     yield
 
-    @values = T.let(nil, T.nilable(T::Array[T.experimental_attached_class]))
-    @mapping = T.let(nil, T.nilable(T::Hash[SerializedVal, T.experimental_attached_class]))
+    @values = T.let(nil, T.nilable(T::Array[T.attached_class]))
+    @mapping = T.let(nil, T.nilable(T::Hash[SerializedVal, T.attached_class]))
 
     # Freeze the Enum class and bind the constant names into each of the instances.
     @mapping = {}

data/lib/types/props/_props.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: false
+# typed: true
 
 # A mixin for defining typed properties (attributes).
 # To get serialization methods (to/from JSON-style hashes), add T::Props::Serializable.
@@ -131,7 +131,7 @@ module T::Props
     sig {params(name: T.any(Symbol, String), cls_or_args: T.untyped, args: T::Hash[Symbol, T.untyped]).void}
     def const(name, cls_or_args, args={})
       if (cls_or_args.is_a?(Hash) && cls_or_args.key?(:immutable)) || args.key?(:immutable)
-        raise ArgumentError.new("Cannot pass 'immutable' argument when using 'const' keyword to define a prop")
+        Kernel.raise ArgumentError.new("Cannot pass 'immutable' argument when using 'const' keyword to define a prop")
       end
 
       if cls_or_args.is_a?(Hash)

data/lib/types/props/decorator.rb

@@ -18,7 +18,7 @@ class T::Props::Decorator
 
   class NoRulesError < StandardError; end
 
-  T::Sig::WithoutRuntime.sig {params(klass: DecoratedClass).void}
+  sig {params(klass: DecoratedClass).void.checked(:never)}
   def initialize(klass)
     @class = klass
     klass.plugins.each do |mod|
@@ -26,7 +26,7 @@ class T::Props::Decorator
     end
   end
 
-  # prop stuff
+  # checked(:never) - O(prop accesses)
   sig {returns(T::Hash[Symbol, Rules]).checked(:never)}
   def props
     @props ||= {}.freeze
@@ -44,12 +44,13 @@ class T::Props::Decorator
   sig {returns(T::Array[Symbol])}
   def all_props; props.keys; end
 
+  # checked(:never) - O(prop accesses)
   sig {params(prop: T.any(Symbol, String)).returns(Rules).checked(:never)}
   def prop_rules(prop); props[prop.to_sym] || raise("No such prop: #{prop.inspect}"); end
 
-  sig {params(prop: Symbol, rules: Rules).void}
+  # checked(:never) - Rules hash is expensive to check
+  sig {params(prop: Symbol, rules: Rules).void.checked(:never)}
   def add_prop_definition(prop, rules)
-    prop = prop.to_sym
     override = rules.delete(:override)
 
     if props.include?(prop) && !override
@@ -61,25 +62,36 @@ class T::Props::Decorator
     @props = @props.merge(prop => rules.freeze).freeze
   end
 
-  sig {returns(T::Array[Symbol])}
+  VALID_RULE_KEYS = %i{
+    enum
+    foreign
+    foreign_hint_only
+    ifunset
+    immutable
+    override
+    redaction
+    sensitivity
+    without_accessors
+    clobber_existing_method!
+    extra
+    optional
+    _tnilable
+  }.to_set.freeze
+  private_constant :VALID_RULE_KEYS
+
+  sig {params(key: Symbol).returns(T::Boolean).checked(:never)}
+  def valid_rule_key?(key)
+    valid_props.include?(key)
+  end
+
+  # Deprecated, kept temporarily to support overrides in pay-server
+  # during the transition to `valid_rule_key?`
+  sig {returns(T::Set[Symbol]).checked(:never)}
   def valid_props
-    %i{
-      enum
-      foreign
-      foreign_hint_only
-      ifunset
-      immutable
-      override
-      redaction
-      sensitivity
-      without_accessors
-      clobber_existing_method!
-      extra
-      optional
-      _tnilable
-    }
+    VALID_RULE_KEYS
   end
 
+  # checked(:never) - O(prop accesses)
   sig {returns(DecoratedClass).checked(:never)}
   def decorated_class; @class; end
 
@@ -87,6 +99,8 @@ class T::Props::Decorator
 
   # 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,
@@ -104,6 +118,8 @@ class T::Props::Decorator
 
   # 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,
@@ -121,6 +137,8 @@ class T::Props::Decorator
   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
@@ -129,6 +147,8 @@ class T::Props::Decorator
   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)
@@ -184,6 +204,8 @@ class T::Props::Decorator
   # Unlike the other methods that take rules, this one calls prop_rules for
   # the default, which raises if the prop doesn't exist (this maintains
   # preexisting behavior).
+  #
+  # checked(:never) - O(prop accesses)
   sig do
     params(
       instance: DecoratedInstance,
@@ -201,6 +223,11 @@ class T::Props::Decorator
 
   # For performance, don't use named params here.
   # Passing in rules here is purely a performance optimization.
+  #
+  # Note this path is NOT used by generated getters on instances,
+  # unless `ifunset` is used on the prop, or `prop_get` is overridden.
+  #
+  # checked(:never) - O(prop accesses)
   sig do
     params(
       instance: DecoratedInstance,
@@ -213,15 +240,7 @@ class T::Props::Decorator
   def prop_get(instance, prop, rules=props[prop.to_sym])
     val = get(instance, prop, rules)
 
-    # NB: Do NOT change this to check `val.nil?` instead. BSON::ByteBuffer overrides `==` such
-    # that `== nil` can return true while `.nil?` returns false. Tests will break in mysterious
-    # ways. A special thanks to Ruby for enabling this type of bug.
-    #
-    # One side effect here is that _if_ a class (like BSON::ByteBuffer) defines ==
-    # in such a way that instances which are not `nil`, ie are not NilClass, nevertheless
-    # are `== nil`, then we will transparently convert such instances to `nil` on read.
-    # Yes, our code relies on this behavior (as of writing). :thisisfine:
-    if val != nil # rubocop:disable Style/NonNilCheck
+    if !val.nil?
       val
     else
       raise NoRulesError.new if !rules
@@ -234,6 +253,7 @@ class T::Props::Decorator
     end
   end
 
+  # checked(:never) - O(prop accesses)
   sig do
     params(
       instance: DecoratedInstance,
@@ -250,6 +270,10 @@ class T::Props::Decorator
     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
+
+  # checked(:never) - Rules hash is expensive to check
   sig do
     params(
       name: Symbol,
@@ -258,6 +282,7 @@ class T::Props::Decorator
       type: PropTypeOrClass
     )
     .void
+    .checked(:never)
   end
   def prop_validate_definition!(name, cls, rules, type)
     validate_prop_name(name)
@@ -267,7 +292,7 @@ class T::Props::Decorator
         "to 'sensitivity:' (in prop #{@class.name}.#{name})")
     end
 
-    if !(rules.keys - valid_props).empty?
+    if rules.keys.any? {|k| !valid_rule_key?(k)}
       raise ArgumentError.new("At least one invalid prop arg supplied in #{self}: #{rules.keys.inspect}")
     end
 
@@ -278,8 +303,7 @@ class T::Props::Decorator
     end
 
     if !(rules[:clobber_existing_method!]) && !(rules[:without_accessors])
-      # TODO: we should really be checking all the methods on `cls`, not just Object
-      if Object.instance_methods.include?(name.to_sym)
+      if BANNED_METHOD_NAMES.include?(name.to_sym)
         raise ArgumentError.new(
           "#{name} can't be used as a prop in #{@class} because a method with " \
           "that name already exists (defined by #{@class.instance_method(name).owner} " \
@@ -303,13 +327,6 @@ class T::Props::Decorator
     end
   end
 
-  # Check if this cls represents a T.nilable(type)
-  sig {params(type: PropTypeOrClass).returns(T::Boolean)}
-  private def is_nilable?(type)
-    return false if !type.is_a?(T::Types::Union)
-    type.types.any? {|t| t == T::Utils.coerce(NilClass)}
-  end
-
   # This converts the type from a T::Type to a regular old ruby class.
   sig {params(type: T::Types::Base).returns(Module)}
   private def convert_type_to_class(type)
@@ -338,6 +355,7 @@ class T::Props::Decorator
     end
   end
 
+  # checked(:never) - Rules hash is expensive to check
   sig do
     params(
       name: T.any(Symbol, String),
@@ -345,6 +363,7 @@ class T::Props::Decorator
       rules: Rules,
     )
     .void
+    .checked(:never)
   end
   def prop_defined(name, cls, rules={})
     cls = T::Utils.resolve_alias(cls)
@@ -501,7 +520,8 @@ class T::Props::Decorator
     handle_redaction_option(name, rules[:redaction]) if rules[:redaction]
   end
 
-  sig {params(name: Symbol, rules: Rules).void}
+  # checked(:never) - Rules hash is expensive to check
+  sig {params(name: Symbol, rules: Rules).void.checked(:never)}
   private def define_getter_and_setter(name, rules)
     T::Configuration.without_ruby_warnings do
       if !rules[:immutable]
@@ -510,16 +530,24 @@ class T::Props::Decorator
         end
       end
 
-      @class.send(:define_method, name) do
-        self.class.decorator.prop_get(self, name, rules)
+      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)
+        end
+      else
+        # Fast path (~30x faster as of Ruby 2.6)
+        @class.attr_reader(name)
       end
     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)
@@ -535,9 +563,12 @@ class T::Props::Decorator
   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)
@@ -553,9 +584,12 @@ class T::Props::Decorator
   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)
@@ -572,7 +606,8 @@ class T::Props::Decorator
   # From T::Props::Utils.deep_clone_object, plus String
   TYPES_NOT_NEEDING_CLONE = [TrueClass, FalseClass, NilClass, Symbol, String, Numeric]
 
-  sig {params(type: PropType).returns(T::Boolean)}
+  # checked(:never) - Typechecks internally
+  sig {params(type: PropType).returns(T::Boolean).checked(:never)}
   private def shallow_clone_ok(type)
     inner_type =
       if type.is_a?(T::Types::TypedArray)
@@ -613,7 +648,8 @@ class T::Props::Decorator
     end
   end
 
-  sig {params(prop_name: Symbol, rules: Hash).void}
+  # checked(:never) - Rules hash is expensive to check
+  sig {params(prop_name: Symbol, rules: Hash).void.checked(:never)}
   private def validate_not_missing_sensitivity(prop_name, rules)
     if rules[:sensitivity].nil?
       if rules[:redaction]
@@ -700,6 +736,7 @@ class T::Props::Decorator
     )
   end
 
+  # checked(:never) - Rules hash is expensive to check
   sig do
     params(
       prop_name: T.any(String, Symbol),
@@ -707,6 +744,7 @@ class T::Props::Decorator
       foreign: T.untyped,
     )
     .void
+    .checked(:never)
   end
   private def define_foreign_method(prop_name, rules, foreign)
     fk_method = "#{prop_name}_"
@@ -758,6 +796,7 @@ class T::Props::Decorator
     end
   end
 
+  # checked(:never) - Rules hash is expensive to check
   sig do
     params(
       prop_name: Symbol,
@@ -766,6 +805,7 @@ class T::Props::Decorator
       foreign: T.untyped,
     )
     .void
+    .checked(:never)
   end
   private def handle_foreign_option(prop_name, prop_cls, rules, foreign)
     validate_foreign_option(
@@ -793,7 +833,7 @@ class T::Props::Decorator
   #
   # This gets called when a module or class that extends T::Props gets included, extended,
   # prepended, or inherited.
-  T::Sig::WithoutRuntime.sig {params(child: DecoratedClass).void}
+  sig {params(child: DecoratedClass).void.checked(:never)}
   def model_inherited(child)
     child.extend(T::Props::ClassMethods)
     child.plugins.concat(decorated_class.plugins)
@@ -811,10 +851,27 @@ class T::Props::Decorator
       # time. Any class that defines props and also overrides the `decorator_class` method is going
       # to reach this line before its override take effect, turning it into a no-op.
       child.decorator.add_prop_definition(name, copied_rules)
+
+      # It's a bit tricky to support `prop_get` hooks added by plugins without
+      # sacrificing the `attr_reader` fast path or clobbering customized getters
+      # defined manually on a child.
+      #
+      # To make this work, we _do_ clobber getters defined on the child, but only if:
+      # (a) it's needed in order to support a `prop_get` hook, and
+      # (b) it's safe because the getter was defined by this file.
+      #
+      unless rules[:without_accessors]
+        if child.decorator.method(:prop_get).owner != method(:prop_get).owner &&
+            child.instance_method(name).source_location.first == __FILE__
+          child.send(:define_method, name) do
+            self.class.decorator.prop_get(self, name, rules)
+          end
+        end
+      end
     end
   end
 
-  T::Sig::WithoutRuntime.sig {params(mod: Module).void}
+  sig {params(mod: Module).void.checked(:never)}
   def plugin(mod)
     decorated_class.plugins << mod
     Private.apply_class_methods(mod, decorated_class)

data/lib/types/props/optional.rb

@@ -21,12 +21,15 @@ module T::Props::Optional::DecoratorMethods
     true,
   ].freeze
 
-  def valid_props
-    super + [
-      :default,
-      :factory,
-      :optional,
-    ]
+  VALID_RULE_KEYS = Set[
+    :default,
+    :factory,
+    :optional,
+  ].freeze
+  private_constant :VALID_RULE_KEYS
+
+  def valid_rule_key?(key)
+    super || VALID_RULE_KEYS.include?(key)
   end
 
   def prop_optional?(prop); prop_rules(prop)[:fully_optional]; end

data/lib/types/props/pretty_printable.rb

@@ -18,9 +18,9 @@ module T::Props::PrettyPrintable
   module DecoratorMethods
     extend T::Sig
 
-    sig {returns(T::Array[Symbol])}
-    def valid_props
-      super + [:inspect]
+    sig {params(key: Symbol).returns(T::Boolean).checked(:never)}
+    def valid_rule_key?(key)
+      super || key == :inspect
     end
 
     sig do

data/lib/types/props/serializable.rb

@@ -274,12 +274,12 @@ end
 # NB: This must stay in the same file where T::Props::Serializable 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::Serializable::DecoratorMethods
-  def valid_props
-    super + [
-      :dont_store,
-      :name,
-      :raise_on_nil_write,
-    ]
+
+  VALID_RULE_KEYS = Set[:dont_store, :name, :raise_on_nil_write].freeze
+  private_constant :VALID_RULE_KEYS
+
+  def valid_rule_key?(key)
+    super || VALID_RULE_KEYS.include?(key)
   end
 
   def required_props

data/lib/types/props/type_validation.rb

@@ -11,9 +11,9 @@ module T::Props::TypeValidation
   module DecoratorMethods
     extend T::Sig
 
-    sig {returns(T::Array[Symbol])}
-    def valid_props
-      super + [:DEPRECATED_underspecified_type]
+    sig {params(key: Symbol).returns(T::Boolean).checked(:never)}
+    def valid_rule_key?(key)
+      super || :DEPRECATED_underspecified_type == key
     end
 
     sig do
@@ -53,7 +53,9 @@ module T::Props::TypeValidation
     # a subtype like the type of the values of a typed hash.
     #
     # If the type is fully valid, returns nil.
-    sig {params(type: T::Types::Base).returns(T.nilable(T::Types::Base))}
+    #
+    # checked(:never) - called potentially many times recursively
+    sig {params(type: T::Types::Base).returns(T.nilable(T::Types::Base)).checked(:never)}
     private def find_invalid_subtype(type)
       case type
       when T::Types::TypedEnumerable

data/lib/types/utils.rb

@@ -96,7 +96,7 @@ module T::Utils
   def self.unwrap_nilable(type)
     case type
     when T::Types::Union
-      non_nil_types = type.types.reject {|t| t == T::Utils.coerce(NilClass)}
+      non_nil_types = type.types.reject {|t| t == Nilable::NIL_TYPE}
       if non_nil_types.length == 1
         non_nil_types.first
       else
@@ -156,6 +156,8 @@ module T::Utils
     # :non_nilable_type, Class: if it is an T.nilable type, the corresponding underlying type; otherwise, nil.
     TypeInfo = Struct.new(:is_union_type, :non_nilable_type)
 
+    NIL_TYPE = T::Utils.coerce(NilClass)
+
     def self.get_type_info(prop_type)
       if prop_type.is_a?(T::Types::Union)
         non_nilable_type = T::Utils.unwrap_nilable(prop_type)
@@ -191,7 +193,7 @@ module T::Utils
     def self.is_union_with_nilclass(prop_type)
       case prop_type
       when T::Types::Union
-        prop_type.types.any? {|t| t == T::Utils.coerce(NilClass)}
+        prop_type.types.include?(NIL_TYPE)
       else
         false
       end

metadata

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