sorbet-runtime 0.5.12203 → 0.5.12366

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4981df02e19e06fc43c04a78123f5ca8f10ae72aaebedbd960844af87d6af230
-  data.tar.gz: 80d5d3fbcbd886a87149150d071638282901d2fbda0a57b4ef76aa2f1bf6fd78
+  metadata.gz: 621006dee0ec596b46c4eba003534e49eb71ccff6b0af7fa32efd16dc9ba436e
+  data.tar.gz: 6cc3bc9bbec95f0c9b34643c995be28939c355cf824c15e4da3888a48e7d9563
 SHA512:
-  metadata.gz: cdb124335891b42b064cae95a130f166b7c5d0d962f5d813f4c85d89c3b669fbd20cf9e18706671e019003291f1ba140d63b8a91c0500586c24cdb5d6869ce8a
-  data.tar.gz: e5429a56cd2c2a29331bb29bd2ab44bc3ad6b0581d2100130515c0b8efb11d26aedacb92e243d3e204913cb6585d72fd33a79a3ff66fec15f9365f40c8126f86
+  metadata.gz: f9f02e2b3b76d2adc6b872fc7aed55c2c0009233f66cd650062d57e2af4a50b56c9747c759de737eca620494da190884576d90c7fd652e6b3d1661acf759060a
+  data.tar.gz: d8aa60c7ee08f3cedda81996841fe5822a33ab2a9a37b3b4cb26957e36e246e7b5ea4f0c76b91f9b62b1e605ebb13312adc263fa0cebd3dee22580dca39f0a2c

data/lib/types/private/methods/_methods.rb

@@ -545,15 +545,15 @@ module T::Private::Methods
 
   module MethodHooks
     def method_added(name)
-      super(name)
       ::T::Private::Methods._on_method_added(self, self, name)
+      super(name)
     end
   end
 
   module SingletonMethodHooks
     def singleton_method_added(name)
-      super(name)
       ::T::Private::Methods._on_method_added(self, singleton_class, name)
+      super(name)
     end
   end
 
@@ -589,6 +589,22 @@ module T::Private::Methods
     mod.extend(SingletonMethodHooks)
   end
 
+  # `name` must be an instance method (for class methods, pass in mod.singleton_class)
+  def self.visibility_method_name(mod, name)
+    if mod.public_method_defined?(name)
+      :public
+    elsif mod.protected_method_defined?(name)
+      :protected
+    elsif mod.private_method_defined?(name)
+      :private
+    else
+      # Raises a NameError formatted like the Ruby VM would (the exact text formatting
+      # of these errors changed across Ruby VM versions, in ways that would sometimes
+      # cause tests to fail if they were dependent on hard coding errors).
+      mod.method(name)
+    end
+  end
+
   # use this directly if you don't want/need to box up the method into an object to pass to method_to_key.
   private_class_method def self.method_owner_and_name_to_key(owner, name)
     "#{owner.object_id}##{name}"

data/lib/types/private/methods/call_validation.rb

@@ -12,7 +12,7 @@ module T::Private::Methods::CallValidation
   # @param method_sig [T::Private::Methods::Signature]
   # @return [UnboundMethod] the new wrapper method (or the original one if we didn't wrap it)
   def self.wrap_method_if_needed(mod, method_sig, original_method)
-    original_visibility = visibility_method_name(mod, method_sig.method_name)
+    original_visibility = T::Private::Methods.visibility_method_name(mod, method_sig.method_name)
     if method_sig.mode == T::Private::Methods::Modes.abstract
       create_abstract_wrapper(mod, method_sig, original_method, original_visibility)
     # Do nothing in this case; this method was not wrapped in _on_method_added.
@@ -330,19 +330,6 @@ module T::Private::Methods::CallValidation
       location: caller_loc
     )
   end
-
-  # `name` must be an instance method (for class methods, pass in mod.singleton_class)
-  private_class_method def self.visibility_method_name(mod, name)
-    if mod.public_method_defined?(name)
-      :public
-    elsif mod.protected_method_defined?(name)
-      :protected
-    elsif mod.private_method_defined?(name)
-      :private
-    else
-      mod.method(name) # Raises
-    end
-  end
 end
 
 if T::Configuration::AT_LEAST_RUBY_2_7

data/lib/types/private/methods/signature_validation.rb

@@ -89,6 +89,7 @@ module T::Private::Methods::SignatureValidation
         validate_override_mode(signature, super_signature)
         validate_override_shape(signature, super_signature)
         validate_override_types(signature, super_signature)
+        validate_override_visibility(signature, super_signature)
       end
     else
       validate_non_override_mode(signature)
@@ -276,6 +277,38 @@ module T::Private::Methods::SignatureValidation
     end
   end
 
+  def self.validate_override_visibility(signature, super_signature)
+    return if super_signature.mode == Modes.untyped
+    # This departs from the behavior of other `validate_override_whatever` functions in that it
+    # only comes into effect when the child signature explicitly says the word `override`. This was
+    # done because the primary method for silencing these errors (`allow_incompatible: :visibility`)
+    # requires an `override` node to attach to. Once we have static override checking for implicitly
+    # overridden methods, we can remove this.
+    return unless [Modes.override, Modes.overridable_override].include?(signature.mode)
+    return if [:visibility, true].include?(signature.override_allow_incompatible)
+    method = signature.method
+    super_method = super_signature.method
+    mode_noun = super_signature.mode == Modes.abstract ? 'implementation' : 'override'
+    vis = method_visibility(method)
+    super_vis = method_visibility(super_method)
+
+    if visibility_strength(vis) > visibility_strength(super_vis)
+      raise "Incompatible visibility for #{mode_noun} of method #{method.name}\n" \
+            "* Base: #{super_vis} (in #{method_loc_str(super_method)})\n" \
+            "* #{mode_noun.capitalize}: #{vis} (in #{method_loc_str(method)})\n" \
+            "(The override must be at least as permissive as the supermethod)" \
+    end
+  end
+
+  private_class_method def self.method_visibility(method)
+    T::Private::Methods.visibility_method_name(method.owner, method.name)
+  end
+
+  # Higher = more restrictive.
+  private_class_method def self.visibility_strength(vis)
+    %i[public protected private].find_index(vis)
+  end
+
   private_class_method def self.base_override_loc_str(signature, super_signature)
     mode_noun = super_signature.mode == Modes.abstract ? 'Implementation' : 'Override'
     "\n * Base definition: in #{method_loc_str(super_signature.method)}" \

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.12203
+  version: 0.5.12366
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-06-26 00:00:00.000000000 Z
+date: 2025-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest