sorbet-runtime 0.6.13188 → 0.6.13189

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee766380df193f2cc47403e32ea913cd5da012247fec0a6c19609b20ddf0667f
-  data.tar.gz: 6841b53a14b1e754321975d39782270accf9998c9a772bcd7a9fb3e5f01a11c2
+  metadata.gz: df6bf8fcb2561e2428429b30dc9059636064a8a735e253fe40f42345c634dc9a
+  data.tar.gz: 156e30c64f4ef4dad43b989ee8a462d458b8c282956de77a9f1f9e21ee2b08d8
 SHA512:
-  metadata.gz: 4cf62dfc5309a5d6c3568dd735aad71318e88b07ef06866ffb0f5193b9c398bd6137090734dda461d95282976b0ed13610ea0f9d2c05a72f0a05170e9bb11815
-  data.tar.gz: 8c14515625524567c0aba3f3004a35880004b3f2d9f4da072020f89373d605f0c4b464070e77276d3d56e1039fea1345cce78857de8a3788bf4bfb9b9b3d571a
+  metadata.gz: 85b4031fe378bad5cb9982bf02b9b4f52f888a02f3d5ef3442ef27c0343da8c9415bf443b798933807b59fb74519f8706965ac0a06a72f883ae15d6b29a5cdab
+  data.tar.gz: de199554534b1c28bbcfd69c7718bbd1b128190e7d91102eb93d24c257b4df186be56c7c617ad1fb08491ff18efa35dfc0494197a903367a14eff2bdb34e0a30

data/lib/types/private/class_utils.rb

@@ -3,61 +3,14 @@
 
 # Cut down version of Chalk::Tools::ClassUtils with only :replace_method functionality.
 # Extracted to a separate namespace so the type system can be used standalone.
+#
+# Note: the functionality to "restore" a method was removed, because it is no
+# longer being used by sorbet-runtime. Restoring a method requires care--if you
+# need to reintroduce this functionality, consult the git history for how to do
+# it safely.
 module T::Private::ClassUtils
-  class ReplacedMethod
-    def initialize(mod, old_method, new_method, overwritten, visibility)
-      if old_method.name != new_method.name
-        raise "Method names must match. old=#{old_method.name} new=#{new_method.name}"
-      end
-      @mod = mod
-      @old_method = old_method
-      @new_method = new_method
-      @overwritten = overwritten
-      @name = old_method.name
-      @visibility = visibility
-      @restored = false
-    end
-
-    def restore
-      # The check below would also catch this, but this makes the failure mode much clearer
-      if @restored
-        raise "Method '#{@name}' on '#{@mod}' was already restored"
-      end
-
-      if @mod.instance_method(@name) != @new_method
-        raise "Trying to restore #{@mod}##{@name} but the method has changed since the call to replace_method"
-      end
-
-      @restored = true
-
-      if @overwritten
-        # The original method was overwritten. Overwrite again to restore it.
-        T::Configuration.without_ruby_warnings do
-          @mod.send(:define_method, @old_method.name, @old_method)
-        end
-      else
-        # The original method was in an ancestor. Restore it by removing the overriding method.
-        @mod.send(:remove_method, @old_method.name)
-      end
-
-      # Restore the visibility. Note that we need to do this even when we call remove_method
-      # above, because the module may have set custom visibility for a method it inherited.
-      @mod.send(@visibility, @old_method.name)
-
-      nil
-    end
-
-    def bind(obj)
-      @old_method.bind(obj)
-    end
-
-    def to_s
-      @old_method.to_s
-    end
-  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)
+  def self.visibility_method_name(mod, name)
     if mod.public_method_defined?(name)
       :public
     elsif mod.protected_method_defined?(name)
@@ -65,7 +18,10 @@ module T::Private::ClassUtils
     elsif mod.private_method_defined?(name)
       :private
     else
-      mod.method(name) # Raises
+      # 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
 
@@ -90,15 +46,18 @@ module T::Private::ClassUtils
     end
   end
 
-  # Replaces a method, either by overwriting it (if it is defined directly on `mod`) or by
-  # overriding it (if it is defined by one of mod's ancestors).  If `original_only` is
-  # false, returns a ReplacedMethod instance on which you can call `bind(...).call(...)`
-  # to call the original method, or `restore` to restore the original method (by
-  # overwriting or removing the override).
+  # Replaces a method, either by overwriting it (if it is defined directly on
+  # `mod`) or by overriding it (if it is defined by one of mod's ancestors).
+  #
+  # Takes the `original_method` as a parameter, so it does not return anything.
+  #
+  # Can also avoid `T.let` pinning errors by letting the caller pre-compute the
+  # `original_method`, so it knows that it will always be defined (because it
+  # doesn't know that the block will always run once)
   #
