sorbet-runtime 0.5.10439 → 0.5.11120

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

@@ -11,26 +11,28 @@ module T::Private::Methods::CallValidation
       raise 'Should have used create_validator_procedure_fast'
     end
     # trampoline to reduce stack frame size
-    if method_sig.arg_types.empty?
+    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)
-    elsif method_sig.arg_types.length == 1
+    when 1
       create_validator_method_fast1(mod, original_method, method_sig, original_visibility, method_sig.return_type.raw_type,
-                                    method_sig.arg_types[0][1].raw_type)
-    elsif method_sig.arg_types.length == 2
+                                    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,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type)
-    elsif method_sig.arg_types.length == 3
+                                    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,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type,
-                                    method_sig.arg_types[2][1].raw_type)
-    elsif method_sig.arg_types.length == 4
+                                    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,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type,
-                                    method_sig.arg_types[2][1].raw_type,
-                                    method_sig.arg_types[3][1].raw_type)
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type,
+                                    arg_types[2][1].raw_type,
+                                    arg_types[3][1].raw_type)
     else
       raise 'should not happen'
     end
@@ -343,26 +345,28 @@ module T::Private::Methods::CallValidation
 
   def self.create_validator_procedure_fast(mod, original_method, method_sig, original_visibility)
     # trampoline to reduce stack frame size
-    if method_sig.arg_types.empty?
+    arg_types = method_sig.arg_types
+    case arg_types.length
+    when 0
       create_validator_procedure_fast0(mod, original_method, method_sig, original_visibility)
-    elsif method_sig.arg_types.length == 1
+    when 1
       create_validator_procedure_fast1(mod, original_method, method_sig, original_visibility,
-                                    method_sig.arg_types[0][1].raw_type)
-    elsif method_sig.arg_types.length == 2
+                                    arg_types[0][1].raw_type)
+    when 2
       create_validator_procedure_fast2(mod, original_method, method_sig, original_visibility,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type)
-    elsif method_sig.arg_types.length == 3
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type)
+    when 3
       create_validator_procedure_fast3(mod, original_method, method_sig, original_visibility,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type,
-                                    method_sig.arg_types[2][1].raw_type)
-    elsif method_sig.arg_types.length == 4
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type,
+                                    arg_types[2][1].raw_type)
+    when 4
       create_validator_procedure_fast4(mod, original_method, method_sig, original_visibility,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type,
-                                    method_sig.arg_types[2][1].raw_type,
-                                    method_sig.arg_types[3][1].raw_type)
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type,
+                                    arg_types[2][1].raw_type,
+                                    arg_types[3][1].raw_type)
     else
       raise 'should not happen'
     end
@@ -608,26 +612,28 @@ module T::Private::Methods::CallValidation
       raise 'Should have used create_validator_procedure_medium'
     end
     # trampoline to reduce stack frame size
-    if method_sig.arg_types.empty?
+    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)
-    elsif method_sig.arg_types.length == 1
+    when 1
       create_validator_method_medium1(mod, original_method, method_sig, original_visibility, method_sig.return_type,
-                                    method_sig.arg_types[0][1])
-    elsif method_sig.arg_types.length == 2
+                                    arg_types[0][1])
+    when 2
       create_validator_method_medium2(mod, original_method, method_sig, original_visibility, method_sig.return_type,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1])
-    elsif method_sig.arg_types.length == 3
+                                    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,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1],
-                                    method_sig.arg_types[2][1])
-    elsif method_sig.arg_types.length == 4
+                                    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,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1],
-                                    method_sig.arg_types[2][1],
-                                    method_sig.arg_types[3][1])
+                                    arg_types[0][1],
+                                    arg_types[1][1],
+                                    arg_types[2][1],
+                                    arg_types[3][1])
     else
       raise 'should not happen'
     end
@@ -940,26 +946,28 @@ module T::Private::Methods::CallValidation
 
   def self.create_validator_procedure_medium(mod, original_method, method_sig, original_visibility)
     # trampoline to reduce stack frame size
-    if method_sig.arg_types.empty?
+    arg_types = method_sig.arg_types
+    case arg_types.length
+    when 0
       create_validator_procedure_medium0(mod, original_method, method_sig, original_visibility)
-    elsif method_sig.arg_types.length == 1
+    when 1
       create_validator_procedure_medium1(mod, original_method, method_sig, original_visibility,
-                                    method_sig.arg_types[0][1])
-    elsif method_sig.arg_types.length == 2
+                                    arg_types[0][1])
+    when 2
       create_validator_procedure_medium2(mod, original_method, method_sig, original_visibility,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1])
-    elsif method_sig.arg_types.length == 3
+                                    arg_types[0][1],
+                                    arg_types[1][1])
+    when 3
       create_validator_procedure_medium3(mod, original_method, method_sig, original_visibility,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1],
-                                    method_sig.arg_types[2][1])
-    elsif method_sig.arg_types.length == 4
+                                    arg_types[0][1],
+                                    arg_types[1][1],
+                                    arg_types[2][1])
+    when 4
       create_validator_procedure_medium4(mod, original_method, method_sig, original_visibility,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1],
-                                    method_sig.arg_types[2][1],
-                                    method_sig.arg_types[3][1])
+                                    arg_types[0][1],
+                                    arg_types[1][1],
+                                    arg_types[2][1],
+                                    arg_types[3][1])
     else
       raise 'should not happen'
     end

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

@@ -11,26 +11,28 @@ module T::Private::Methods::CallValidation
       raise 'Should have used create_validator_procedure_fast'
     end
     # trampoline to reduce stack frame size
-    if method_sig.arg_types.empty?
+    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)
-    elsif method_sig.arg_types.length == 1
+    when 1
       create_validator_method_fast1(mod, original_method, method_sig, original_visibility, method_sig.return_type.raw_type,
-                                    method_sig.arg_types[0][1].raw_type)
-    elsif method_sig.arg_types.length == 2
+                                    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,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type)
-    elsif method_sig.arg_types.length == 3
+                                    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,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type,
-                                    method_sig.arg_types[2][1].raw_type)
-    elsif method_sig.arg_types.length == 4
+                                    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,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type,
-                                    method_sig.arg_types[2][1].raw_type,
-                                    method_sig.arg_types[3][1].raw_type)
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type,
+                                    arg_types[2][1].raw_type,
+                                    arg_types[3][1].raw_type)
     else
       raise 'should not happen'
     end
@@ -343,26 +345,28 @@ module T::Private::Methods::CallValidation
 
   def self.create_validator_procedure_fast(mod, original_method, method_sig, original_visibility)
     # trampoline to reduce stack frame size
-    if method_sig.arg_types.empty?
+    arg_types = method_sig.arg_types
+    case arg_types.length
+    when 0
       create_validator_procedure_fast0(mod, original_method, method_sig, original_visibility)
-    elsif method_sig.arg_types.length == 1
+    when 1
       create_validator_procedure_fast1(mod, original_method, method_sig, original_visibility,
-                                    method_sig.arg_types[0][1].raw_type)
-    elsif method_sig.arg_types.length == 2
+                                    arg_types[0][1].raw_type)
+    when 2
       create_validator_procedure_fast2(mod, original_method, method_sig, original_visibility,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type)
-    elsif method_sig.arg_types.length == 3
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type)
+    when 3
       create_validator_procedure_fast3(mod, original_method, method_sig, original_visibility,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type,
-                                    method_sig.arg_types[2][1].raw_type)
-    elsif method_sig.arg_types.length == 4
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type,
+                                    arg_types[2][1].raw_type)
+    when 4
       create_validator_procedure_fast4(mod, original_method, method_sig, original_visibility,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type,
-                                    method_sig.arg_types[2][1].raw_type,
-                                    method_sig.arg_types[3][1].raw_type)
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type,
+                                    arg_types[2][1].raw_type,
+                                    arg_types[3][1].raw_type)
     else
       raise 'should not happen'
     end
@@ -608,26 +612,28 @@ module T::Private::Methods::CallValidation
       raise 'Should have used create_validator_procedure_medium'
     end
     # trampoline to reduce stack frame size
-    if method_sig.arg_types.empty?
+    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)
-    elsif method_sig.arg_types.length == 1
+    when 1
       create_validator_method_medium1(mod, original_method, method_sig, original_visibility, method_sig.return_type,
-                                    method_sig.arg_types[0][1])
-    elsif method_sig.arg_types.length == 2
+                                    arg_types[0][1])
+    when 2
       create_validator_method_medium2(mod, original_method, method_sig, original_visibility, method_sig.return_type,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1])
-    elsif method_sig.arg_types.length == 3
+                                    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,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1],
-                                    method_sig.arg_types[2][1])
-    elsif method_sig.arg_types.length == 4
+                                    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,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1],
-                                    method_sig.arg_types[2][1],
-                                    method_sig.arg_types[3][1])
+                                    arg_types[0][1],
+                                    arg_types[1][1],
+                                    arg_types[2][1],
+                                    arg_types[3][1])
     else
       raise 'should not happen'
     end
@@ -940,26 +946,28 @@ module T::Private::Methods::CallValidation
 
   def self.create_validator_procedure_medium(mod, original_method, method_sig, original_visibility)
     # trampoline to reduce stack frame size
-    if method_sig.arg_types.empty?
+    arg_types = method_sig.arg_types
+    case arg_types.length
+    when 0
       create_validator_procedure_medium0(mod, original_method, method_sig, original_visibility)
-    elsif method_sig.arg_types.length == 1
+    when 1
       create_validator_procedure_medium1(mod, original_method, method_sig, original_visibility,
-                                    method_sig.arg_types[0][1])
-    elsif method_sig.arg_types.length == 2
+                                    arg_types[0][1])
+    when 2
       create_validator_procedure_medium2(mod, original_method, method_sig, original_visibility,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1])
-    elsif method_sig.arg_types.length == 3
+                                    arg_types[0][1],
+                                    arg_types[1][1])
+    when 3
       create_validator_procedure_medium3(mod, original_method, method_sig, original_visibility,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1],
-                                    method_sig.arg_types[2][1])
-    elsif method_sig.arg_types.length == 4
+                                    arg_types[0][1],
+                                    arg_types[1][1],
+                                    arg_types[2][1])
+    when 4
       create_validator_procedure_medium4(mod, original_method, method_sig, original_visibility,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1],
-                                    method_sig.arg_types[2][1],
-                                    method_sig.arg_types[3][1])
+                                    arg_types[0][1],
+                                    arg_types[1][1],
+                                    arg_types[2][1],
+                                    arg_types[3][1])
     else
       raise 'should not happen'
     end

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

@@ -16,7 +16,6 @@ module T::Private::Methods
     end
 
     def initialize(mod, raw)
-      # TODO RUBYPLAT-1278 - with ruby 2.5, use kwargs here
       @decl = Declaration.new(
         mod,
         ARG_NOT_PROVIDED, # params
@@ -32,15 +31,29 @@ module T::Private::Methods
       )
     end
 
-    def params(**params)
+    def params(*unused_positional_params, **params)
       check_live!
       if !decl.params.equal?(ARG_NOT_PROVIDED)
         raise BuilderError.new("You can't call .params twice")
       end
 
+      if unused_positional_params.any?
+        some_or_only = params.any? ? "some" : "only"
+        raise BuilderError.new(<<~MSG)
+          'params' was called with #{some_or_only} positional arguments, but it needs to be called with keyword arguments.
+          The keyword arguments' keys must match the name and order of the method's parameters.
+        MSG
+      end
+
       if params.empty?
-        raise BuilderError.new("params expects keyword arguments")
+        raise BuilderError.new(<<~MSG)
+          'params' was called without any arguments, but it needs to be called with keyword arguments.
+          The keyword arguments' keys must match the name and order of the method's parameters.
+
+          Omit 'params' entirely for methods with no parameters.
+        MSG
       end
+
       decl.params = params
 
       self
@@ -66,7 +79,7 @@ module T::Private::Methods
         raise BuilderError.new("You can't call .void after calling .returns.")
       end
 
-      decl.returns = T::Private::Types::Void.new
+      decl.returns = T::Private::Types::Void::Private::INSTANCE
 
       self
     end
@@ -218,15 +231,17 @@ module T::Private::Methods
         decl.on_failure = nil
       end
       if decl.params.equal?(ARG_NOT_PROVIDED)
