sorbet-runtime 0.6.13299 → 0.6.13301

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 346fdbb1a44759ff22aa86b6583474a790fb38fea59464ecee830b515521a4cf
-  data.tar.gz: 5a3a3fb1fcd5b8801ea0070631caa24a1decb95df7c9d09e506f16910ffb819b
+  metadata.gz: 11be14e5fdfd480b79b5c799ffc878c604f8cdd3c5776f5b7eb55eaf143d59ee
+  data.tar.gz: c90d13ff890616e82d414249178bbd5dfb080c7604bc5b4a5c2b706ef9fd63c7
 SHA512:
-  metadata.gz: 87b79a12e41334bee22330e734b8613515da22e3d7d1843d60584e20ff41dd0fb5ab896265e7d1434cb1d09c681ed51c603b0ae4c6c976afabbf8c18ec7021e2
-  data.tar.gz: aa62c20849e24e1453150fd7e4cf354bf36d5ee24c355a3b35a4e39d0263a2821e3c1f9cbec4521245e45b2639000441ccb85567a5558525896faae3ab62b720
+  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