sorbet-runtime 0.5.12225 → 0.5.12349

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c3aed74436b6f44fed009be1812a819efa86d7efb4f57a47aa3d195ab57f2208
-  data.tar.gz: 57820a54f94052a51b8d44c4d25fca0ff49cf08dacc2cff8d38afc45806fe59a
+  metadata.gz: ed0be05b2dc1a36d22edcee3cf009bf56a33694e889ba41793966f6128853738
+  data.tar.gz: 906069610c18e58a01945eb7c605fe1dcc6089d8a6a20955557c8dd6cf491528
 SHA512:
-  metadata.gz: e851aa9cc3d1d650c5c8c40ddb8b9e02d7185e165b2a4c719b52da858ee2628969b8188344cbd47061c5d7ad5f61624f045220e4151d1f77ba1e56e1463db841
-  data.tar.gz: e7ffdbd9acd7b2dd6ad927d31c442769b57885989a39c8b33bc13fad179150810a43ff32d80d1074a8c8f2f112ab49a7d7bd7b03d1475ff1685936f522b6519e
+  metadata.gz: e8d6655a0e3502befabc74bb1e4ee6d55a8d8b5d7a1eccc6593ba3070cd2d45e14958239f5dba645451fed4f1bb73300e2868f90da983a8223f14f84bfad382f
+  data.tar.gz: 1f815a6904f8ee420f72a400cdd895df9d5b456cbaaf0f919318e84fd0b50e3ce37618fbf0b9b3aa6e069757e7fc3e8db04c17e538fb164e1abfbb4be503f3ab

data/lib/types/props/decorator.rb

@@ -14,12 +14,28 @@ class T::Props::Decorator
   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) }
+  OverrideRules = T.type_alias { T::Hash[Symbol, {allow_incompatible: T::Boolean}] }
 
   class NoRulesError < StandardError; end
 
   EMPTY_PROPS = T.let({}.freeze, T::Hash[Symbol, Rules], checked: false)
   private_constant :EMPTY_PROPS
 
+  OVERRIDE_TRUE = T.let({
+    reader: {allow_incompatible: false}.freeze,
+    writer: {allow_incompatible: false}.freeze,
+  }.freeze, OverrideRules)
+
+  OVERRIDE_READER = T.let({
+    reader: {allow_incompatible: false}.freeze,
+  }.freeze, OverrideRules)
+
+  OVERRIDE_WRITER = T.let({
+    writer: {allow_incompatible: false}.freeze,
+  }.freeze, OverrideRules)
+
+  OVERRIDE_EMPTY = T.let({}.freeze, OverrideRules)
+
   sig { params(klass: T.untyped).void.checked(:never) }
   def initialize(klass)
     @class = T.let(klass, T.all(Module, T::Props::ClassMethods))
@@ -45,17 +61,15 @@ class T::Props::Decorator
   end
 
   # checked(:never) - Rules hash is expensive to check
-  sig { params(prop: Symbol, rules: Rules).void.checked(:never) }
-  def add_prop_definition(prop, rules)
+  sig { params(name: Symbol, rules: Rules).void.checked(:never) }
+  def add_prop_definition(name, rules)
     override = rules.delete(:override)
 
-    if props.include?(prop) && !override
-      raise ArgumentError.new("Attempted to redefine prop #{prop.inspect} on class #{@class} that's already defined without specifying :override => true: #{prop_rules(prop)}")
-    elsif !props.include?(prop) && override
-      raise ArgumentError.new("Attempted to override a prop #{prop.inspect} on class #{@class} that doesn't already exist")
+    if props.include?(name) && !override
+      raise ArgumentError.new("Attempted to redefine prop #{name.inspect} on class #{@class} that's already defined without specifying :override => true: #{prop_rules(name)}")
     end
 
-    @props = @props.merge(prop => rules.freeze).freeze
+    @props = @props.merge(name => rules.freeze).freeze
   end
 
   # Heads up!
@@ -302,6 +316,27 @@ class T::Props::Decorator
     T::Utils::Nilable.is_union_with_nilclass(cls) || ((cls == T.untyped || cls == NilClass) && rules.key?(:default) && rules[:default].nil?)
   end
 
+  sig(:final) { params(name: Symbol).returns(T::Boolean).checked(:never) }
+  private def method_defined_on_ancestor?(name)
+    @class.method_defined?(name) && !@class.method_defined?(name, false)
+  end
+
+  sig(:final) { params(name: Symbol, rules: Rules).void.checked(:never) }
+  private def validate_overrides(name, rules)
+    override = elaborate_override(name, rules[:override])
+
+    return if rules[:without_accessors]
+
+    if override[:reader] && !method_defined_on_ancestor?(name) && !props.include?(name)
+      raise ArgumentError.new("You marked the getter for prop #{name.inspect} as `override`, but the method `#{name}` doesn't exist to be overridden.")
+    end
+
+    # Properly, we should also check whether `props[name]` is immutable, but the old code didn't either.
+    if !rules[:immutable] && override[:writer] && !method_defined_on_ancestor?("#{name}=".to_sym) && !props.include?(name)
+      raise ArgumentError.new("You marked the setter for prop #{name.inspect} as `override`, but the method `#{name}=` doesn't exist to be overridden.")
+    end
+  end
+
   # checked(:never) - Rules hash is expensive to check
   sig do
     params(
@@ -381,6 +416,7 @@ class T::Props::Decorator
     rules[:setter_proc] = setter_proc
     rules[:value_validate_proc] = value_validate_proc
 
+    validate_overrides(name, rules)
     add_prop_definition(name, rules)
 
     # NB: using `without_accessors` doesn't make much sense unless you also define some other way to
@@ -405,6 +441,7 @@ class T::Props::Decorator
           # 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)
@@ -627,7 +664,7 @@ class T::Props::Decorator
 
     props.each do |name, rules|
       copied_rules = rules.dup
-      # NB: Calling `child.decorator` here is a timb bomb that's going to give someone a really bad
+      # NB: Calling `child.decorator` here is a time bomb that's going to give someone a really bad
       # 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)
@@ -656,6 +693,52 @@ class T::Props::Decorator
     end
   end
 
+  sig(:final) do
+    params(key: Symbol, d: T.untyped, out: T::Hash[Symbol, {allow_incompatible: T::Boolean}])
+      .void
+      .checked(:never)
+  end
+  private def elaborate_override_entry(key, d, out)
+    # It's written this way so that `{reader: false}` will omit the entry for `reader` in the
+    # result entirely
+    case d[key]
+    when TrueClass
+      out[key] = {allow_incompatible: false}
+    when Hash
+      out[key] = {allow_incompatible: !!d[key][:allow_incompatible]}
+    end
+  end
+
+  sig(:final) do
+    params(name: Symbol, d: T.untyped)
+      .returns(T::Hash[Symbol, {allow_incompatible: T::Boolean}])
+      .checked(:never)
+  end
+  private def elaborate_override(name, d)
+    return OVERRIDE_TRUE if d == true
+    return OVERRIDE_READER if d == :reader
+    return OVERRIDE_WRITER if d == :writer
+    return OVERRIDE_EMPTY if d == false || d.nil?
+    unless d.is_a?(Hash)
+      raise ArgumentError.new("`override` only accepts `true`, `:reader`, `:writer`, or a Hash in prop #{@class.name}.#{name} (got #{d.class})")
+    end
+
+    # cwong: should we check for bad keys? `sig { override(not_real: true) }` on a normal function
+    # errors statically but not at runtime.
+
+    # XX cwong: this means {reader: false, allow_incompatible: true} will become {allow_incompatible: true},
+    # is that fine?
+    unless (allow_incompatible = d[:allow_incompatible]).nil?
+      return {reader: {allow_incompatible: !!allow_incompatible},
+              writer: {allow_incompatible: !!allow_incompatible}}.to_h
+    end
+
+    result = {}
+    elaborate_override_entry(:reader, d, result)
+    elaborate_override_entry(:writer, d, result)
+    result
+  end
+
   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 &&

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.5.12225
+  version: 0.5.12349
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-07-16 00:00:00.000000000 Z
+date: 2025-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest