sorbet-runtime 0.4.4667 → 0.5.6189

data/lib/types/private/types/type_alias.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Private::Types
+  # Wraps a proc for a type alias to defer its evaluation.
+  class TypeAlias < T::Types::Base
+
+    def initialize(callable)
+      @callable = callable
+    end
+
+    def aliased_type
+      @aliased_type ||= T::Utils.coerce(@callable.call)
+    end
+
+    # @override Base
+    def name
+      aliased_type.name
+    end
+
+    # @override Base
+    def recursively_valid?(obj)
+      aliased_type.recursively_valid?(obj)
+    end
+
+    # @override Base
+    def valid?(obj)
+      aliased_type.valid?(obj)
+    end
+  end
+end

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/profile.rb

@@ -10,7 +10,11 @@ module T::Profile
     def typecheck_duration_estimate
       total_typechecks = typecheck_samples * SAMPLE_RATE + (SAMPLE_RATE - typecheck_sample_attempts)
       typechecks_measured = typecheck_samples * SAMPLE_RATE
-      typecheck_duration * SAMPLE_RATE * 1.0 * total_typechecks / typechecks_measured
+      if typechecks_measured.positive?
+        typecheck_duration * SAMPLE_RATE * 1.0 * total_typechecks / typechecks_measured
+      else
+        0.0
+      end
     end
 
     def typecheck_count_estimate

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.
@@ -39,7 +39,7 @@ module T::Props
     # a document class.
     #
     # @param name [Symbol] The name of this property
-    # @param cls [Class,T::Props::CustomType] (String) The type of this
+    # @param cls [Class,T::Types::Base] The type of this
     #   property. If the type is itself a {Document} subclass, this
     #   property will be recursively serialized/deserialized.
     # @param rules [Hash] Options to control this property's behavior.
@@ -90,10 +90,6 @@ module T::Props
     #   none is provided.
     # @option rules [T::Boolean] :immutable If true, this prop cannot be
     #   modified after an instance is created or loaded from a hash.
-    # @option rules [Class,T::Props::CustomType] :array If set, specifies the
-    #   type of individual members of a prop with `type` `Array`. This
-    #   allows for typechecking of arrays, and also for recursive
-    #   serialization of arrays of sub-{Document}s.
     # @option rules [T::Boolean] :override It is an error to redeclare a
     #   `prop` that has already been declared (including on a
     #   superclass), unless `:override` is set to `true`.
@@ -131,7 +127,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/constructor.rb

@@ -3,18 +3,38 @@
 
 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)
+    # Use `each_pair` rather than `count` because, as of Ruby 2.6, the latter delegates to Enumerator
+    # and therefore allocates for each entry.
+    result = 0
+    @props_without_defaults&.each_pair do |p, setter_proc|
+      begin
+        val = hash[p]
+        instance.instance_exec(val, &setter_proc)
+        if val || hash.key?(p)
+          result += 1
+        end
+      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
+    result
   end
 end

data/lib/types/props/custom_type.rb

@@ -1,20 +1,35 @@
 # frozen_string_literal: true
-# typed: false
+# typed: strict
 
 module T::Props
   module CustomType
+    extend T::Sig
+    extend T::Helpers
+
+    abstract!
+
     include Kernel # for `is_a?`
 
-    # Returns true if the given Ruby value can be assigned to a T::Props field
-    # of this type.
-    #
-    # @param [Object] _value
-    # @return T::Boolean
-    def instance?(_value)
-      raise NotImplementedError.new('Must override in included class')
+    # Alias for backwards compatibility
+    sig(:final) do
+      params(
+        value: BasicObject,
+      )
+      .returns(T::Boolean)
+      .checked(:never)
+    end
+    def instance?(value)
+      self.===(value)
     end
 
-    # Alias for consistent interface with T::Types::Base
+    # Alias for backwards compatibility
+    sig(:final) do
+      params(
+        value: BasicObject,
+      )
+      .returns(T::Boolean)
+      .checked(:never)
+    end
     def valid?(value)
       instance?(value)
     end
