sorbet-runtime 0.6.12872 → 0.6.13192

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1df82030d7eef7b4581bd982da33dafd6667515045b5e32e36d95d2cd96e876
-  data.tar.gz: c6b5c03495c971851b599f2465ce86a983a23b7455b9766755b77da9916b2d38
+  metadata.gz: bf43d3cf4e297c8c2c814618b558777e99dad15ee9fdedaf1275adac6303b1ab
+  data.tar.gz: 9b454b18a90066a60aef190a683699dae158bf6e0d42be29b4314e3e5a28a072
 SHA512:
-  metadata.gz: 1491c37794b1e008c76728181aa3fdeb4fa7ac16c995d9c9d8477d7b5a6bd557c921781097d07f060b378de14648050cd773b35735ad46129fe074b888495fe4
-  data.tar.gz: 84d80bada939f468b9580708a11a63f3b08ab61c411b79d202afe294beab896f886213aa044d718170fcabced529be555ee08083be70b6f85f66ea61421ac6c2
+  metadata.gz: b5e5e921d5a506dabd5fe96e434a73723ec8105ac8f4d554379f2e82f265e965dfbeed04b04b1875f8f35520467bb35d41f8baf8dc6558d07068e1ece3f55af6
+  data.tar.gz: 145f14e022976650ccbed8a8abe9398970d687759833650185156e4e4156d91b7fd7b54ade90a86c7be2a916b608880ae739d1d8473e629c29714c1330a33b6b

data/lib/types/helpers.rb

@@ -4,8 +4,6 @@
 # Use as a mixin with extend (`extend T::Helpers`).
 # Docs at https://sorbet.org/docs/
 module T::Helpers
-  extend T::Sig
-
   Private = T::Private
 
   ### Class/Module Helpers ###

data/lib/types/private/abstract/hooks.rb

@@ -27,7 +27,7 @@ module T::Private::Abstract::Hooks
     # `self` may not actually be abstract -- it could be a concrete class that inherited from an
     # abstract class. We only need to check this in `inherited` because, for modules being included
     # or extended, the concrete ones won't have these hooks at all. This is just an optimization.
-    return if !T::AbstractUtils.abstract_module?(self)
+    return if !T::AbstractUtils.abstract_module?(T.unsafe(self))
 
     T::Private::Abstract::Data.set(self, :last_used_by, other)
   end

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

@@ -34,7 +34,13 @@ module T::Private::Methods
   ARG_NOT_PROVIDED = Object.new
   PROC_TYPE = Object.new
 
-  DeclarationBlock = Struct.new(:mod, :loc, :blk, :final, :raw)
+  # blk_or_decl:
+  # - It's a `Proc` if we haven't forced the thunk yet.
+  # - It's a `Declaration` if we have, but we haven't finished building the sig
+  #   (This can matter for circular load-time behavior, where a method is
+  #   called while its Signature is being built)
+  # - It's `nil` if we've finished building the sig
+  DeclarationBlock = Struct.new(:mod, :loc, :blk_or_decl, :final, :raw)
 
   def self.declare_sig(mod, loc, arg, &blk)
     T::Private::DeclState.current.active_declaration = _declare_sig_internal(mod, loc, arg, &blk)
@@ -236,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,
@@ -321,6 +327,7 @@ module T::Private::Methods
         nil
       end
 
+    # Release location information sooner
     declaration_block.loc = nil
 
     signature =
@@ -331,15 +338,28 @@ module T::Private::Methods
       end
 
     unwrap_method(signature.method.owner, signature, original_method)
+
+    # Drop this declaration. Only drop it after we've actually wrapped the
+    # method and recorded the signature, because that might raise an exception,
+    # leaving the declaration in a weird state if the program rescues that
+    # exception and continues.
+    declaration_block.blk_or_decl = nil
+
     signature
   end
 
   def self.run_builder(declaration_block)
+    blk_or_decl = declaration_block.blk_or_decl
+    return blk_or_decl if blk_or_decl.is_a?(Declaration)
+    if blk_or_decl.nil?
+      raise "DeclarationBlock for #{declaration_block.mod} at #{declaration_block.loc} should have already been unwrapped"
+    end
+
     builder = DeclBuilder.new(declaration_block.mod, declaration_block.raw)
-    builder
-      .instance_exec(&declaration_block.blk)
-      .finalize!
-      .decl
+    decl = builder.instance_exec(&blk_or_decl).finalize!.decl
+    # Record that we've already run `blk` once and constructed a `Declaration`
+    declaration_block.blk_or_decl = decl
+    decl
   end
 
   def self.build_sig(hook_mod, method_name, original_method, current_declaration)
@@ -400,7 +420,7 @@ module T::Private::Methods
     @signatures_by_method[key]
   end
 