-        decl.params = {}
+        decl.params = FROZEN_HASH
       end
       if decl.type_parameters.equal?(ARG_NOT_PROVIDED)
-        decl.type_parameters = {}
+        decl.type_parameters = FROZEN_HASH
       end
 
       decl.finalized = true
 
       self
     end
+
+    FROZEN_HASH = {}.freeze
   end
 end

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

@@ -8,17 +8,20 @@ class T::Private::Methods::Signature
               :check_level, :parameters, :on_failure, :override_allow_incompatible,
               :defined_raw
 
+  UNNAMED_REQUIRED_PARAMETERS = [[:req]].freeze
+
   def self.new_untyped(method:, mode: T::Private::Methods::Modes.untyped, parameters: method.parameters)
-    # Using `Untyped` ensures we'll get an error if we ever try validation on these.
-    not_typed = T::Private::Types::NotTyped.new
+    # Using `NotTyped` ensures we'll get an error if we ever try validation on these.
+    not_typed = T::Private::Types::NotTyped::INSTANCE
     raw_return_type = not_typed
     # Map missing parameter names to "argN" positionally
     parameters = parameters.each_with_index.map do |(param_kind, param_name), index|
       [param_kind, param_name || "arg#{index}"]
     end
-    raw_arg_types = parameters.map do |_param_kind, param_name|
-      [param_name, not_typed]
-    end.to_h
+    raw_arg_types = {}
+    parameters.each do |_, param_name|
+      raw_arg_types[param_name] = not_typed
+    end
 
     self.new(
       method: method,
@@ -36,8 +39,6 @@ class T::Private::Methods::Signature
   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)
     @method = method
     @method_name = method_name
-    @arg_types = []
-    @kwarg_types = {}
     @block_type = nil
     @block_name = nil
     @rest_type = nil
@@ -48,8 +49,6 @@ class T::Private::Methods::Signature
     @bind = bind ? T::Utils.coerce(bind) : bind
     @mode = mode
     @check_level = check_level
-    @req_arg_count = 0
-    @req_kwarg_names = []
     @has_rest = false
     @has_keyrest = false
     @parameters = parameters
@@ -57,28 +56,40 @@ class T::Private::Methods::Signature
     @override_allow_incompatible = override_allow_incompatible
     @defined_raw = defined_raw
 
-    declared_param_names = raw_arg_types.keys
+    # Use T.untyped in lieu of T.nilable to try to avoid unnecessary allocations.
+    arg_types = T.let(nil, T.untyped)
+    kwarg_types = T.let(nil, T.untyped)
+    req_arg_count = 0
+    req_kwarg_names = T.let(nil, T.untyped)
+
     # If sig params are declared but there is a single parameter with a missing name
     # **and** the method ends with a "=", assume it is a writer method generated
     # by attr_writer or attr_accessor
-    writer_method = declared_param_names != [nil] && parameters == [[:req]] && method_name[-1] == "="
+    writer_method = !(raw_arg_types.size == 1 && raw_arg_types.key?(nil)) && parameters == UNNAMED_REQUIRED_PARAMETERS && method_name[-1] == "="
     # For writer methods, map the single parameter to the method name without the "=" at the end
     parameters = [[:req, method_name[0...-1].to_sym]] if writer_method
-    param_names = parameters.map {|_, name| name}
-    missing_names = param_names - declared_param_names
-    extra_names = declared_param_names - param_names
-    if !missing_names.empty?
+    is_name_missing = parameters.any? {|_, name| !raw_arg_types.key?(name)}
+    if is_name_missing
+      param_names = parameters.map {|_, name| name}
+      missing_names = param_names - raw_arg_types.keys
       raise "The declaration for `#{method.name}` is missing parameter(s): #{missing_names.join(', ')}"
-    end
-    if !extra_names.empty?
-      raise "The declaration for `#{method.name}` has extra parameter(s): #{extra_names.join(', ')}"
+    elsif parameters.length == raw_arg_types.size
+    else
+      param_names = parameters.map {|_, name| name}
+      has_extra_names = parameters.count {|_, name| raw_arg_types.key?(name)} < raw_arg_types.size
+      if has_extra_names
+        extra_names = raw_arg_types.keys - param_names
+        raise "The declaration for `#{method.name}` has extra parameter(s): #{extra_names.join(', ')}"
+      end
     end
 
     if parameters.size != raw_arg_types.size
       raise "The declaration for `#{method.name}` has arguments with duplicate names"
     end