@@ -24,30 +39,30 @@ module T::Props
     #
     # @param [Object] _instance
     # @return An instance of one of T::Configuration.scalar_types
-    def serialize(_instance)
-      raise NotImplementedError.new('Must override in included class')
-    end
+    sig {abstract.params(instance: T.untyped).returns(T.untyped).checked(:never)}
+    def serialize(instance); end
 
     # Given the serialized form of your type, this returns an instance
     # of that custom type representing that value.
     #
-    # @param _mongo_scalar One of T::Configuration.scalar_types
+    # @param scalar One of T::Configuration.scalar_types
     # @return Object
-    def deserialize(_mongo_scalar)
-      raise NotImplementedError.new('Must override in included class')
-    end
+    sig {abstract.params(scalar: T.untyped).returns(T.untyped).checked(:never)}
+    def deserialize(scalar); end
 
+    sig {override.params(_base: Module).void}
     def self.included(_base)
       super
 
       raise 'Please use "extend", not "include" to attach this module'
     end
 
+    sig(:final) {params(val: Object).returns(T::Boolean).checked(:never)}
     def self.scalar_type?(val)
       # We don't need to check for val's included modules in
       # T::Configuration.scalar_types, because T::Configuration.scalar_types
       # are all classes.
-      klass = val.class
+      klass = T.let(val.class, T.nilable(Class))
       until klass.nil?
         return true if T::Configuration.scalar_types.include?(klass.to_s)
         klass = klass.superclass
@@ -59,16 +74,8 @@ module T::Props
     # implement set-like fields that store a unique-array, but forbid
     # hashes; Custom hash types should be implemented via an emebdded
     # T::Struct (or a subclass like Chalk::ODM::Document) or via T.
-    def self.valid_serialization?(val, type=nil)
-      if type&.name == 'Chalk::ODM::BsonTypes::BsonObject'
-        # Special case we allow for backwards compatibility with props formerly
-        # typed as "Object" or "Hash", which contain arbitrarily-nested BSON
-        # data (e.g. parsed API request bodies). In general, we aren't pushing
-        # to convert these to Chalk::ODM::BsonTypes - we'd rather delurk them -
-        # but this lets us convert events with these types to Proto.
-        return true
-      end
-
+    sig(:final) {params(val: Object).returns(T::Boolean).checked(:never)}
+    def self.valid_serialization?(val)
       case val
       when Array
         val.each do |v|
@@ -80,5 +87,22 @@ module T::Props
         scalar_type?(val)
       end
     end
+
+    sig(:final) do
+      params(instance: Object)
+      .returns(T.untyped)
+      .checked(:never)
+    end
+    def self.checked_serialize(instance)
+      val = T.cast(instance.class, T::Props::CustomType).serialize(instance)
+      unless valid_serialization?(val)
+        msg = "#{instance.class} did not serialize to a valid scalar type. It became a: #{val.class}"
+        if val.is_a?(Hash)
+          msg += "\nIf you want to store a structured Hash, consider using a T::Struct as your type."
+        end
+        raise TypeError.new(msg)
+      end
+      val
+    end
   end
 end

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
@@ -10,46 +10,39 @@
 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
-  PropType = T.type_alias(T.any(T::Types::Base, T::Props::CustomType))
-  PropTypeOrClass = T.type_alias(T.any(PropType, Module))
+  Rules = T.type_alias {T::Hash[Symbol, T.untyped]}
+  DecoratedInstance = T.type_alias {Object} # Would be T::Props, but that produces circular reference errors in some circumstances
+  PropType = T.type_alias {T::Types::Base}
+  PropTypeOrClass = T.type_alias {T.any(PropType, Module)}
 
   class NoRulesError < StandardError; end
 
-  T::Sig::WithoutRuntime.sig {params(klass: DecoratedClass).void}
+  EMPTY_PROPS = T.let({}.freeze, T::Hash[Symbol, Rules])
+  private_constant :EMPTY_PROPS
+
+  sig {params(klass: T.untyped).void.checked(:never)}
   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
 
-  # prop stuff
+  # checked(:never) - O(prop accesses)
   sig {returns(T::Hash[Symbol, Rules]).checked(:never)}
-  def props
-    @props ||= {}.freeze
-  end
-
-  # Try to avoid using this; post-definition mutation of prop rules is
-  # surprising and hard to reason about.
-  sig {params(prop: Symbol, key: Symbol, value: T.untyped).void}
-  def mutate_prop_backdoor!(prop, key, value)
-    @props = props.merge(
-      prop => props.fetch(prop).merge(key => value).freeze
-    ).freeze
-  end
+  attr_reader :props
 
   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,178 +54,147 @@ class T::Props::Decorator
     @props = @props.merge(prop => rules.freeze).freeze
   end
 
-  sig {returns(T::Array[Symbol])}
-  def valid_props
-    %i{
-      enum
-      foreign
-      foreign_hint_only
-      ifunset
-      immutable
-      override
-      redaction
-      sensitivity
-      without_accessors
-      clobber_existing_method!
-      extra
-      optional
-      _tnilable
-    }
-  end
-
-  sig {returns(DecoratedClass).checked(:never)}
+  VALID_RULE_KEYS = T.let(%i[
+    enum
+    foreign
+    foreign_hint_only
+    ifunset
+    immutable
+    override
+    redaction
+    sensitivity
+    without_accessors
+    clobber_existing_method!
+    extra
+    setter_validate
+    _tnilable
+  ].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]
+  end
+
+  # checked(:never) - O(prop accesses)
+  sig {returns(T.all(Module, T::Props::ClassMethods)).checked(:never)}
   def decorated_class; @class; end
 
   # Accessors
 
+  # 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)
+    # 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.
   # Passing in rules here is purely a performance optimization.
+  # 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).
+  #
+  # 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: T.any(String, Symbol),
-      rules: T.nilable(Rules)
+      prop: Symbol,
+      val: T.untyped,
+      rules: Rules
     )
-    .returns(T.untyped)
+    .void
     .checked(:never)
   end
-  def get(instance, prop, 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_get(rules ? rules[:accessor_key] : '@' + prop.to_s) # rubocop:disable PrisonGuard/NoLurkyInstanceVariableAccess
+  def prop_set(instance, prop, val, rules=prop_rules(prop))
+    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.
+  # Only Models have any custom get logic but we need to call this on
+  # non-Models since we don't know at code gen time what we have.
   sig do
     params(
       instance: DecoratedInstance,
       prop: Symbol,
-      value: T.untyped,
-      rules: T.nilable(Rules)
+      value: T.untyped
     )
-    .void
+    .returns(T.untyped)
     .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.
-  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.
-  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
+  def prop_get_logic(instance, prop, value)
+    value
   end
 
   # For performance, don't use named params here.
   # Passing in rules here is purely a performance optimization.
-  # 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).
+  #
+  # 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,
-      prop: Symbol,
-      val: T.untyped,
-      rules: T.nilable(Rules)
+      prop: T.any(String, Symbol),
+      rules: Rules
     )
-    .void
+    .returns(T.untyped)
     .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)
+  def prop_get(instance, prop, rules=prop_rules(prop))
+    val = instance.instance_variable_get(rules[:accessor_key])
+    if !val.nil?
+      val
+    elsif (d = rules[:ifunset])
+      T::Props::Utils.deep_clone_object(d)
+    else
+      nil
+    end
   end
 
-  # For performance, don't use named params here.
-  # Passing in rules here is purely a performance optimization.
   sig do
     params(
       instance: DecoratedInstance,
       prop: T.any(String, Symbol),
-      rules: T.nilable(Rules)
+      rules: Rules
     )
     .returns(T.untyped)
     .checked(:never)
   end
-  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
-      val
-    else
-      raise NoRulesError.new if !rules
-      d = rules[:ifunset]
-      if d
-        T::Props::Utils.deep_clone_object(d)
-      else
-        nil
-      end
-    end
+  def prop_get_if_set(instance, prop, rules=prop_rules(prop))
+    instance.instance_variable_get(rules[:accessor_key])
   end
+  alias_method :get, :prop_get_if_set # Alias for backwards compatibility
 
+  # checked(:never) - O(prop accesses)
   sig do
     params(
       instance: DecoratedInstance,
       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={})
+  def foreign_prop_get(instance, prop, foreign_class, rules=prop_rules(prop), 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 = T.let(Object.instance_methods.to_set.freeze, T::Set[Symbol])
+
+  # checked(:never) - Rules hash is expensive to check
   sig do
     params(
       name: Symbol,
@@ -241,6 +203,7 @@ class T::Props::Decorator
       type: PropTypeOrClass
     )
     .void
+    .checked(:never)
   end
   def prop_validate_definition!(name, cls, rules, type)
     validate_prop_name(name)
@@ -250,26 +213,17 @@ 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
 
-    if (array = rules[:array])
-      unless array.is_a?(Module)
-        raise ArgumentError.new("Bad class as subtype in prop #{@class.name}.#{name}: #{array.inspect}")
-      end
-    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)
-        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} " \
-          "at #{@class.instance_method(name).source_location || '<unknown>'}). " \
-          "(If using this name is unavoidable, try `without_accessors: true`.)"
-        )
-      end
+    if !rules[:clobber_existing_method!] && !rules[:without_accessors] && 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} " \
+        "at #{@class.instance_method(name).source_location || '<unknown>'}). " \
+        "(If using this name is unavoidable, try `without_accessors: true`.)"
+      )
     end
 
     extra = rules[:extra]
@@ -280,19 +234,16 @@ class T::Props::Decorator
     nil
   end
 
+  SAFE_NAME = T.let(/\A[A-Za-z_][A-Za-z0-9_-]*\z/.freeze, Regexp)
+
+  # Used to validate both prop names and serialized forms
+  sig {params(name: T.any(Symbol, String)).void}
   private def validate_prop_name(name)
-    if name !~ /\A[A-Za-z_][A-Za-z0-9_-]*\z/
+    if !name.match?(SAFE_NAME)
       raise ArgumentError.new("Invalid prop name in #{@class.name}: #{name}")
     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)
@@ -321,6 +272,7 @@ class T::Props::Decorator
     end
   end
 
+  # checked(:never) - Rules hash is expensive to check
   sig do
     params(
       name: T.any(Symbol, String),
@@ -328,49 +280,10 @@ class T::Props::Decorator
       rules: Rules,
     )
     .void
+    .checked(:never)
   end
   def prop_defined(name, cls, rules={})
-    if rules[:optional] == true
-      T::Configuration.hard_assert_handler(
-        'Use of `optional: true` is deprecated, please use `T.nilable(...)` instead.',
-        storytime: {
-          name: name,
-          cls_or_args: cls.to_s,
-          args: rules,
-          klass: decorated_class.name,
-        },
-      )
-    elsif rules[:optional] == false
-      T::Configuration.hard_assert_handler(
-        'Use of `optional: :false` is deprecated as it\'s the default value.',
-        storytime: {
-          name: name,
-          cls_or_args: cls.to_s,
-          args: rules,
-          klass: decorated_class.name,
-        },
-      )
-    elsif rules[:optional] == :on_load
-      T::Configuration.hard_assert_handler(
-        'Use of `optional: :on_load` is deprecated. You probably want `T.nilable(...)` with :raise_on_nil_write instead.',
-        storytime: {
-          name: name,
-          cls_or_args: cls.to_s,
-          args: rules,
-          klass: decorated_class.name,
-        },
-      )
-    elsif rules[:optional] == :existing
-      T::Configuration.hard_assert_handler(
-        'Use of `optional: :existing` is not allowed: you should use use T.nilable (http://go/optional)',
-        storytime: {
-          name: name,
-          cls_or_args: cls.to_s,
-          args: rules,
-          klass: decorated_class.name,
-        },
-      )
-    end
+    cls = T::Utils.resolve_alias(cls)
 
     if T::Utils::Nilable.is_union_with_nilclass(cls)
       # :_tnilable is introduced internally for performance purpose so that clients do not need to call
@@ -385,59 +298,34 @@ class T::Props::Decorator
     if !cls.is_a?(Module)
       cls = convert_type_to_class(cls)
     end
-    type_object = type
-    if !(type_object.singleton_class < T::Props::CustomType)
-      type_object = smart_coerce(type_object, array: rules[:array], enum: rules[:enum])
-    end
+    type_object = smart_coerce(type, enum: rules[:enum])
 
     prop_validate_definition!(name, cls, rules, type_object)
 
     # Retrive the possible underlying object with T.nilable.
-    underlying_type_object = T::Utils::Nilable.get_underlying_type_object(type_object)
     type = T::Utils::Nilable.get_underlying_type(type)
 
-    array_subdoc_type = array_subdoc_type(underlying_type_object)
-    hash_value_subdoc_type = hash_value_subdoc_type(underlying_type_object)
-    hash_key_custom_type = hash_key_custom_type(underlying_type_object)
-
     sensitivity_and_pii = {sensitivity: rules[:sensitivity]}
     if defined?(Opus) && defined?(Opus::Sensitivity) && defined?(Opus::Sensitivity::Utils)
       sensitivity_and_pii = Opus::Sensitivity::Utils.normalize_sensitivity_and_pii_annotation(sensitivity_and_pii)
-    end
-    # We check for Class so this is only applied on concrete
-    # documents/models; We allow mixins containing props to not
-    # specify their PII nature, as long as every class into which they
-    # 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?
+
+      # We check for Class so this is only applied on concrete
+      # documents/models; We allow mixins containing props to not
+      # specify their PII nature, as long as every class into which they
+      # are ultimately included does.
+      #
+      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`'
         )
       end
     end
 
-    needs_clone =
-      if cls <= Array || cls <= Hash || cls <= Set
-        shallow_clone_ok(underlying_type_object) ? :shallow : true
-      else
-        false
-      end
-
     rules = rules.merge(
       # TODO: The type of this element is confusing. We should refactor so that
       # it can be always `type_object` (a PropType) or always `cls` (a Module)
       type: type,
-      # These are precomputed for performance
-      # TODO: A lot of these are only needed by T::Props::Serializable or T::Struct
-      # and can/should be moved accordingly.
-      type_is_custom_type: cls.singleton_class < T::Props::CustomType,
-      type_is_serializable: cls < T::Props::Serializable,
-      type_is_array_of_serializable: !array_subdoc_type.nil?,
-      type_is_hash_of_serializable_values: !hash_value_subdoc_type.nil?,
-      type_is_hash_of_custom_type_keys: !hash_key_custom_type.nil?,
       type_object: type_object,
-      type_needs_clone: needs_clone,
       accessor_key: "@#{name}".to_sym,
       sensitivity: sensitivity_and_pii[:sensitivity],
       pii: sensitivity_and_pii[:pii],
@@ -447,29 +335,19 @@ class T::Props::Decorator
 
     validate_not_missing_sensitivity(name, rules)
 
-    # for backcompat
-    if type.is_a?(T::Types::TypedArray) && type.type.is_a?(T::Types::Simple)
-      rules[:array] = type.type.raw_type
-    elsif array_subdoc_type
-      rules[:array] = array_subdoc_type
+    # for backcompat (the `:array` key is deprecated but because the name is
+    # so generic it's really hard to be sure it's not being relied on anymore)
+    if type.is_a?(T::Types::TypedArray)
+      inner = T::Utils::Nilable.get_underlying_type(type.type)
+      if inner.is_a?(Module)
+        rules[:array] = inner
+      end
     end
 
-    if rules[:type_is_serializable]
-      rules[:serializable_subtype] = cls
-    elsif array_subdoc_type
-      rules[:serializable_subtype] = array_subdoc_type
-    elsif hash_value_subdoc_type && hash_key_custom_type
-      rules[:serializable_subtype] = {
-        keys: hash_key_custom_type,
-        values: hash_value_subdoc_type,
-      }
-    elsif hash_value_subdoc_type
-      rules[:serializable_subtype] = hash_value_subdoc_type
-    elsif hash_key_custom_type
-      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]
@@ -479,130 +357,57 @@ class T::Props::Decorator
     end
 
     handle_foreign_option(name, cls, rules, rules[:foreign]) if rules[:foreign]
-    handle_foreign_hint_only_option(cls, rules[:foreign_hint_only]) if rules[:foreign_hint_only]
+    handle_foreign_hint_only_option(name, cls, rules[:foreign_hint_only]) if rules[:foreign_hint_only]
     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]
-        @class.send(:define_method, "#{name}=") do |_x|
-          raise T::Props::ImmutableProp.new("#{self.class}##{name} cannot be modified after creation.")
-        end
-      else
-        @class.send(:define_method, "#{name}=") do |x|
-          self.class.decorator.prop_set(self, name, x, rules)
+      if !rules[:immutable]
+        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
 
-      @class.send(:define_method, name) do
-        self.class.decorator.prop_get(self, name, rules)
-      end
-    end
-  end
-
-  # returns the subdoc of the array type, or nil if it's not a Document type
-  sig do
-    params(type: PropType)
-    .returns(T.nilable(Module))
-  end
-  private def array_subdoc_type(type)
-    if type.is_a?(T::Types::TypedArray)
-      el_type = T::Utils.unwrap_nilable(type.type) || type.type
-
-      if el_type.is_a?(T::Types::Simple) &&
-          (el_type.raw_type < T::Props::Serializable || el_type.raw_type.is_a?(T::Props::CustomType))
-        return el_type.raw_type
-      end
-    end
-
-    nil
-  end
-
-  # returns the subdoc of the hash value type, or nil if it's not a Document type
-  sig do
-    params(type: PropType)
-    .returns(T.nilable(Module))
-  end
-  private def hash_value_subdoc_type(type)
-    if type.is_a?(T::Types::TypedHash)
-      values_type = T::Utils.unwrap_nilable(type.values) || type.values
-
-      if values_type.is_a?(T::Types::Simple) &&
-          (values_type.raw_type < T::Props::Serializable || values_type.raw_type.is_a?(T::Props::CustomType))
-        return values_type.raw_type
-      end
-    end
-
-    nil
-  end
-
-  # returns the type of the hash key, or nil. Any CustomType could be a key, but we only expect Opus::Enum right now.
-  sig do
-    params(type: PropType)
-    .returns(T.nilable(Module))
-  end
-  private def hash_key_custom_type(type)
-    if type.is_a?(T::Types::TypedHash)
-      keys_type = T::Utils.unwrap_nilable(type.keys) || type.keys
-
-      if keys_type.is_a?(T::Types::Simple) && keys_type.raw_type.is_a?(T::Props::CustomType)
-        return keys_type.raw_type
-      end
-    end
-
-    nil
-  end
-
-  # From T::Props::Utils.deep_clone_object, plus String
-  TYPES_NOT_NEEDING_CLONE = [TrueClass, FalseClass, NilClass, Symbol, String, Numeric]
-  if defined?(Opus) && defined?(Opus::Enum)
-    TYPES_NOT_NEEDING_CLONE << Opus::Enum
-  end
-
-  sig {params(type: PropType).returns(T::Boolean)}
-  private def shallow_clone_ok(type)
-    inner_type =
-      if type.is_a?(T::Types::TypedArray)
-        type.type
-      elsif type.is_a?(T::Types::TypedSet)
-        type.type
-      elsif type.is_a?(T::Types::TypedHash)
-        type.values
+      if method(:prop_get).owner != T::Props::Decorator || rules.key?(:ifunset)
+        @class.send(:define_method, name) do
+          T.unsafe(self.class).decorator.prop_get(self, name, rules)
+        end
+      else
+        # Fast path (~30x faster as of Ruby 2.6)
+        @class.send(:attr_reader, name) # send is used because `attr_reader` is private in 2.4
       end
-
-    inner_type.is_a?(T::Types::Simple) && TYPES_NOT_NEEDING_CLONE.any? do |cls|
-      inner_type.raw_type <= cls
     end
   end
 
   sig do
-    params(type: PropTypeOrClass, array: T.untyped, enum: T.untyped)
+    params(type: PropTypeOrClass, enum: T.untyped)
     .returns(T::Types::Base)
   end
-  private def smart_coerce(type, array:, enum:)
+  private def smart_coerce(type, enum:)
     # Backwards compatibility for pre-T::Types style
-    if !array.nil? && !enum.nil?
-      raise ArgumentError.new("Cannot specify both :array and :enum options")
-    elsif !array.nil?
-      if type == Set
-        T::Set[array]
-      else
-        T::Array[array]
-      end
-    elsif !enum.nil?
-      if T::Utils.unwrap_nilable(type)
-        T.nilable(T.enum(enum))
+    type = T::Utils.coerce(type)
+    if enum.nil?
+      type
+    else
+      nonnil_type = T::Utils.unwrap_nilable(type)
+      if nonnil_type
+        T.nilable(T.all(nonnil_type, T.enum(enum)))
       else
-        T.enum(enum)
+        T.all(type, T.enum(enum))
       end
-    else
-      T::Utils.coerce(type)
     end
   end
 
-  sig {params(prop_name: Symbol, rules: Hash).void}
+  # checked(:never) - Rules hash is expensive to check
+  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]
@@ -617,7 +422,7 @@ class T::Props::Decorator
       # TODO(PRIVACYENG-982) Ideally we'd also check for 'password' and possibly
       # other terms, but this interacts badly with ProtoDefinedDocument because
       # the proto syntax currently can't declare "sensitivity: []"
-      if prop_name =~ /\bsecret\b/
+      if /\bsecret\b/.match?(prop_name)
         T::Configuration.hard_assert_handler(
           "#{@class}##{prop_name} has the word 'secret' in its name, but no " \
           "'sensitivity:' annotation. This is probably wrong, because if a " \
@@ -634,7 +439,7 @@ class T::Props::Decorator
   sig do
     params(
       prop_name: Symbol,
-      redaction: Chalk::Tools::RedactionUtils::RedactionDirectiveSpec,
+      redaction: T.untyped,
     )
     .void
   end
@@ -671,13 +476,14 @@ class T::Props::Decorator
 
   sig do
     params(
+      prop_name: Symbol,
       prop_cls: Module,
       foreign_hint_only: T.untyped,
     )
     .void
   end
-  private def handle_foreign_hint_only_option(prop_cls, foreign_hint_only)
-    if ![String, Array].include?(prop_cls) && !(prop_cls.is_a?(T::Props::CustomType))
+  private def handle_foreign_hint_only_option(prop_name, prop_cls, foreign_hint_only)
+    if ![String, Array].include?(prop_cls) && !prop_cls.is_a?(T::Props::CustomType)
       raise ArgumentError.new(
         "`foreign_hint_only` can only be used with String or Array prop types"
       )
@@ -687,8 +493,24 @@ class T::Props::Decorator
       :foreign_hint_only, foreign_hint_only,
       valid_type_msg: "an individual or array of a model class, or a Proc returning such."
     )
+
+    unless foreign_hint_only.is_a?(Proc)
+      T::Configuration.soft_assert_handler(<<~MESSAGE, storytime: {prop: prop_name, value: foreign_hint_only}, notify: 'jerry')
+        Please use a Proc that returns a model class instead of the model class itself as the argument to `foreign_hint_only`. In other words:
+
+          instead of `prop :foo, String, foreign_hint_only: FooModel`
+          use `prop :foo, String, foreign_hint_only: -> {FooModel}`
+
+          OR
+
+          instead of `prop :foo, String, foreign_hint_only: [FooModel, BarModel]`
+          use `prop :foo, String, foreign_hint_only: -> {[FooModel, BarModel]}`
+
+      MESSAGE
+    end
   end
 
+  # checked(:never) - Rules hash is expensive to check
   sig do
     params(
       prop_name: T.any(String, Symbol),
@@ -696,6 +518,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}_"
@@ -705,6 +528,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)
@@ -717,13 +541,13 @@ class T::Props::Decorator
         # of the method, optimizing it so this only runs on the first invocation.
         foreign = resolved_foreign
       end
-      if allow_direct_mutation.nil?
-        opts = {}
+      opts = if allow_direct_mutation.nil?
+        {}
       else
-        opts = {allow_direct_mutation: allow_direct_mutation}
+        {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}!"
@@ -735,18 +559,11 @@ class T::Props::Decorator
           storytime: {method: force_fk_method, class: self.class}
         )
       end
-      T.must(loaded_foreign)
-    end
-
-    @class.send(:define_method, "#{prop_name}_record") do |allow_direct_mutation: nil|
-      T::Configuration.soft_assert_handler(
-        "Using deprecated 'model.#{prop_name}_record' foreign key syntax. You should replace this with 'model.#{prop_name}_'",
-        notify: 'vasi'
-      )
-      send(fk_method, allow_direct_mutation: allow_direct_mutation)
+      loaded_foreign
     end
   end
 
+  # checked(:never) - Rules hash is expensive to check
   sig do
     params(
       prop_name: Symbol,
@@ -755,6 +572,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(
@@ -775,6 +593,16 @@ class T::Props::Decorator
       )
     end
 
+    unless foreign.is_a?(Proc)
+      T::Configuration.soft_assert_handler(<<~MESSAGE, storytime: {prop: prop_name, value: foreign}, notify: 'jerry')
+        Please use a Proc that returns a model class instead of the model class itself as the argument to `foreign`. In other words:
+
+          instead of `prop :foo, String, foreign: FooModel`
+          use `prop :foo, String, foreign: -> {FooModel}`
+
+      MESSAGE
+    end
+
     define_foreign_method(prop_name, rules, foreign)
   end
 
@@ -782,16 +610,17 @@ 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: 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|
@@ -800,33 +629,47 @@ 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 clobber_getter?(child, name)
+          child.send(:define_method, name) do
+            T.unsafe(self.class).decorator.prop_get(self, name, rules)
+          end
+        end
+
+        if !rules[:immutable] && clobber_setter?(child, name)
+          child.send(:define_method, "#{name}=") do |val|
+            T.unsafe(self.class).decorator.prop_set(self, name, val, rules)
+          end
+        end
+      end
     end
   end
 
-  T::Sig::WithoutRuntime.sig {params(mod: Module).void}
+  sig {params(child: T.all(Module, T::Props::ClassMethods), prop: Symbol).returns(T::Boolean).checked(:never)}
+  private def clobber_getter?(child, prop)
+    !!(child.decorator.method(:prop_get).owner != method(:prop_get).owner &&
+       child.instance_method(prop).source_location&.first == __FILE__)
+  end
+
+  sig {params(child: T.all(Module, T::Props::ClassMethods), prop: Symbol).returns(T::Boolean).checked(:never)}
+  private def clobber_setter?(child, prop)
+    !!(child.decorator.method(:prop_set).owner != method(:prop_set).owner &&
+       child.instance_method("#{prop}=").source_location&.first == __FILE__)
+  end
+
+  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