-  def self.unwrap_method(mod, signature, original_method)
+  private_class_method def self.unwrap_method(mod, signature, original_method)
     maybe_wrapped_method = CallValidation.wrap_method_if_needed(mod, signature, original_method)
     @signatures_by_method[method_to_key(maybe_wrapped_method)] = signature
   end
@@ -439,12 +459,6 @@ module T::Private::Methods
     method_owner_and_name_to_key(method.owner, method.name)
   end
 
-  private_class_method def self.key_to_method(key)
-    id, name = key.split("#")
-    obj = ObjectSpace._id2ref(id.to_i)
-    obj.instance_method(name)
-  end
-
   private_class_method def self.run_sig_block_for_key(key, force_type_init: false)
     blk = @sig_wrappers[key]
     if !blk
@@ -453,7 +467,7 @@ module T::Private::Methods
         # We already ran the sig block, perhaps in another thread.
         return sig
       else
-        raise "No `sig` wrapper for #{key_to_method(key)}"
+        raise "No `sig` wrapper for #{key}. This is likely a bug in sorbet-runtime. If you can reproduce, please report an issue."
       end
     end
 
@@ -464,7 +478,7 @@ module T::Private::Methods
       raise
     end
     if @sigs_that_raised[key]
-      raise "A previous invocation of #{key_to_method(key)} raised, and the current one succeeded. Please don't do that."
+      raise "A previous invocation of #{sig.method_desc} raised, and the current one succeeded. Please don't do that."
     end
 
     @sig_wrappers.delete(key)
@@ -527,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
@@ -588,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

@@ -5,6 +5,10 @@ module T::Private::Methods::CallValidation
   CallValidation = T::Private::Methods::CallValidation
   Modes = T::Private::Methods::Modes
 
+  KERNEL_TO_S = Kernel.instance_method(:to_s)
+  MODULE_TO_S = Module.instance_method(:to_s)
+  private_constant(:KERNEL_TO_S, :MODULE_TO_S)
+
   # Wraps a method with a layer of validation for the given type signature.
   # This wrapper is meant to be fast, and is applied by a previous wrapper,
   # which was placed by `_on_method_added`.
@@ -12,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.
@@ -68,24 +72,32 @@ module T::Private::Methods::CallValidation
   end
 
   def self.create_validator_method(mod, original_method, method_sig, original_visibility)
-    has_fixed_arity = method_sig.kwarg_types.empty? && !method_sig.has_rest && !method_sig.has_keyrest &&
+    has_fixed_arity = method_sig.kwarg_types.empty? && method_sig.rest_type.nil? && method_sig.keyrest_type.nil? &&
       original_method.parameters.all? { |(kind, _name)| kind == :req || kind == :block }
-    can_skip_block_type = method_sig.block_type.nil? || method_sig.block_type.valid?(nil)
+
+    # nil implies block_type.nil?
+    # true implies !block_type.nil? and block_type.valid?(nil)
+    # false implies !block_type.nil? and !block_type.valid?(nil)
+    # This formulation avoids a type error without introducing extra method calls or local vars
+    can_skip_block_type = method_sig.block_type&.valid?(nil) != false
+
     ok_for_fast_path = has_fixed_arity && can_skip_block_type && !method_sig.bind && method_sig.arg_types.length < 5 && is_allowed_to_have_fast_path
 
     all_args_are_simple = ok_for_fast_path && method_sig.arg_types.all? { |_name, type| type.is_a?(T::Types::Simple) }
-    simple_method = all_args_are_simple && method_sig.return_type.is_a?(T::Types::Simple)
-    simple_procedure = all_args_are_simple && method_sig.return_type.is_a?(T::Private::Types::Void)
+
+    effective_return_type = method_sig.effective_return_type
+    simple_method = all_args_are_simple && effective_return_type.is_a?(T::Types::Simple)
+    simple_procedure = all_args_are_simple && effective_return_type.is_a?(T::Private::Types::Void)
 
     # All the types for which valid? unconditionally returns `true`
     return_is_ignorable =
-      method_sig.return_type.equal?(T::Types::Untyped::Private::INSTANCE) ||
-      method_sig.return_type.equal?(T::Types::Anything::Private::INSTANCE) ||
-      method_sig.return_type.equal?(T::Types::AttachedClassType::Private::INSTANCE) ||
-      method_sig.return_type.equal?(T::Types::SelfType::Private::INSTANCE) ||
-      method_sig.return_type.is_a?(T::Types::TypeParameter) ||
-      method_sig.return_type.is_a?(T::Types::TypeVariable) ||
-      (method_sig.return_type.is_a?(T::Types::Simple) && method_sig.return_type.raw_type.equal?(BasicObject))
+      effective_return_type.equal?(T::Types::Untyped::Private::INSTANCE) ||
+      effective_return_type.equal?(T::Types::Anything::Private::INSTANCE) ||
+      effective_return_type.equal?(T::Types::AttachedClassType::Private::INSTANCE) ||
+      effective_return_type.equal?(T::Types::SelfType::Private::INSTANCE) ||
+      effective_return_type.is_a?(T::Types::TypeParameter) ||
+      effective_return_type.is_a?(T::Types::TypeVariable) ||
+      (effective_return_type.is_a?(T::Types::Simple) && effective_return_type.raw_type.equal?(BasicObject))
 
     returns_anything_method = all_args_are_simple && return_is_ignorable
 
@@ -97,7 +109,7 @@ module T::Private::Methods::CallValidation
           create_validator_method_skip_return_fast(mod, original_method, method_sig, original_visibility)
         elsif simple_procedure
           create_validator_procedure_fast(mod, original_method, method_sig, original_visibility)
-        elsif ok_for_fast_path && method_sig.return_type.is_a?(T::Private::Types::Void)
+        elsif ok_for_fast_path && effective_return_type.is_a?(T::Private::Types::Void)
           create_validator_procedure_medium(mod, original_method, method_sig, original_visibility)
         elsif ok_for_fast_path && return_is_ignorable
           create_validator_method_skip_return_medium(mod, original_method, method_sig, original_visibility)
@@ -180,17 +192,17 @@ module T::Private::Methods::CallValidation
 
     # The only type that is allowed to change the return value is `.void`.
     # It ignores what you returned and changes it to be a private singleton.
-    if method_sig.return_type.is_a?(T::Private::Types::Void)
+    if method_sig.effective_return_type.is_a?(T::Private::Types::Void)
       T::Private::Types::Void::VOID
     else
-      message = method_sig.return_type.error_message_for_obj(return_value)
+      message = method_sig.effective_return_type.error_message_for_obj(return_value)
       if message
         CallValidation.report_error(
           method_sig,
           message,
           'Return value',
           nil,
-          method_sig.return_type,
+          method_sig.effective_return_type,
           return_value,
         )
       end
@@ -283,17 +295,17 @@ module T::Private::Methods::CallValidation
 
     # The only type that is allowed to change the return value is `.void`.
     # It ignores what you returned and changes it to be a private singleton.
-    if method_sig.return_type.is_a?(T::Private::Types::Void)
+    if method_sig.effective_return_type.is_a?(T::Private::Types::Void)
       T::Private::Types::Void::VOID
     else
-      message = method_sig.return_type.error_message_for_obj(return_value)
+      message = method_sig.effective_return_type.error_message_for_obj(return_value)
       if message
         CallValidation.report_error(
           method_sig,
           message,
           'Return value',
           nil,
-          method_sig.return_type,
+          method_sig.effective_return_type,
           return_value,
         )
       end
@@ -301,6 +313,16 @@ module T::Private::Methods::CallValidation
     end
   end
 
+  # Get the name of a method owner via its `.to_s`, but fallback if its implementation raises or returns `nil`.
+  private_class_method def self.safe_method_owner_to_s(method_owner)
+    case method_owner
+    when Module # methods are usually owned by a Class or Module...
+      MODULE_TO_S.bind_call(method_owner)
+    else # ... but could be a singleton method on any kind of Object.
+      KERNEL_TO_S.bind_call(method_owner)
+    end
+  end
+
   def self.report_error(method_sig, error_message, kind, name, type, value, caller_offset: 0)
     caller_loc = T.must(caller_locations(3 + caller_offset, 1))[0]
     method = method_sig.method
@@ -310,9 +332,9 @@ module T::Private::Methods::CallValidation
     pretty_method_name =
       if owner.singleton_class? && owner.respond_to?(:attached_object)
         # attached_object is new in Ruby 3.2
-        "#{owner.attached_object}.#{method.name}"
+        "#{safe_method_owner_to_s(owner.attached_object)}.#{method.name}"
       else
-        "#{owner}##{method.name}"
+        "#{safe_method_owner_to_s(owner)}##{method.name}"
       end
 
     pretty_message = "#{kind}#{name ? " '#{name}'" : ''}: #{error_message}\n" \

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

@@ -7,28 +7,28 @@
 
 module T::Private::Methods::CallValidation
   def self.create_validator_method_fast(mod, original_method, method_sig, original_visibility)
-    if method_sig.return_type.is_a?(T::Private::Types::Void)
+    if method_sig.effective_return_type.is_a?(T::Private::Types::Void)
       raise 'Should have used create_validator_procedure_fast'
     end
     # trampoline to reduce stack frame size
     arg_types = method_sig.arg_types
     case arg_types.length
     when 0
-      create_validator_method_fast0(mod, original_method, method_sig, original_visibility, method_sig.return_type.raw_type)
+      create_validator_method_fast0(mod, original_method, method_sig, original_visibility, method_sig.effective_return_type.raw_type)
     when 1
-      create_validator_method_fast1(mod, original_method, method_sig, original_visibility, method_sig.return_type.raw_type,
+      create_validator_method_fast1(mod, original_method, method_sig, original_visibility, method_sig.effective_return_type.raw_type,
                                     arg_types[0][1].raw_type)
     when 2
-      create_validator_method_fast2(mod, original_method, method_sig, original_visibility, method_sig.return_type.raw_type,
+      create_validator_method_fast2(mod, original_method, method_sig, original_visibility, method_sig.effective_return_type.raw_type,
                                     arg_types[0][1].raw_type,
                                     arg_types[1][1].raw_type)
     when 3
-      create_validator_method_fast3(mod, original_method, method_sig, original_visibility, method_sig.return_type.raw_type,
+      create_validator_method_fast3(mod, original_method, method_sig, original_visibility, method_sig.effective_return_type.raw_type,
                                     arg_types[0][1].raw_type,
                                     arg_types[1][1].raw_type,
                                     arg_types[2][1].raw_type)
     when 4
-      create_validator_method_fast4(mod, original_method, method_sig, original_visibility, method_sig.return_type.raw_type,
+      create_validator_method_fast4(mod, original_method, method_sig, original_visibility, method_sig.effective_return_type.raw_type,
                                     arg_types[0][1].raw_type,
                                     arg_types[1][1].raw_type,
                                     arg_types[2][1].raw_type,
@@ -58,14 +58,14 @@ module T::Private::Methods::CallValidation
 
       return_value = original_method.bind_call(self, &blk)
       unless return_value.is_a?(return_type)
-        message = method_sig.return_type.error_message_for_obj(return_value)
+        message = method_sig.effective_return_type.error_message_for_obj(return_value)
         if message
           CallValidation.report_error(
             method_sig,
             message,
             'Return value',
             nil,
-            method_sig.return_type,
+            method_sig.effective_return_type,
             return_value,
             caller_offset: -1
           )
@@ -107,14 +107,14 @@ module T::Private::Methods::CallValidation
 
       return_value = original_method.bind_call(self, arg0, &blk)
       unless return_value.is_a?(return_type)
-        message = method_sig.return_type.error_message_for_obj(return_value)
+        message = method_sig.effective_return_type.error_message_for_obj(return_value)
         if message
           CallValidation.report_error(
             method_sig,
             message,
             'Return value',
             nil,
-            method_sig.return_type,
+            method_sig.effective_return_type,
             return_value,
             caller_offset: -1
           )
@@ -168,14 +168,14 @@ module T::Private::Methods::CallValidation
 
       return_value = original_method.bind_call(self, arg0, arg1, &blk)
       unless return_value.is_a?(return_type)
-        message = method_sig.return_type.error_message_for_obj(return_value)
+        message = method_sig.effective_return_type.error_message_for_obj(return_value)
         if message
           CallValidation.report_error(
             method_sig,
             message,
             'Return value',
             nil,
-            method_sig.return_type,
+            method_sig.effective_return_type,
             return_value,
             caller_offset: -1
           )
@@ -241,14 +241,14 @@ module T::Private::Methods::CallValidation
 
       return_value = original_method.bind_call(self, arg0, arg1, arg2, &blk)
       unless return_value.is_a?(return_type)
-        message = method_sig.return_type.error_message_for_obj(return_value)
+        message = method_sig.effective_return_type.error_message_for_obj(return_value)
         if message
           CallValidation.report_error(
             method_sig,
             message,
             'Return value',
             nil,
-            method_sig.return_type,
+            method_sig.effective_return_type,
             return_value,
             caller_offset: -1
           )
@@ -326,14 +326,14 @@ module T::Private::Methods::CallValidation
 
       return_value = original_method.bind_call(self, arg0, arg1, arg2, arg3, &blk)
       unless return_value.is_a?(return_type)
-        message = method_sig.return_type.error_message_for_obj(return_value)
+        message = method_sig.effective_return_type.error_message_for_obj(return_value)
         if message
           CallValidation.report_error(
             method_sig,
             message,
             'Return value',
             nil,
-            method_sig.return_type,
+            method_sig.effective_return_type,
             return_value,
             caller_offset: -1
           )
@@ -867,28 +867,28 @@ module T::Private::Methods::CallValidation
   end
 
   def self.create_validator_method_medium(mod, original_method, method_sig, original_visibility)
-    if method_sig.return_type.is_a?(T::Private::Types::Void)
+    if method_sig.effective_return_type.is_a?(T::Private::Types::Void)
       raise 'Should have used create_validator_procedure_medium'
     end
     # trampoline to reduce stack frame size
     arg_types = method_sig.arg_types
     case arg_types.length
     when 0
-      create_validator_method_medium0(mod, original_method, method_sig, original_visibility, method_sig.return_type)
+      create_validator_method_medium0(mod, original_method, method_sig, original_visibility, method_sig.effective_return_type)
     when 1
-      create_validator_method_medium1(mod, original_method, method_sig, original_visibility, method_sig.return_type,
+      create_validator_method_medium1(mod, original_method, method_sig, original_visibility, method_sig.effective_return_type,
                                     arg_types[0][1])
     when 2
-      create_validator_method_medium2(mod, original_method, method_sig, original_visibility, method_sig.return_type,
+      create_validator_method_medium2(mod, original_method, method_sig, original_visibility, method_sig.effective_return_type,
                                     arg_types[0][1],
                                     arg_types[1][1])
     when 3
-      create_validator_method_medium3(mod, original_method, method_sig, original_visibility, method_sig.return_type,
+      create_validator_method_medium3(mod, original_method, method_sig, original_visibility, method_sig.effective_return_type,
                                     arg_types[0][1],
                                     arg_types[1][1],
                                     arg_types[2][1])
     when 4
-      create_validator_method_medium4(mod, original_method, method_sig, original_visibility, method_sig.return_type,
+      create_validator_method_medium4(mod, original_method, method_sig, original_visibility, method_sig.effective_return_type,
                                     arg_types[0][1],
                                     arg_types[1][1],
                                     arg_types[2][1],
@@ -918,14 +918,14 @@ module T::Private::Methods::CallValidation
 
       return_value = original_method.bind_call(self, &blk)
       unless return_type.valid?(return_value)
-        message = method_sig.return_type.error_message_for_obj(return_value)
+        message = method_sig.effective_return_type.error_message_for_obj(return_value)
         if message
           CallValidation.report_error(
             method_sig,
             message,
             'Return value',
             nil,
-            method_sig.return_type,
+            method_sig.effective_return_type,
             return_value,
             caller_offset: -1
           )
@@ -967,14 +967,14 @@ module T::Private::Methods::CallValidation
 
       return_value = original_method.bind_call(self, arg0, &blk)
       unless return_type.valid?(return_value)
-        message = method_sig.return_type.error_message_for_obj(return_value)
+        message = method_sig.effective_return_type.error_message_for_obj(return_value)
         if message
           CallValidation.report_error(
             method_sig,
             message,
             'Return value',
             nil,
-            method_sig.return_type,
+            method_sig.effective_return_type,
             return_value,
             caller_offset: -1
           )
@@ -1028,14 +1028,14 @@ module T::Private::Methods::CallValidation
 
       return_value = original_method.bind_call(self, arg0, arg1, &blk)
       unless return_type.valid?(return_value)
-        message = method_sig.return_type.error_message_for_obj(return_value)
+        message = method_sig.effective_return_type.error_message_for_obj(return_value)
         if message
           CallValidation.report_error(
             method_sig,
             message,
             'Return value',
             nil,
-            method_sig.return_type,
+            method_sig.effective_return_type,
             return_value,
             caller_offset: -1
           )
@@ -1101,14 +1101,14 @@ module T::Private::Methods::CallValidation
 
       return_value = original_method.bind_call(self, arg0, arg1, arg2, &blk)
       unless return_type.valid?(return_value)
-        message = method_sig.return_type.error_message_for_obj(return_value)
+        message = method_sig.effective_return_type.error_message_for_obj(return_value)
         if message
           CallValidation.report_error(
             method_sig,
             message,
             'Return value',
             nil,
-            method_sig.return_type,
+            method_sig.effective_return_type,
             return_value,
             caller_offset: -1
           )
@@ -1186,14 +1186,14 @@ module T::Private::Methods::CallValidation
 
       return_value = original_method.bind_call(self, arg0, arg1, arg2, arg3, &blk)
       unless return_type.valid?(return_value)
-        message = method_sig.return_type.error_message_for_obj(return_value)
+        message = method_sig.effective_return_type.error_message_for_obj(return_value)
         if message
           CallValidation.report_error(
             method_sig,
             message,
             'Return value',
             nil,
-            method_sig.return_type,
+            method_sig.effective_return_type,
             return_value,
             caller_offset: -1
           )

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

@@ -22,10 +22,10 @@ module T::Private::Methods
         ARG_NOT_PROVIDED, # returns
         ARG_NOT_PROVIDED, # bind
         Modes.standard, # mode
-        ARG_NOT_PROVIDED, # checked
+        nil, # checked
         false, # finalized
         ARG_NOT_PROVIDED, # on_failure
-        nil, # override_allow_incompatible
+        false, # override_allow_incompatible
         ARG_NOT_PROVIDED, # type_parameters
         raw
       )
@@ -98,10 +98,10 @@ module T::Private::Methods
     def checked(level)
       check_live!
 
-      if !decl.checked.equal?(ARG_NOT_PROVIDED)
+      if !decl.checked.nil?
         raise BuilderError.new("You can't call .checked multiple times in a signature.")
       end
-      if level == :never && !decl.on_failure.equal?(ARG_NOT_PROVIDED)
+      if :never == level && !decl.on_failure.equal?(ARG_NOT_PROVIDED)
         raise BuilderError.new("You can't use .checked(:#{level}) with .on_failure because .on_failure will have no effect.")
       end
       if !T::Private::RuntimeLevels::LEVELS.include?(level)
@@ -119,8 +119,13 @@ module T::Private::Methods
       if !decl.on_failure.equal?(ARG_NOT_PROVIDED)
         raise BuilderError.new("You can't call .on_failure multiple times in a signature.")
       end
-      if decl.checked == :never
-        raise BuilderError.new("You can't use .on_failure with .checked(:#{decl.checked}) because .on_failure will have no effect.")
+      effective_checked = decl.checked.nil? ? T::Private::RuntimeLevels.default_checked_level : decl.checked
+      if effective_checked == :never
+        if decl.checked.nil?
+          raise BuilderError.new("To use .on_failure you must additionally call .checked(:tests) or .checked(:always), otherwise, the .on_failure has no effect.")
+        else
+          raise BuilderError.new("You can't use .on_failure with .checked(:#{effective_checked}) because .on_failure will have no effect.")
+        end
       end
 
       decl.on_failure = args
@@ -225,13 +230,6 @@ module T::Private::Methods
       if decl.bind.equal?(ARG_NOT_PROVIDED)
         decl.bind = nil
       end
-      if decl.checked.equal?(ARG_NOT_PROVIDED)
-        default_checked_level = T::Private::RuntimeLevels.default_checked_level
-        if default_checked_level == :never && !decl.on_failure.equal?(ARG_NOT_PROVIDED)
-          raise BuilderError.new("To use .on_failure you must additionally call .checked(:tests) or .checked(:always), otherwise, the .on_failure has no effect.")
-        end
-        decl.checked = default_checked_level
-      end
       if decl.on_failure.equal?(ARG_NOT_PROVIDED)
         decl.on_failure = nil
       end

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

@@ -3,8 +3,8 @@
 
 class T::Private::Methods::Signature
   attr_reader :method, :method_name, :arg_types, :kwarg_types, :block_type, :block_name,
-              :rest_type, :rest_name, :keyrest_type, :keyrest_name, :bind,
-              :return_type, :mode, :req_arg_count, :req_kwarg_names, :has_rest, :has_keyrest,
+              :rest_type, :rest_name, :keyrest_type, :keyrest_name, :bind, :effective_return_type,
+              :return_type, :mode, :req_arg_count, :req_kwarg_names,
               :check_level, :parameters, :on_failure, :override_allow_incompatible,
               :defined_raw
 
@@ -37,6 +37,7 @@ class T::Private::Methods::Signature
   end
 
   def initialize(method:, method_name:, raw_arg_types:, raw_return_type:, bind:, mode:, check_level:, on_failure:, parameters: method.parameters, override_allow_incompatible: false, defined_raw: false)
+    check_level = check_level.nil? ? T::Private::RuntimeLevels.default_checked_level : check_level
     @method = method
     @method_name = method_name
     @block_type = nil
@@ -46,11 +47,14 @@ class T::Private::Methods::Signature
     @keyrest_type = nil
     @keyrest_name = nil
     @return_type = T::Utils.coerce(raw_return_type)
+    @effective_return_type = if check_level == :tests && @return_type.is_a?(T::Private::Types::Void)
+      T::Types::Anything::Private::INSTANCE
+    else
+      @return_type
+    end
     @bind = bind ? T::Utils.coerce(bind) : bind
     @mode = mode
     @check_level = check_level
-    @has_rest = false
-    @has_keyrest = false
     @parameters = parameters
     @on_failure = on_failure
     @override_allow_incompatible = override_allow_incompatible
@@ -134,11 +138,9 @@ class T::Private::Methods::Signature
         @block_name = param_name
         @block_type = type
       when :rest
-        @has_rest = true
         @rest_name = param_name
         @rest_type = type
       when :keyrest
-        @has_keyrest = true
         @keyrest_name = param_name
         @keyrest_type = type
       else
@@ -175,10 +177,6 @@ class T::Private::Methods::Signature
     @method.owner
   end
 
-  def dsl_method
-    "#{@mode}_method"
-  end
-
   # @return [Hash] a mapping like `{arg_name: [val, type], ...}`, for only those args actually present.
   def each_args_value_type(args)
     # Manually split out args and kwargs based on ruby's behavior. Do not try to implement this by
@@ -189,14 +187,14 @@ class T::Private::Methods::Signature
     # causes forwarding **kwargs to do the wrong thing: see https://bugs.ruby-lang.org/issues/10708
     # and https://bugs.ruby-lang.org/issues/11860.
     args_length = args.length
-    if (args_length > @req_arg_count) && (!@kwarg_types.empty? || @has_keyrest) && args[-1].is_a?(Hash)
-      kwargs = args[-1]
+    if (args_length > @req_arg_count) && (!@kwarg_types.empty? || !@keyrest_type.nil?) && (last_arg = args[-1]).is_a?(Hash)
+      kwargs = last_arg
       args_length -= 1
     else
       kwargs = EMPTY_HASH
     end
 
-    if !@has_rest && ((args_length < @req_arg_count) || (args_length > @arg_types.length))
+    if @rest_type.nil? && ((args_length < @req_arg_count) || (args_length > @arg_types.length))
       expected_str = @req_arg_count.to_s
       if @arg_types.length != @req_arg_count
         expected_str += "..#{@arg_types.length}"
@@ -210,11 +208,12 @@ class T::Private::Methods::Signature
       # Process given pre-rest args. When there are no rest args,
       # this is just the given number of args.
       while it < args_length && it < @arg_types.length
-        yield @arg_types[it][0], args[it], @arg_types[it][1]
+        arg_type = @arg_types.fetch(it)
+        yield arg_type[0], args[it], arg_type[1]
         it += 1
       end
 
-      if @has_rest
+      if !@rest_type.nil?
         rest_count = args_length - @arg_types.length
         rest_count = 0 if rest_count.negative?
 
@@ -227,7 +226,7 @@ class T::Private::Methods::Signature
 
     kwargs.each do |name, val|
       type = @kwarg_types[name]
-      if !type && @has_keyrest
+      if !type && !@keyrest_type.nil?
         type = @keyrest_type
       end
 
@@ -236,12 +235,12 @@ class T::Private::Methods::Signature
   end
 
   def method_desc
-    loc = if @method.source_location
-      @method.source_location.join(':')
+    loc = if (source_loc = @method.source_location)
+      source_loc.join(':')
     else
       "<unknown location>"
     end
-    "#{@method} at #{loc}"
+    "#{@method.owner}##{@method_name} at #{loc}"
   end
 
   def force_type_init

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

@@ -126,12 +126,12 @@ module T::Private::Methods::SignatureValidation
         # Peaceful
       elsif super_signature.mode == Modes.abstract
         raise "You must use `.override` when overriding the abstract method `#{signature.method_name}`.\n" \
-              "  Abstract definition: #{method_loc_str(super_signature.method)}\n" \
-              "  Implementation definition: #{method_loc_str(signature.method)}\n"
+              "  Abstract definition: #{super_signature.method_desc}\n" \
+              "  Implementation definition: #{signature.method_desc}\n"
       elsif super_signature.mode != Modes.untyped
         raise "You must use `.override` when overriding the existing method `#{signature.method_name}`.\n" \
-              "  Parent definition: #{method_loc_str(super_signature.method)}\n" \
-              "  Child definition:  #{method_loc_str(signature.method)}\n"
+              "  Parent definition: #{super_signature.method_desc}\n" \
+              "  Child definition:  #{signature.method_desc}\n"
       end
     else
       raise "Unexpected mode: #{signature.mode}. Please report this bug at https://github.com/sorbet/sorbet/issues"
@@ -153,7 +153,7 @@ module T::Private::Methods::SignatureValidation
       else
         raise "You marked `#{signature.method_name}` as #{pretty_mode(signature)}, but that method doesn't already exist in this class/module to be overridden.\n" \
           "  Either check for typos and for missing includes or super classes to make the parent method shows up\n" \
-          "  ... or remove #{pretty_mode(signature)} here: #{method_loc_str(signature.method)}\n"
+          "  ... or remove #{pretty_mode(signature)} here: #{signature.method_desc}\n"
       end
     when Modes.standard, *Modes::NON_OVERRIDE_MODES
       # Peaceful
@@ -182,13 +182,13 @@ module T::Private::Methods::SignatureValidation
     method_name = signature.method_name
     mode_verb = super_signature.mode == Modes.abstract ? 'implements' : 'overrides'
 
-    if !signature.has_rest && signature.arg_count < super_signature.arg_count
+    if signature.rest_type.nil? && signature.arg_count < super_signature.arg_count
       raise "Your definition of `#{method_name}` must accept at least #{super_signature.arg_count} " \
             "positional arguments to be compatible with the method it #{mode_verb}: " \
             "#{base_override_loc_str(signature, super_signature)}"
     end
 
-    if !signature.has_rest && super_signature.has_rest
+    if signature.rest_type.nil? && !super_signature.rest_type.nil?
       raise "Your definition of `#{method_name}` must have `*#{super_signature.rest_name}` " \
             "to be compatible with the method it #{mode_verb}: " \
             "#{base_override_loc_str(signature, super_signature)}"
@@ -200,7 +200,7 @@ module T::Private::Methods::SignatureValidation
             "#{base_override_loc_str(signature, super_signature)}"
     end
 
-    if !signature.has_keyrest
+    if signature.keyrest_type.nil?
       # O(nm), but n and m are tiny here
       missing_kwargs = super_signature.kwarg_names - signature.kwarg_names
       if !missing_kwargs.empty?
@@ -210,7 +210,7 @@ module T::Private::Methods::SignatureValidation
       end
     end
 
-    if !signature.has_keyrest && super_signature.has_keyrest
+    if signature.keyrest_type.nil? && !super_signature.keyrest_type.nil?
       raise "Your definition of `#{method_name}` must have `**#{super_signature.keyrest_name}` " \
             "to be compatible with the method it #{mode_verb}: " \
             "#{base_override_loc_str(signature, super_signature)}"
@@ -244,8 +244,8 @@ module T::Private::Methods::SignatureValidation
       if !super_type.subtype_of?(type)
         raise "Incompatible type for arg ##{index + 1} (`#{name}`) in signature for #{mode_noun} of method " \
               "`#{signature.method_name}`:\n" \
-              "* Base: `#{super_type}` (in #{method_loc_str(super_signature.method)})\n" \
-              "* #{mode_noun.capitalize}: `#{type}` (in #{method_loc_str(signature.method)})\n" \
+              "* Base: `#{super_type}` (in #{super_signature.method_desc})\n" \
+              "* #{mode_noun.capitalize}: `#{type}` (in #{signature.method_desc})\n" \
               "(The types must be contravariant.)"
       end
     end
@@ -255,24 +255,24 @@ module T::Private::Methods::SignatureValidation
       type = signature.kwarg_types[name]
       if !super_type.subtype_of?(type)
         raise "Incompatible type for arg `#{name}` in signature for #{mode_noun} of method `#{signature.method_name}`:\n" \
-              "* Base: `#{super_type}` (in #{method_loc_str(super_signature.method)})\n" \
-              "* #{mode_noun.capitalize}: `#{type}` (in #{method_loc_str(signature.method)})\n" \
+              "* Base: `#{super_type}` (in #{super_signature.method_desc})\n" \
+              "* #{mode_noun.capitalize}: `#{type}` (in #{signature.method_desc})\n" \
               "(The types must be contravariant.)"
       end
     end
 
     # return types must be covariant
-    super_signature_return_type = super_signature.return_type
+    super_signature_return_type = super_signature.effective_return_type
 
     if super_signature_return_type == T::Private::Types::Void::Private::INSTANCE
       # Treat `.void` as `T.anything` (see corresponding comment in definition_valitor for more)
       super_signature_return_type = T::Types::Anything::Private::INSTANCE
     end
 
-    if !signature.return_type.subtype_of?(super_signature_return_type)
+    if !signature.effective_return_type.subtype_of?(super_signature_return_type)
       raise "Incompatible return type in signature for #{mode_noun} of method `#{signature.method_name}`:\n" \
-            "* Base: `#{super_signature.return_type}` (in #{method_loc_str(super_signature.method)})\n" \
-            "* #{mode_noun.capitalize}: `#{signature.return_type}` (in #{method_loc_str(signature.method)})\n" \
+            "* Base: `#{super_signature.effective_return_type}` (in #{super_signature.method_desc})\n" \
+            "* #{mode_noun.capitalize}: `#{signature.effective_return_type}` (in #{signature.method_desc})\n" \
             "(The types must be covariant.)"
     end
   end
@@ -297,14 +297,14 @@ module T::Private::Methods::SignatureValidation
 
     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" \
+            "* Base: #{super_vis} (in #{super_signature.method_desc})\n" \
+            "* #{mode_noun.capitalize}: #{vis} (in #{signature.method_desc})\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)
+    T::Private::ClassUtils.visibility_method_name(method.owner, method.name)
   end
 
   # Higher = more restrictive.
@@ -317,16 +317,7 @@ module T::Private::Methods::SignatureValidation
 
   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)}" \
-    "\n * #{mode_noun}: in #{method_loc_str(signature.method)}"
-  end
-
-  private_class_method def self.method_loc_str(method)
-    loc = if method.source_location
-      method.source_location.join(':')
-    else
-      "<unknown location>"
-    end
-    "#{method.owner} at #{loc}"
+    "\n * Base definition: in #{super_signature.method_desc}" \
+    "\n * #{mode_noun}: in #{signature.method_desc}"
   end
 end

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,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.6.12872
+  version: 0.6.13192
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-12-25 00:00:00.000000000 Z
+date: 2026-05-06 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: benchmark
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -136,20 +150,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: subprocess
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.5.3
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.5.3
 description: Sorbet's runtime type checking component
 email: 
 executables: []