+    i = 0
+    raw_arg_types.each do |type_name, raw_type|
+      param_kind, param_name = parameters[i]
 
-    parameters.zip(raw_arg_types) do |(param_kind, param_name), (type_name, raw_type)|
       if type_name != param_name
         hint = ""
         # Ruby reorders params so that required keyword arguments
@@ -92,15 +103,15 @@ class T::Private::Methods::Signature
         end
 
         raise "Parameter `#{type_name}` is declared out of order (declared as arg number " \
-              "#{declared_param_names.index(type_name) + 1}, defined in the method as arg number " \
-              "#{param_names.index(type_name) + 1}).#{hint}\nMethod: #{method_desc}"
+              "#{i + 1}, defined in the method as arg number " \
+              "#{parameters.index {|_, name| name == type_name} + 1}).#{hint}\nMethod: #{method_desc}"
       end
 
       type = T::Utils.coerce(raw_type)
 
       case param_kind
       when :req
-        if @arg_types.length > @req_arg_count
+        if (arg_types ? arg_types.length : 0) > req_arg_count
           # Note that this is actually is supported by Ruby, but it would add complexity to
           # support it here, and I'm happy to discourage its use anyway.
           #
@@ -111,14 +122,14 @@ class T::Private::Methods::Signature
           # see this error. The simplest resolution is to rename your method.
           raise "Required params after optional params are not supported in method declarations. Method: #{method_desc}"
         end
-        @arg_types << [param_name, type]
-        @req_arg_count += 1
+        (arg_types ||= []) << [param_name, type]
+        req_arg_count += 1
       when :opt
-        @arg_types << [param_name, type]
+        (arg_types ||= []) << [param_name, type]
       when :key, :keyreq
-        @kwarg_types[param_name] = type
+        (kwarg_types ||= {})[param_name] = type
         if param_kind == :keyreq
-          @req_kwarg_names << param_name
+          (req_kwarg_names ||= []) << param_name
         end
       when :block
         @block_name = param_name
@@ -134,7 +145,14 @@ class T::Private::Methods::Signature
       else
         raise "Unexpected param_kind: `#{param_kind}`. Method: #{method_desc}"
       end
+
+      i += 1
     end
+
+    @arg_types = arg_types || EMPTY_LIST
+    @kwarg_types = kwarg_types || EMPTY_HASH
+    @req_arg_count = req_arg_count
+    @req_kwarg_names = req_kwarg_names || EMPTY_LIST
   end
 
   attr_writer :method_name
@@ -179,15 +197,7 @@ class T::Private::Methods::Signature
       kwargs = EMPTY_HASH
     end
 
-    arg_types = @arg_types
-
-    if @has_rest
-      rest_count = args_length - @arg_types.length
-      rest_count = 0 if rest_count.negative?
-
-      arg_types += [[@rest_name, @rest_type]] * rest_count
-
-    elsif (args_length < @req_arg_count) || (args_length > @arg_types.length)
+    if !@has_rest && ((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}"
@@ -197,10 +207,23 @@ class T::Private::Methods::Signature
 
     begin
       it = 0
-      while it < args_length
-        yield arg_types[it][0], args[it], arg_types[it][1]
+
+      # 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]
         it += 1
       end
+
+      if @has_rest
+        rest_count = args_length - @arg_types.length
+        rest_count = 0 if rest_count.negative?
+
+        rest_count.times do
+          yield @rest_name, args[it], @rest_type
+          it += 1
+        end
+      end
     end
 
     kwargs.each do |name, val|
@@ -208,6 +231,7 @@ class T::Private::Methods::Signature
       if !type && @has_keyrest
         type = @keyrest_type
       end
+
       yield name, val, type if type
     end
   end
@@ -221,5 +245,6 @@ class T::Private::Methods::Signature
     "#{@method} at #{loc}"
   end
 
+  EMPTY_LIST = [].freeze
   EMPTY_HASH = {}.freeze
 end