-  # If `original_only` is true, return the `UnboundMethod` representing the original method.
-  def self.replace_method(mod, name, original_only=false, &blk)
-    original_method = mod.instance_method(name)
+  # Does not share code with `replace_method_with_handle`, for performance (do
+  # not want to increase the call stack, as this is a very sensitive code path).
+  def self.replace_method(original_method, mod, name, &blk)
     original_visibility = visibility_method_name(mod, name)
     original_owner = original_method.owner
 
@@ -117,18 +76,12 @@ module T::Private::ClassUtils
       end
     end
 
-    overwritten = original_owner == mod
     T::Configuration.without_ruby_warnings do
       T::Private::DeclState.current.without_on_method_added do
         def_with_visibility(mod, name, original_visibility, &blk)
       end
     end
 
-    if original_only
-      original_method
-    else
-      new_method = mod.instance_method(name)
-      ReplacedMethod.new(mod, original_method, new_method, overwritten, original_visibility)
-    end
+    nil
   end
 end

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

@@ -242,7 +242,7 @@ module T::Private::Methods
     # (or unwrap back to the original method).
     key = method_owner_and_name_to_key(mod, method_name)
     unless current_declaration.raw
-      T::Private::ClassUtils.replace_method(mod, method_name, true) do |*args, &blk|
+      T::Private::ClassUtils.replace_method(original_method, mod, method_name) do |*args, &blk|
         method_sig = T::Private::Methods.maybe_run_sig_block_for_key(key)
         method_sig ||= T::Private::Methods._handle_missing_method_signature(
           self,
@@ -541,15 +541,21 @@ module T::Private::Methods
       end
       @old_hooks = nil
     else
-      old_included = T::Private::ClassUtils.replace_method(Module, :included, true) do |arg|
+      # Grab the original methods before replacing them, so that each block
+      # closure can reference a variable that is already assigned.
+      # (Do this directly, to avoid pinning errors)
+      old_included = Module.instance_method(:included)
+      T::Private::ClassUtils.replace_method(old_included, Module, :included) do |arg|
         old_included.bind_call(self, arg)
         ::T::Private::Methods._hook_impl(arg, false, self)
       end
-      old_extended = T::Private::ClassUtils.replace_method(Module, :extended, true) do |arg|
+      old_extended = Module.instance_method(:extended)
+      T::Private::ClassUtils.replace_method(old_extended, Module, :extended) do |arg|
         old_extended.bind_call(self, arg)
         ::T::Private::Methods._hook_impl(arg, true, self)
       end
-      old_inherited = T::Private::ClassUtils.replace_method(Class, :inherited, true) do |arg|
+      old_inherited = Class.instance_method(:inherited)
+      T::Private::ClassUtils.replace_method(old_inherited, Class, :inherited) do |arg|
         old_inherited.bind_call(self, arg)
         ::T::Private::Methods._hook_impl(arg, false, self)
       end
@@ -602,22 +608,6 @@ module T::Private::Methods
     end
     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
 end
 
 # This has to be here, and can't be nested inside `T::Private::Methods`,

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

@@ -16,7 +16,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 = T::Private::Methods.visibility_method_name(mod, method_sig.method_name)
+    original_visibility = T::Private::ClassUtils.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.

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

@@ -304,7 +304,7 @@ module T::Private::Methods::SignatureValidation
   end
 
   private_class_method def self.method_visibility(method)
-    T::Private::Methods.visibility_method_name(method.owner, method.name)
+    T::Private::ClassUtils.visibility_method_name(method.owner, method.name)
   end
 
   # Higher = more restrictive.

data/lib/types/struct.rb

@@ -10,7 +10,8 @@ end
 class T::Struct < T::InexactStruct
   def self.inherited(subclass)
     super(subclass)
-    T::Private::ClassUtils.replace_method(subclass.singleton_class, :inherited, true) do |s|
+    original_method = subclass.singleton_class.instance_method(:inherited)
+    T::Private::ClassUtils.replace_method(original_method, subclass.singleton_class, :inherited) do |s|
       super(s)
       raise "#{self.name} is a subclass of T::Struct and cannot be subclassed"
     end
@@ -23,7 +24,8 @@ class T::ImmutableStruct < T::InexactStruct
   def self.inherited(subclass)
     super(subclass)
 
-    T::Private::ClassUtils.replace_method(subclass.singleton_class, :inherited, true) do |s|
+    original_method = subclass.singleton_class.instance_method(:inherited)
+    T::Private::ClassUtils.replace_method(original_method, subclass.singleton_class, :inherited) do |s|
       super(s)
       raise "#{self.name} is a subclass of T::ImmutableStruct and cannot be subclassed"
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.6.13188
+  version: 0.6.13189
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-05-05 00:00:00.000000000 Z
+date: 2026-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark