sorbet-runtime 0.6.13300 → 0.6.13301

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 24e2e39ecb07eff0a9d4e9efeeebe17935b16363cf0e27b070e9ac9b5e90eccf
-  data.tar.gz: 7e4c6aca4672cfe3aa3a33779e640a343c981330fbda03a2d1471b7ac619ae20
+  metadata.gz: 11be14e5fdfd480b79b5c799ffc878c604f8cdd3c5776f5b7eb55eaf143d59ee
+  data.tar.gz: c90d13ff890616e82d414249178bbd5dfb080c7604bc5b4a5c2b706ef9fd63c7
 SHA512:
-  metadata.gz: 86e102983a1b56070cc100e77a809cf77ffdc4cc0c3ea3d4986020e9ecf85763af195cd24517157ddf2d2d4ed25c32ba9d92a19ecb1857c61b2c9503e737ac98
-  data.tar.gz: 63d055b3273fff38053757d9e439a8e82f945d1edc0d883b2a82a1f442feb13af73a199eb56aa5216aa67e2f9c749431c29a50b5d27d24e483f580d4beca7fb5
+  metadata.gz: 40aebdc992a72011d67c62214f0cd36d7cf1a6a728c1c9db44beb6b2af5d97b4a7783b2896892382bdc10cde4bb9a4a3be8aa9ea901da409902569a6e52ee9ed
+  data.tar.gz: efbf3fff51bae607d1e0c25e12c768c95ce5e289677ab9f22fd5fb88b7f8045c9dd0940c5d3efba7b9d1ac66c53d6da166d062311b2a4b0e812166b17ba867cf

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

@@ -72,8 +72,16 @@ module T::Private::Methods::CallValidation
   end
 
   def self.create_validator_method(mod, original_method, method_sig, original_visibility)
+    # Wrapper-shape decisions must read the parameters of the method actually being wrapped, not
+    # `method_sig.parameters` (captured at sig-build time). The two diverge when a sig'd method is
+    # re-wrapped over a different implementation: a stub redefined as `def m(*args, **kwargs, &blk)`
+    # then re-validated against the original fixed-arity sig would otherwise pick a fixed-arity wrapper,
+    # which binds args to named positionals and forwards them without the `ruby2_keywords` flag, turning
+    # a trailing `key: val` into a positional hash. Reading from `original_method` costs one array per
+    # wrap, off the hot path.
+    parameters = original_method.parameters
     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 }
+      parameters.all? { |(kind, _name)| kind == :req || kind == :block }
 
     # nil implies block_type.nil?
     # true implies !block_type.nil? and block_type.valid?(nil)
@@ -83,6 +91,29 @@ module T::Private::Methods::CallValidation
 
     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
 
+    # Like `ok_for_fast_path`, but for the specialized wrappers below, each of
+    # which supports exactly one extra call shape (kwargs, a required block, or
+    # optional positional args) on top of what the fast/medium wrappers support.
+    ok_for_specialized_path = !ok_for_fast_path && !method_sig.bind && method_sig.rest_type.nil? &&
+      method_sig.keyrest_type.nil? && method_sig.arg_types.length < 5 && is_allowed_to_have_fast_path
+
+    # Restricted to methods with no positional args. The kwargs wrapper's `|**kwargs, &blk|` declares a
+    # keyword-rest, which would capture a bare `key: val` hash that a method with a positional parameter
+    # expects to receive positionally, starving that parameter. All-kwargs methods have no such parameter,
+    # so the wrapper matches a direct call. (Most kwargs-shaped sigs take only kwargs.)
+    kwargs_path = ok_for_specialized_path && can_skip_block_type && !method_sig.kwarg_types.empty? &&
+      method_sig.arg_types.empty? &&
+      parameters.all? { |(kind, _name)| kind == :key || kind == :keyreq || kind == :block }
+
+    required_block_path = ok_for_specialized_path && !can_skip_block_type && has_fixed_arity
+
+    # At least one param is `:opt` here (otherwise `ok_for_fast_path` would hold). The wrapper forwards
+    # through a `ruby2_keywords`-flagged `|*args, &blk|` splat (see below), not named optional parameters:
+    # named params have no `*rest` for `def_with_visibility` to flag, so a trailing `key: val` that Ruby
+    # packs into an optional positional would lose the keyword flag the slow path preserves.
+    optional_args_path = ok_for_specialized_path && can_skip_block_type && method_sig.kwarg_types.empty? &&
+      parameters.all? { |(kind, _name)| kind == :req || kind == :opt || kind == :block }
+
     all_args_are_simple = ok_for_fast_path && method_sig.arg_types.all? { |_name, type| type.is_a?(T::Types::Simple) }
 
     effective_return_type = method_sig.effective_return_type
@@ -115,6 +146,12 @@ module T::Private::Methods::CallValidation
           create_validator_method_skip_return_medium(mod, original_method, method_sig, original_visibility)
         elsif ok_for_fast_path
           create_validator_method_medium(mod, original_method, method_sig, original_visibility)
+        elsif kwargs_path
+          create_validator_method_kwargs(mod, original_method, method_sig, original_visibility)
+        elsif required_block_path
+          create_validator_method_with_block(mod, original_method, method_sig, original_visibility)
+        elsif optional_args_path
+          create_validator_method_optional_args(mod, original_method, method_sig, original_visibility)
         elsif can_skip_block_type
           # The Ruby VM already validates that any block passed to a method
           # must be either `nil` or a `Proc` object, so there's no need to also

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

@@ -1726,4 +1726,1030 @@ module T::Private::Methods::CallValidation
     end
   end
 
+  def self.create_validator_method_kwargs(mod, original_method, method_sig, original_visibility)
+    return_type = method_sig.effective_return_type
+    return_type = nil if return_type.is_a?(T::Private::Types::Void)
+    create_validator_method_kwargs0(mod, original_method, method_sig, original_visibility, return_type, method_sig.kwarg_types)
+  end
+
+  def self.create_validator_method_kwargs0(mod, original_method, method_sig, original_visibility, return_type, kwarg_types)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |**kwargs, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      # NOTE: like `validate_call`, we don't validate for missing or extra
+      # kwargs; the `bind_call` below takes care of that.
+      kwargs.each do |name, val|
+        type = kwarg_types[name]
+        next unless type
+        next if type.valid?(val)
+        CallValidation.report_error(
+          method_sig,
+          type.error_message_for_obj(val),
+          'Parameter',
+          name,
+          type,
+          val,
+          caller_offset: 1
+        )
+      end
+      return_value = original_method.bind_call(self, **kwargs, &blk)
+      if return_type.nil?
+        T::Private::Types::Void::VOID
+      else
+        unless return_type.valid?(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.effective_return_type,
+              return_value,
+              caller_offset: -1
+            )
+          end
+        end
+        return_value
+      end
+    end
+  end
+
+  def self.create_validator_method_with_block(mod, original_method, method_sig, original_visibility)
+    return_type = method_sig.effective_return_type
+    return_type = nil if return_type.is_a?(T::Private::Types::Void)
+    block_type = method_sig.block_type
+    # trampoline to reduce stack frame size
+    arg_types = method_sig.arg_types
+    case arg_types.length
+    when 0
+      create_validator_method_with_block0(mod, original_method, method_sig, original_visibility, return_type, block_type)
+    when 1
+      create_validator_method_with_block1(mod, original_method, method_sig, original_visibility, return_type, block_type,
+                                          arg_types[0][1])
+    when 2
+      create_validator_method_with_block2(mod, original_method, method_sig, original_visibility, return_type, block_type,
+                                          arg_types[0][1],
+                                          arg_types[1][1])
+    when 3
+      create_validator_method_with_block3(mod, original_method, method_sig, original_visibility, return_type, block_type,
+                                          arg_types[0][1],
+                                          arg_types[1][1],
+                                          arg_types[2][1])
+    when 4
+      create_validator_method_with_block4(mod, original_method, method_sig, original_visibility, return_type, block_type,
+                                          arg_types[0][1],
+                                          arg_types[1][1],
+                                          arg_types[2][1],
+                                          arg_types[3][1])
+    else
+      raise 'should not happen'
+    end
+  end
+
+  def self.create_validator_method_with_block0(mod, original_method, method_sig, original_visibility, return_type, block_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |&blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      if blk.nil?
+        CallValidation.report_error(
+          method_sig,
+          block_type.error_message_for_obj(blk),
+          'Block parameter',
+          method_sig.block_name,
+          block_type,
+          blk,
+          caller_offset: -1
+        )
+      end
+      return_value = original_method.bind_call(self, &blk)
+      if return_type.nil?
+        T::Private::Types::Void::VOID
+      else
+        unless return_type.valid?(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.effective_return_type,
+              return_value,
+              caller_offset: -1
+            )
+          end
+        end
+        return_value
+      end
+    end
+  end
+
+  def self.create_validator_method_with_block1(mod, original_method, method_sig, original_visibility, return_type, block_type, arg0_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+      if blk.nil?
+        CallValidation.report_error(
+          method_sig,
+          block_type.error_message_for_obj(blk),
+          'Block parameter',
+          method_sig.block_name,
+          block_type,
+          blk,
+          caller_offset: -1
+        )
+      end
+      return_value = original_method.bind_call(self, arg0, &blk)
+      if return_type.nil?
+        T::Private::Types::Void::VOID
+      else
+        unless return_type.valid?(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.effective_return_type,
+              return_value,
+              caller_offset: -1
+            )
+          end
+        end
+        return_value
+      end
+    end
+  end
+
+  def self.create_validator_method_with_block2(mod, original_method, method_sig, original_visibility, return_type, block_type, arg0_type, arg1_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+      unless arg1_type.valid?(arg1)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+      if blk.nil?
+        CallValidation.report_error(
+          method_sig,
+          block_type.error_message_for_obj(blk),
+          'Block parameter',
+          method_sig.block_name,
+          block_type,
+          blk,
+          caller_offset: -1
+        )
+      end
+      return_value = original_method.bind_call(self, arg0, arg1, &blk)
+      if return_type.nil?
+        T::Private::Types::Void::VOID
+      else
+        unless return_type.valid?(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.effective_return_type,
+              return_value,
+              caller_offset: -1
+            )
+          end
+        end
+        return_value
+      end
+    end
+  end
+
+  def self.create_validator_method_with_block3(mod, original_method, method_sig, original_visibility, return_type, block_type, arg0_type, arg1_type, arg2_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+      unless arg1_type.valid?(arg1)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+      unless arg2_type.valid?(arg2)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(arg2),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          arg2,
+          caller_offset: -1
+        )
+      end
+      if blk.nil?
+        CallValidation.report_error(
+          method_sig,
+          block_type.error_message_for_obj(blk),
+          'Block parameter',
+          method_sig.block_name,
+          block_type,
+          blk,
+          caller_offset: -1
+        )
+      end
+      return_value = original_method.bind_call(self, arg0, arg1, arg2, &blk)
+      if return_type.nil?
+        T::Private::Types::Void::VOID
+      else
+        unless return_type.valid?(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.effective_return_type,
+              return_value,
+              caller_offset: -1
+            )
+          end
+        end
+        return_value
+      end
+    end
+  end
+
+  def self.create_validator_method_with_block4(mod, original_method, method_sig, original_visibility, return_type, block_type, arg0_type, arg1_type, arg2_type, arg3_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, arg3, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+      unless arg1_type.valid?(arg1)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+      unless arg2_type.valid?(arg2)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(arg2),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          arg2,
+          caller_offset: -1
+        )
+      end
+      unless arg3_type.valid?(arg3)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[3][1].error_message_for_obj(arg3),
+          'Parameter',
+          method_sig.arg_types[3][0],
+          arg3_type,
+          arg3,
+          caller_offset: -1
+        )
+      end
+      if blk.nil?
+        CallValidation.report_error(
+          method_sig,
+          block_type.error_message_for_obj(blk),
+          'Block parameter',
+          method_sig.block_name,
+          block_type,
+          blk,
+          caller_offset: -1
+        )
+      end
+      return_value = original_method.bind_call(self, arg0, arg1, arg2, arg3, &blk)
+      if return_type.nil?
+        T::Private::Types::Void::VOID
+      else
+        unless return_type.valid?(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.effective_return_type,
+              return_value,
+              caller_offset: -1
+            )
+          end
+        end
+        return_value
+      end
+    end
+  end
+
+  def self.create_validator_method_optional_args(mod, original_method, method_sig, original_visibility)
+    return_type = method_sig.effective_return_type
+    return_type = nil if return_type.is_a?(T::Private::Types::Void)
+    # trampoline to reduce stack frame size
+    arg_types = method_sig.arg_types
+    case [method_sig.req_arg_count, arg_types.length]
+    when [0, 1]
+      create_validator_method_optional_args0_1(mod, original_method, method_sig, original_visibility, return_type,
+                                                arg_types[0][1])
+    when [0, 2]
+      create_validator_method_optional_args0_2(mod, original_method, method_sig, original_visibility, return_type,
+                                                arg_types[0][1],
+                                                arg_types[1][1])
+    when [1, 2]
+      create_validator_method_optional_args1_2(mod, original_method, method_sig, original_visibility, return_type,
+                                                arg_types[0][1],
+                                                arg_types[1][1])
+    when [0, 3]
+      create_validator_method_optional_args0_3(mod, original_method, method_sig, original_visibility, return_type,
+                                                arg_types[0][1],
+                                                arg_types[1][1],
+                                                arg_types[2][1])
+    when [1, 3]
+      create_validator_method_optional_args1_3(mod, original_method, method_sig, original_visibility, return_type,
+                                                arg_types[0][1],
+                                                arg_types[1][1],
+                                                arg_types[2][1])
+    when [2, 3]
+      create_validator_method_optional_args2_3(mod, original_method, method_sig, original_visibility, return_type,
+                                                arg_types[0][1],
+                                                arg_types[1][1],
+                                                arg_types[2][1])
+    when [0, 4]
+      create_validator_method_optional_args0_4(mod, original_method, method_sig, original_visibility, return_type,
+                                                arg_types[0][1],
+                                                arg_types[1][1],
+                                                arg_types[2][1],
+                                                arg_types[3][1])
+    when [1, 4]
+      create_validator_method_optional_args1_4(mod, original_method, method_sig, original_visibility, return_type,
+                                                arg_types[0][1],
+                                                arg_types[1][1],
+                                                arg_types[2][1],
+                                                arg_types[3][1])
+    when [2, 4]
+      create_validator_method_optional_args2_4(mod, original_method, method_sig, original_visibility, return_type,
+                                                arg_types[0][1],
+                                                arg_types[1][1],
+                                                arg_types[2][1],
+                                                arg_types[3][1])
+    when [3, 4]
+      create_validator_method_optional_args3_4(mod, original_method, method_sig, original_visibility, return_type,
+                                                arg_types[0][1],
+                                                arg_types[1][1],
+                                                arg_types[2][1],
+                                                arg_types[3][1])
+    else
+      raise 'should not happen'
+    end
+  end
+
+  def self.create_validator_method_optional_args0_1(mod, original_method, method_sig, original_visibility, return_type, arg0_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |*args, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless args.empty? || arg0_type.valid?(args[0])
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(args[0]),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          args[0],
+          caller_offset: -1
+        )
+      end
+      return_value = original_method.bind_call(self, *args, &blk)
+      if return_type.nil?
+        T::Private::Types::Void::VOID
+      else
+        unless return_type.valid?(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.effective_return_type,
+              return_value,
+              caller_offset: -1
+            )
+          end
+        end
+        return_value
+      end
+    end
+  end
+
+  def self.create_validator_method_optional_args0_2(mod, original_method, method_sig, original_visibility, return_type, arg0_type, arg1_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |*args, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless args.empty? || arg0_type.valid?(args[0])
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(args[0]),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          args[0],
+          caller_offset: -1
+        )
+      end
+      unless args.length <= 1 || arg1_type.valid?(args[1])
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(args[1]),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          args[1],
+          caller_offset: -1
+        )
+      end
+      return_value = original_method.bind_call(self, *args, &blk)
+      if return_type.nil?
+        T::Private::Types::Void::VOID
+      else
+        unless return_type.valid?(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.effective_return_type,
+              return_value,
+              caller_offset: -1
+            )
+          end
+        end
+        return_value
+      end
+    end
+  end
+
+  def self.create_validator_method_optional_args1_2(mod, original_method, method_sig, original_visibility, return_type, arg0_type, arg1_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |*args, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(args[0])
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(args[0]),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          args[0],
+          caller_offset: -1
+        )
+      end
+      unless args.length <= 1 || arg1_type.valid?(args[1])
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(args[1]),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          args[1],
+          caller_offset: -1
+        )
+      end
+      return_value = original_method.bind_call(self, *args, &blk)
+      if return_type.nil?
+        T::Private::Types::Void::VOID
+      else
+        unless return_type.valid?(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.effective_return_type,
+              return_value,
+              caller_offset: -1
+            )
+          end
+        end
+        return_value
+      end
+    end
+  end
+
+  def self.create_validator_method_optional_args0_3(mod, original_method, method_sig, original_visibility, return_type, arg0_type, arg1_type, arg2_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |*args, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless args.empty? || arg0_type.valid?(args[0])
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(args[0]),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          args[0],
+          caller_offset: -1
+        )
+      end
+      unless args.length <= 1 || arg1_type.valid?(args[1])
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(args[1]),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          args[1],
+          caller_offset: -1
+        )
+      end
+      unless args.length <= 2 || arg2_type.valid?(args[2])
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(args[2]),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          args[2],
+          caller_offset: -1
+        )
+      end
+      return_value = original_method.bind_call(self, *args, &blk)
+      if return_type.nil?
+        T::Private::Types::Void::VOID
+      else
+        unless return_type.valid?(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.effective_return_type,
+              return_value,
+              caller_offset: -1
+            )
+          end
+        end
+        return_value
+      end
+    end
+  end
+
+  def self.create_validator_method_optional_args1_3(mod, original_method, method_sig, original_visibility, return_type, arg0_type, arg1_type, arg2_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |*args, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(args[0])
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(args[0]),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          args[0],
+          caller_offset: -1
+        )
+      end
+      unless args.length <= 1 || arg1_type.valid?(args[1])
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(args[1]),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          args[1],
+          caller_offset: -1
+        )
+      end
+      unless args.length <= 2 || arg2_type.valid?(args[2])
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(args[2]),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          args[2],
+          caller_offset: -1
+        )
+      end
+      return_value = original_method.bind_call(self, *args, &blk)
+      if return_type.nil?
+        T::Private::Types::Void::VOID
+      else
+        unless return_type.valid?(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.effective_return_type,
+              return_value,
+              caller_offset: -1
+            )
+          end
+        end
+        return_value
+      end
+    end
+  end
+
+  def self.create_validator_method_optional_args2_3(mod, original_method, method_sig, original_visibility, return_type, arg0_type, arg1_type, arg2_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |*args, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(args[0])
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(args[0]),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          args[0],
+          caller_offset: -1
+        )
+      end
+      unless arg1_type.valid?(args[1])
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(args[1]),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          args[1],
+          caller_offset: -1
+        )
+      end
+      unless args.length <= 2 || arg2_type.valid?(args[2])
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(args[2]),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          args[2],
+          caller_offset: -1
+        )
+      end
+      return_value = original_method.bind_call(self, *args, &blk)
+      if return_type.nil?
+        T::Private::Types::Void::VOID
+      else
+        unless return_type.valid?(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.effective_return_type,
+              return_value,
+              caller_offset: -1
+            )
+          end
+        end
+        return_value
+      end
+    end
+  end
+
+  def self.create_validator_method_optional_args0_4(mod, original_method, method_sig, original_visibility, return_type, arg0_type, arg1_type, arg2_type, arg3_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |*args, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless args.empty? || arg0_type.valid?(args[0])
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(args[0]),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          args[0],
+          caller_offset: -1
+        )
+      end
+      unless args.length <= 1 || arg1_type.valid?(args[1])
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(args[1]),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          args[1],
+          caller_offset: -1
+        )
+      end
+      unless args.length <= 2 || arg2_type.valid?(args[2])
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(args[2]),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          args[2],
+          caller_offset: -1
+        )
+      end
+      unless args.length <= 3 || arg3_type.valid?(args[3])
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[3][1].error_message_for_obj(args[3]),
+          'Parameter',
+          method_sig.arg_types[3][0],
+          arg3_type,
+          args[3],
+          caller_offset: -1
+        )
+      end
+      return_value = original_method.bind_call(self, *args, &blk)
+      if return_type.nil?
+        T::Private::Types::Void::VOID
+      else
+        unless return_type.valid?(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.effective_return_type,
+              return_value,
+              caller_offset: -1
+            )
+          end
+        end
+        return_value
+      end
+    end
+  end
+
+  def self.create_validator_method_optional_args1_4(mod, original_method, method_sig, original_visibility, return_type, arg0_type, arg1_type, arg2_type, arg3_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |*args, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(args[0])
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(args[0]),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          args[0],
+          caller_offset: -1
+        )
+      end
+      unless args.length <= 1 || arg1_type.valid?(args[1])
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(args[1]),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          args[1],
+          caller_offset: -1
+        )
+      end
+      unless args.length <= 2 || arg2_type.valid?(args[2])
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(args[2]),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          args[2],
+          caller_offset: -1
+        )
+      end
+      unless args.length <= 3 || arg3_type.valid?(args[3])
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[3][1].error_message_for_obj(args[3]),
+          'Parameter',
+          method_sig.arg_types[3][0],
+          arg3_type,
+          args[3],
+          caller_offset: -1
+        )
+      end
+      return_value = original_method.bind_call(self, *args, &blk)
+      if return_type.nil?
+        T::Private::Types::Void::VOID
+      else
+        unless return_type.valid?(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.effective_return_type,
+              return_value,
+              caller_offset: -1
+            )
+          end
+        end
+        return_value
+      end
+    end
+  end
+
+  def self.create_validator_method_optional_args2_4(mod, original_method, method_sig, original_visibility, return_type, arg0_type, arg1_type, arg2_type, arg3_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |*args, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(args[0])
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(args[0]),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          args[0],
+          caller_offset: -1
+        )
+      end
+      unless arg1_type.valid?(args[1])
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(args[1]),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          args[1],
+          caller_offset: -1
+        )
+      end
+      unless args.length <= 2 || arg2_type.valid?(args[2])
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(args[2]),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          args[2],
+          caller_offset: -1
+        )
+      end
+      unless args.length <= 3 || arg3_type.valid?(args[3])
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[3][1].error_message_for_obj(args[3]),
+          'Parameter',
+          method_sig.arg_types[3][0],
+          arg3_type,
+          args[3],
+          caller_offset: -1
+        )
+      end
+      return_value = original_method.bind_call(self, *args, &blk)
+      if return_type.nil?
+        T::Private::Types::Void::VOID
+      else
+        unless return_type.valid?(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.effective_return_type,
+              return_value,
+              caller_offset: -1
+            )
+          end
+        end
+        return_value
+      end
+    end
+  end
+
+  def self.create_validator_method_optional_args3_4(mod, original_method, method_sig, original_visibility, return_type, arg0_type, arg1_type, arg2_type, arg3_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |*args, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(args[0])
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(args[0]),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          args[0],
+          caller_offset: -1
+        )
+      end
+      unless arg1_type.valid?(args[1])
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(args[1]),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          args[1],
+          caller_offset: -1
+        )
+      end
+      unless arg2_type.valid?(args[2])
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(args[2]),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          args[2],
+          caller_offset: -1
+        )
+      end
+      unless args.length <= 3 || arg3_type.valid?(args[3])
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[3][1].error_message_for_obj(args[3]),
+          'Parameter',
+          method_sig.arg_types[3][0],
+          arg3_type,
+          args[3],
+          caller_offset: -1
+        )
+      end
+      return_value = original_method.bind_call(self, *args, &blk)
+      if return_type.nil?
+        T::Private::Types::Void::VOID
+      else
+        unless return_type.valid?(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.effective_return_type,
+              return_value,
+              caller_offset: -1
+            )
+          end
+        end
+        return_value
+      end
+    end
+  end
+
 end

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

@@ -67,7 +67,9 @@ module T::Private::Methods::SignatureValidation
     super_method = signature.method.super_method
 
     if super_method && super_method.owner != signature.method.owner
-      Methods.maybe_run_sig_block_for_method(super_method)
+      # No need to run the sig block for super_method explicitly:
+      # signature_for_method forces it internally (via signature_for_key ->
+      # maybe_run_sig_block_for_key on the identical registry key).
       super_signature = Methods.signature_for_method(super_method)
 
       # If the super_method has any kwargs we can't build a
@@ -200,7 +202,10 @@ module T::Private::Methods::SignatureValidation
             "#{base_override_loc_str(signature, super_signature)}"
     end
 
-    if signature.keyrest_type.nil?
+    # The kwarg_types.empty? guard is an exact implication (an empty super
+    # kwarg set can never yield missing kwargs) that skips two fresh
+    # `.keys` arrays plus the Array#- for the common kwarg-free method.
+    if signature.keyrest_type.nil? && !super_signature.kwarg_types.empty?
       # O(nm), but n and m are tiny here
       missing_kwargs = super_signature.kwarg_names - signature.kwarg_names
       if !missing_kwargs.empty?
@@ -216,12 +221,15 @@ module T::Private::Methods::SignatureValidation
             "#{base_override_loc_str(signature, super_signature)}"
     end
 
-    # O(nm), but n and m are tiny here
-    extra_req_kwargs = signature.req_kwarg_names - super_signature.req_kwarg_names
-    if !extra_req_kwargs.empty?
-      raise "Your definition of `#{method_name}` has extra required keyword arg(s) " \
-            "#{extra_req_kwargs} relative to the method it #{mode_verb}, making it incompatible: " \
-            "#{base_override_loc_str(signature, super_signature)}"
+    # Guard on the minuend: an empty req_kwarg_names can never yield extras.
+    if !signature.req_kwarg_names.empty?
+      # O(nm), but n and m are tiny here
+      extra_req_kwargs = signature.req_kwarg_names - super_signature.req_kwarg_names
+      if !extra_req_kwargs.empty?
+        raise "Your definition of `#{method_name}` has extra required keyword arg(s) " \
+              "#{extra_req_kwargs} relative to the method it #{mode_verb}, making it incompatible: " \
+              "#{base_override_loc_str(signature, super_signature)}"
+      end
     end
 
     if super_signature.block_name && !signature.block_name
@@ -231,16 +239,33 @@ module T::Private::Methods::SignatureValidation
     end
   end
 
+  # Evaluation order matters: check_tests? must only run for a :tests-checked
+  # sig (it side-effectfully arms the @wrapped_tests_with_validation trapdoor
+  # in RuntimeLevels).
+  private_class_method def self.check_level_active?(sig)
+    sig.check_level == :always || (sig.check_level == :tests && T::Private::RuntimeLevels.check_tests?)
+  end
+
   def self.validate_override_types(signature, super_signature)
     return if signature.override_allow_incompatible == true
     return if super_signature.mode == Modes.untyped
-    return unless [signature, super_signature].all? do |sig|
-      sig.check_level == :always || (sig.check_level == :tests && T::Private::RuntimeLevels.check_tests?)
-    end
+    return unless check_level_active?(signature) && check_level_active?(super_signature)
     mode_noun = super_signature.mode == Modes.abstract ? 'implementation' : 'override'
 
     # arg types must be contravariant
-    super_signature.arg_types.zip(signature.arg_types).each_with_index do |((_super_name, super_type), (name, type)), index|
+    #
+    # An index loop avoids allocating a pair array per positional arg.
+    # Iterating to super's length is deliberate: extra override positionals
+    # go unchecked, and when the override has a rest param and fewer named
+    # args than the base, the missing positions are checked as nil name/type.
+    super_arg_types = super_signature.arg_types
+    arg_types = signature.arg_types
+    index = 0
+    while index < super_arg_types.length
+      super_type = super_arg_types.fetch(index)[1]
+      pair = arg_types[index]
+      name = pair && pair[0]
+      type = pair && pair[1]
       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" \
@@ -248,6 +273,7 @@ module T::Private::Methods::SignatureValidation
               "* #{mode_noun.capitalize}: `#{type}` (in #{signature.method_desc})\n" \
               "(The types must be contravariant.)"
       end
+      index += 1
     end
 
     # kwarg types must be contravariant

data/lib/types/types/base.rb

@@ -52,6 +52,16 @@ module T::Types
     def subtype_of?(t2)
       t1 = self
 
+      # Fast path over the isSubType mirror below: the dominant pair during
+      # override validation is two plain Simples, which match none of the
+      # branches in the walk. instance_of? (never
+      # is_a?) so that any hypothetical Simple subclass takes the full walk,
+      # and the raw subtype_of_single? result is returned unmodified
+      # (Module#<= yields nil for unrelated modules, which callers observe).
+      if t1.instance_of?(T::Types::Simple) && t2.instance_of?(T::Types::Simple)
+        return subtype_of_single?(t2)
+      end
+
       if t2.is_a?(T::Private::Types::TypeAlias)
         t2 = t2.aliased_type
       end

data/lib/types/types/typed_set.rb

@@ -3,6 +3,11 @@
 
 module T::Types
   class TypedSet < TypedEnumerable
+    # We can reference `Set` directly without a load guard: as of Ruby 3.2 it
+    # ships as a default-autoloaded constant (Ruby registers `autoload :Set,
+    # "set"`), so the first reference here transparently loads it. Ruby 3.3 --
+    # the most recently supported release -- keeps this behavior, and Ruby 3.1
+    # and earlier (which required an explicit `require "set"`) are past EOL.
     def underlying_class
       Set
     end
@@ -14,22 +19,15 @@ module T::Types
 
     # overrides Base
     def recursively_valid?(obj)
-      return false if Object.autoload?(:Set) # Set is meant to be autoloaded but not yet loaded, this value can't be a Set
-      return false unless Object.const_defined?(:Set) # Set is not loaded yet
       obj.is_a?(Set) && super
     end
 
     # overrides Base
     def valid?(obj)
-      return false if Object.autoload?(:Set) # Set is meant to be autoloaded but not yet loaded, this value can't be a Set
-      return false unless Object.const_defined?(:Set) # Set is not loaded yet
       obj.is_a?(Set)
     end
 
     def new(...)
-      # Fine for this to blow up, because hopefully if they're trying to make a
-      # Set, they don't mind putting (or already have put) a `require 'set'` in
-      # their program directly.
       Set.new(...)
     end
 
@@ -39,8 +37,6 @@ module T::Types
       end
 
       def valid?(obj)
-        return false if Object.autoload?(:Set) # Set is meant to be autoloaded but not yet loaded, this value can't be a Set
-        return false unless Object.const_defined?(:Set) # Set is not loaded yet
         obj.is_a?(Set)
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.6.13300
+  version: 0.6.13301
 platform: ruby
 authors:
 - Stripe