rubocop 1.62.1 → 1.67.0

data/lib/rubocop/cop/naming/accessor_method_name.rb

@@ -40,6 +40,7 @@ module RuboCop
         MSG_WRITER = 'Do not prefix writer method names with `set_`.'
 
         def on_def(node)
+          return unless proper_attribute_name?(node)
           return unless bad_reader_name?(node) || bad_writer_name?(node)
 
           message = message(node)
@@ -58,6 +59,10 @@ module RuboCop
           end
         end
 
+        def proper_attribute_name?(node)
+          !node.method_name.to_s.end_with?('!', '?', '=')
+        end
+
         def bad_reader_name?(node)
           node.method_name.to_s.start_with?('get_') && !node.arguments?
         end

data/lib/rubocop/cop/naming/block_forwarding.rb

@@ -51,29 +51,25 @@ module RuboCop
           [Lint::AmbiguousOperator, Style::ArgumentsForwarding]
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity
         def on_def(node)
           return if node.arguments.empty?
 
           last_argument = node.last_argument
           return if expected_block_forwarding_style?(node, last_argument)
 
-          invalid_syntax = false
-          node.each_descendant(:block_pass) do |block_pass_node|
-            next if block_pass_node.children.first&.sym_type? ||
-                    last_argument.source != block_pass_node.source
+          forwarded_args = node.each_descendant(:block_pass).with_object([]) do |block_pass, result|
+            return nil if invalidates_syntax?(block_pass)
+            next unless block_argument_name_matched?(block_pass, last_argument)
 
-            if block_pass_node.each_ancestor(:block, :numblock).any?
-              invalid_syntax = true
-              next
-            end
+            result << block_pass
+          end
 
-            register_offense(block_pass_node, node)
+          forwarded_args.each do |forwarded_arg|
+            register_offense(forwarded_arg, node)
           end
 
-          register_offense(last_argument, node) unless invalid_syntax
+          register_offense(last_argument, node)
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
         alias on_defs on_def
 
         private
@@ -88,6 +84,29 @@ module RuboCop
           end
         end
 
+        def block_argument_name_matched?(block_pass_node, last_argument)
+          return false if block_pass_node.children.first&.sym_type?
+
+          last_argument.source == block_pass_node.source
+        end
+
+        # Prevents the following syntax error:
+        #
+        # # foo.rb
+        # def foo(&)
+        #   block_method do
+        #     bar(&)
+        #   end
+        # end
+        #
+        # $ ruby -vc foo.rb
+        # ruby 3.3.0 (2023-12-25 revision 5124f9ac75) [x86_64-darwin22]
+        # foo.rb: foo.rb:4: anonymous block parameter is also used within block (SyntaxError)
+        #
+        def invalidates_syntax?(block_pass_node)
+          block_pass_node.each_ancestor(:block, :numblock).any?
+        end
+
         def use_kwarg_in_method_definition?(node)
           node.arguments.each_descendant(:kwarg, :kwoptarg).any?
         end

data/lib/rubocop/cop/naming/file_name.rb

@@ -57,7 +57,7 @@ module RuboCop
           file_path = processed_source.file_path
           return if config.file_to_exclude?(file_path) || config.allowed_camel_case_file?(file_path)
 
-          for_bad_filename(file_path) { |range, msg| add_offense(range, message: msg) }
+          for_bad_filename(file_path)
         end
 
         private
@@ -71,7 +71,7 @@ module RuboCop
             msg = other_message(basename) unless bad_filename_allowed?
           end
 
-          yield source_range(processed_source.buffer, 1, 0), msg if msg
+          add_global_offense(msg) if msg
         end
 
         def perform_class_and_module_naming_checks(file_path, basename)

data/lib/rubocop/cop/naming/inclusive_language.rb

@@ -116,9 +116,9 @@ module RuboCop
             add_offense(range, message: create_message(word)) do |corrector|
               suggestions = find_flagged_term(word)['Suggestions']
 
-              next unless suggestions.is_a?(String)
-
-              corrector.replace(range, suggestions)
+              if (preferred_term = preferred_sole_term(suggestions))
+                corrector.replace(range, preferred_term)
+              end
             end
           end
         end
@@ -157,6 +157,15 @@ module RuboCop
           set_regexes(flagged_term_strings, allowed_strings)
         end
 
+        def preferred_sole_term(suggestions)
+          case suggestions
+          when Array
+            suggestions.one? && preferred_sole_term(suggestions.first)
+          when String
+            suggestions
+          end
+        end
+
         def extract_regexp(term, term_definition)
           return term_definition['Regex'] if term_definition['Regex']
           return /(?:\b|(?<=[\W_]))#{term}(?:\b|(?=[\W_]))/ if term_definition['WholeWord']
@@ -207,8 +216,7 @@ module RuboCop
             message = create_multiple_word_message_for_file(words)
           end
 
-          range = source_range(processed_source.buffer, 1, 0)
-          add_offense(range, message: message)
+          add_global_offense(message)
         end
 
         def create_single_word_message_for_file(word)

data/lib/rubocop/cop/naming/predicate_name.rb

@@ -3,59 +3,75 @@
 module RuboCop
   module Cop
     module Naming
-      # Checks that predicate methods names end with a question mark and
+      # Checks that predicate method names end with a question mark and
       # do not start with a forbidden prefix.
       #
-      # A method is determined to be a predicate method if its name starts
-      # with one of the prefixes defined in the `NamePrefix` configuration.
-      # You can change what prefixes are considered by changing this option.
-      # Any method name that starts with one of these prefixes is required by
-      # the cop to end with a `?`. Other methods can be allowed by adding to
-      # the `AllowedMethods` configuration.
+      # A method is determined to be a predicate method if its name starts with
+      # one of the prefixes listed in the `NamePrefix` configuration. The list
+      # defaults to `is_`, `has_`, and `have_` but may be overridden.
       #
-      # NOTE: The `is_a?` method is allowed by default.
+      # Predicate methods must end with a question mark.
       #
-      # If `ForbiddenPrefixes` is set, methods that start with the configured
-      # prefixes will not be allowed and will be removed by autocorrection.
+      # When `ForbiddenPrefixes` is also set (as it is by default), predicate
+      # methods which begin with a forbidden prefix are not allowed, even if
+      # they end with a `?`. These methods should be changed to remove the
+      # prefix.
       #
-      # In other words, if `ForbiddenPrefixes` is empty, a method named `is_foo`
-      # will register an offense only due to the lack of question mark (and will be
-      # autocorrected to `is_foo?`). If `ForbiddenPrefixes` contains `is_`,
-      # `is_foo` will register an offense both because the ? is missing and because of
-      # the `is_` prefix, and will be corrected to `foo?`.
-      #
-      # NOTE: `ForbiddenPrefixes` is only applied to prefixes in `NamePrefix`;
-      # a prefix in the former but not the latter will not be considered by
-      # this cop.
-      #
-      # @example
+      # @example NamePrefix: ['is_', 'has_', 'have_'] (default)
       #   # bad
       #   def is_even(value)
       #   end
       #
-      #   def is_even?(value)
+      #   # When ForbiddenPrefixes: ['is_', 'has_', 'have_'] (default)
+      #   # good
+      #   def even?(value)
       #   end
       #
+      #   # When ForbiddenPrefixes: []
       #   # good
-      #   def even?(value)
+      #   def is_even?(value)
       #   end
       #
+      # @example NamePrefix: ['seems_to_be_']
       #   # bad
-      #   def has_value
+      #   def seems_to_be_even(value)
       #   end
       #
-      #   def has_value?
+      #   # When ForbiddenPrefixes: ['seems_to_be_']
+      #   # good
+      #   def even?(value)
       #   end
       #
+      #   # When ForbiddenPrefixes: []
       #   # good
-      #   def value?
+      #   def seems_to_be_even?(value)
       #   end
       #
       # @example AllowedMethods: ['is_a?'] (default)
+      #   # Despite starting with the `is_` prefix, this method is allowed
       #   # good
       #   def is_a?(value)
       #   end
       #
+      # @example AllowedMethods: ['is_even?']
+      #   # good
+      #   def is_even?(value)
+      #   end
+      #
+      # @example MethodDefinitionMacros: ['define_method', 'define_singleton_method'] (default)
+      #   # bad
+      #   define_method(:is_even) { |value| }
+      #
+      #   # good
+      #   define_method(:even?) { |value| }
+      #
+      # @example MethodDefinitionMacros: ['def_node_matcher']
+      #   # bad
+      #   def_node_matcher(:is_even) { |value| }
+      #
+      #   # good
+      #   def_node_matcher(:even?) { |value| }
+      #
       class PredicateName < Base
         include AllowedMethods
 
@@ -72,7 +88,7 @@ module RuboCop
               next if allowed_method_name?(method_name.to_s, prefix)
 
               add_offense(
-                node.first_argument.source_range,
+                node.first_argument,
                 message: message(method_name, expected_name(method_name.to_s, prefix))
               )
             end
@@ -93,6 +109,16 @@ module RuboCop
         end
         alias on_defs on_def
 
+        def validate_config
+          forbidden_prefixes.each do |forbidden_prefix|
+            next if predicate_prefixes.include?(forbidden_prefix)
+
+            raise ValidationError, <<~MSG.chomp
+              The `Naming/PredicateName` cop is misconfigured. Prefix #{forbidden_prefix} must be included in NamePrefix because it is included in ForbiddenPrefixes.
+            MSG
+          end
+        end
+
         private
 
         def allowed_method_name?(method_name, prefix)

data/lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb

@@ -113,13 +113,21 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def correct_node(corrector, node, offending_name, preferred_name)
           return unless node
 
           node.each_node(:lvar, :lvasgn, :masgn) do |child_node|
             next unless variable_name_matches?(child_node, offending_name)
 
-            corrector.replace(child_node, preferred_name) if child_node.lvar_type?
+            if child_node.lvar_type?
+              parent_node = child_node.parent
+              if parent_node.respond_to?(:value_omission?) && parent_node.value_omission?
+                corrector.insert_after(parent_node.loc.operator, " #{preferred_name}")
+              else
+                corrector.replace(child_node, preferred_name)
+              end
+            end
 
             if child_node.masgn_type? || child_node.lvasgn_type?
               correct_reassignment(corrector, child_node, offending_name, preferred_name)
@@ -127,6 +135,7 @@ module RuboCop
             end
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
         # If the exception variable is reassigned, that assignment needs to be corrected.
         # Further `lvar` nodes will not be corrected though since they now refer to a

data/lib/rubocop/cop/offense.rb

@@ -97,8 +97,8 @@ module RuboCop
       # @!attribute [r] correctable?
       #
       # @return [Boolean]
-      #   whether this offense can be automatically corrected via
-      #   autocorrect or a todo.
+      #   whether this offense can be automatically corrected via autocorrect.
+      #   This includes todo comments, for example when requested with `--disable-uncorrectable`.
       def correctable?
         @status != :unsupported
       end

data/lib/rubocop/cop/security/compound_hash.rb

@@ -30,8 +30,8 @@ module RuboCop
       class CompoundHash < Base
         COMBINATOR_IN_HASH_MSG = 'Use `[...].hash` instead of combining hash values manually.'
         MONUPLE_HASH_MSG =
-          'Delegate hash directly without wrapping in an array when only using a single value'
-        REDUNDANT_HASH_MSG = 'Calling .hash on elements of a hashed array is redundant'
+          'Delegate hash directly without wrapping in an array when only using a single value.'
+        REDUNDANT_HASH_MSG = 'Calling .hash on elements of a hashed array is redundant.'
 
         # @!method hash_method_definition?(node)
         def_node_matcher :hash_method_definition?, <<~PATTERN

data/lib/rubocop/cop/style/access_modifier_declarations.rb

@@ -8,6 +8,17 @@ module RuboCop
       # EnforcedStyle config covers only method definitions.
       # Applications of visibility methods to symbols can be controlled
       # using AllowModifiersOnSymbols config.
+      # Also, the visibility of `attr*` methods can be controlled using
+      # AllowModifiersOnAttrs config.
+      #
+      # In Ruby 3.0, `attr*` methods now return an array of defined method names
+      # as symbols. So we can write the modifier and `attr*` in inline style.
+      # AllowModifiersOnAttrs config allows `attr*` methods to be written in
+      # inline style without modifying applications that have been maintained
+      # for a long time in group style. Furthermore, developers who are not very
+      # familiar with Ruby may know that the modifier applies to `def`, but they
+      # may not know that it also applies to `attr*` methods. It would be easier
+      # to understand if we could write `attr*` methods in inline style.
       #
       # @safety
       #   Autocorrection is not safe, because the visibility of dynamically
@@ -57,6 +68,8 @@ module RuboCop
       #   class Foo
       #
       #     private :bar, :baz
+      #     private *%i[qux quux]
+      #     private *METHOD_NAMES
       #
       #   end
       #
@@ -65,6 +78,36 @@ module RuboCop
       #   class Foo
       #
       #     private :bar, :baz
+      #     private *%i[qux quux]
+      #     private *METHOD_NAMES
+      #
+      #   end
+      #
+      # @example AllowModifiersOnAttrs: true (default)
+      #   # good
+      #   class Foo
+      #
+      #     public attr_reader :bar
+      #     protected attr_writer :baz
+      #     private attr_accessor :qux
+      #     private attr :quux
+      #
+      #     def public_method; end
+      #
+      #     private
+      #
+      #     def private_method; end
+      #
+      #   end
+      #
+      # @example AllowModifiersOnAttrs: false
+      #   # bad
+      #   class Foo
+      #
+      #     public attr_reader :bar
+      #     protected attr_writer :baz
+      #     private attr_accessor :qux
+      #     private attr :quux
       #
       #   end
       class AccessModifierDeclarations < Base
@@ -89,13 +132,22 @@ module RuboCop
 
         # @!method access_modifier_with_symbol?(node)
         def_node_matcher :access_modifier_with_symbol?, <<~PATTERN
-          (send nil? {:private :protected :public :module_function} (sym _))
+          (send nil? {:private :protected :public :module_function}
+            {(sym _) (splat {#percent_symbol_array? const})}
+          )
+        PATTERN
+
+        # @!method access_modifier_with_attr?(node)
+        def_node_matcher :access_modifier_with_attr?, <<~PATTERN
+          (send nil? {:private :protected :public :module_function}
+            (send nil? {:attr :attr_reader :attr_writer :attr_accessor} _))
         PATTERN
 
         def on_send(node)
           return unless node.access_modifier?
           return if ALLOWED_NODE_TYPES.include?(node.parent&.type)
           return if allow_modifiers_on_symbols?(node)
+          return if allow_modifiers_on_attrs?(node)
 
           if offense?(node)
             add_offense(node.loc.selector) do |corrector|
@@ -124,10 +176,18 @@ module RuboCop
           end
         end
 
+        def percent_symbol_array?(node)
+          node.array_type? && node.percent_literal?(:symbol)
+        end
+
         def allow_modifiers_on_symbols?(node)
           cop_config['AllowModifiersOnSymbols'] && access_modifier_with_symbol?(node)
         end
 
+        def allow_modifiers_on_attrs?(node)
+          cop_config['AllowModifiersOnAttrs'] && access_modifier_with_attr?(node)
+        end
+
         def offense?(node)
           (group_style? && access_modifier_is_inlined?(node) &&
             !right_siblings_same_inline_method?(node)) ||
@@ -168,7 +228,7 @@ module RuboCop
 
         def find_corresponding_def_node(node)
           if access_modifier_with_symbol?(node)
-            method_name = node.first_argument.value
+            method_name = node.first_argument.respond_to?(:value) && node.first_argument.value
             node.parent.each_child_node(:def).find do |child|
               child.method?(method_name)
             end

data/lib/rubocop/cop/style/accessor_grouping.rb

@@ -10,6 +10,9 @@ module RuboCop
       # NOTE: If there is a method call before the accessor method it is always allowed
       # as it might be intended like Sorbet.
       #
+      # NOTE: If there is a RBS::Inline annotation comment just after the accessor method
+      # it is always allowed.
+      #
       # @example EnforcedStyle: grouped (default)
       #   # bad
       #   class Foo
@@ -92,7 +95,7 @@ module RuboCop
           comment_line?(processed_source[node.first_line - 2])
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def groupable_accessor?(node)
           return true unless (previous_expression = node.left_siblings.last)
 
@@ -105,11 +108,16 @@ module RuboCop
 
           return true unless previous_expression.send_type?
 
+          # Accessors with RBS::Inline annotations shouldn't be groupable.
+          return false if processed_source.comments.any? do |c|
+            same_line?(c, previous_expression) && c.text.start_with?('#:')
+          end
+
           previous_expression.attribute_accessor? ||
             previous_expression.access_modifier? ||
             node.first_line - previous_expression.last_line > 1 # there is a space between nodes
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def class_send_elements(class_node)
           class_def = class_node.body

data/lib/rubocop/cop/style/alias.rb

@@ -41,6 +41,7 @@ module RuboCop
         def on_send(node)
           return unless node.command?(:alias_method)
           return unless style == :prefer_alias && alias_keyword_possible?(node)
+          return unless node.arguments.count == 2
 
           msg = format(MSG_ALIAS_METHOD, current: lexical_scope_type(node))
           add_offense(node.loc.selector, message: msg) do |corrector|
@@ -79,7 +80,7 @@ module RuboCop
         def alias_method_possible?(node)
           scope_type(node) != :instance_eval &&
             node.children.none?(&:gvar_type?) &&
-            node&.parent&.type != :def
+            node.each_ancestor(:def).none?
         end
 
         def add_offense_for_args(node, &block)

data/lib/rubocop/cop/style/arguments_forwarding.rb

@@ -29,6 +29,8 @@ module RuboCop
       #
       # Names not on this list are likely to be meaningful and are allowed by default.
       #
+      # This cop handles not only method forwarding but also forwarding to `super`.
+      #
       # @example
       #   # bad
       #   def foo(*args, &block)
@@ -146,7 +148,7 @@ module RuboCop
 
           restarg, kwrestarg, blockarg = extract_forwardable_args(node.arguments)
           forwardable_args = redundant_forwardable_named_args(restarg, kwrestarg, blockarg)
-          send_nodes = node.each_descendant(:send).to_a
+          send_nodes = node.each_descendant(:send, :csend, :super, :yield).to_a
 
           send_classifications = classify_send_nodes(
             node, send_nodes, non_splat_or_block_pass_lvar_references(node.body), forwardable_args
@@ -178,7 +180,8 @@ module RuboCop
         end
 
         def only_forwards_all?(send_classifications)
-          send_classifications.all? { |_, c, _, _| c == :all }
+          all_classifications = %i[all all_anonymous].freeze
+          send_classifications.all? { |_, c, _, _| all_classifications.include?(c) }
         end
 
         # rubocop:disable Metrics/MethodLength
@@ -186,8 +189,8 @@ module RuboCop
           _rest_arg, _kwrest_arg, block_arg = *forwardable_args
           registered_block_arg_offense = false
 
-          send_classifications.each do |send_node, _c, forward_rest, forward_kwrest, forward_block_arg| # rubocop:disable Layout/LineLength
-            if !forward_rest && !forward_kwrest
+          send_classifications.each do |send_node, c, forward_rest, forward_kwrest, forward_block_arg| # rubocop:disable Layout/LineLength
+            if !forward_rest && !forward_kwrest && c != :all_anonymous
               # Prevents `anonymous block parameter is also used within block (SyntaxError)` occurs
               # in Ruby 3.3.0.
               if outside_block?(forward_block_arg)
@@ -211,6 +214,7 @@ module RuboCop
         # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         def add_post_ruby_32_offenses(def_node, send_classifications, forwardable_args)
           return unless use_anonymous_forwarding?
+          return if send_inside_block?(send_classifications)
 
           rest_arg, kwrest_arg, block_arg = *forwardable_args
 
@@ -312,7 +316,8 @@ module RuboCop
         end
 
         def register_forward_block_arg_offense(add_parens, def_arguments_or_send, block_arg)
-          return if target_ruby_version <= 3.0 || block_arg.source == '&' || explicit_block_name?
+          return if target_ruby_version <= 3.0 ||
+                    block_arg.nil? || block_arg.source == '&' || explicit_block_name?
 
           add_offense(block_arg, message: BLOCK_MSG) do |corrector|
             add_parens_if_missing(def_arguments_or_send, corrector) if add_parens
@@ -331,13 +336,18 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/AbcSize
         def arguments_range(node, first_node)
-          arguments = node.arguments.reject { |arg| ADDITIONAL_ARG_TYPES.include?(arg.type) }
+          arguments = node.arguments.reject do |arg|
+            next true if ADDITIONAL_ARG_TYPES.include?(arg.type) || arg.variable? || arg.call_type?
 
-          start_node = first_node || arguments.first
+            arg.literal? && arg.each_descendant(:kwsplat).none?
+          end
 
-          range_between(start_node.source_range.begin_pos, arguments.last.source_range.end_pos)
+          start_node = first_node || arguments.first
+          start_node.source_range.begin.join(arguments.last.source_range.end)
         end
+        # rubocop:enable Metrics/AbcSize
 
         def allow_only_rest_arguments?
           cop_config.fetch('AllowOnlyRestArgument', true)
@@ -347,8 +357,15 @@ module RuboCop
           cop_config.fetch('UseAnonymousForwarding', false)
         end
 
+        def send_inside_block?(send_classifications)
+          send_classifications.any? do |send_node, *|
+            send_node.each_ancestor(:block, :numblock).any?
+          end
+        end
+
         def add_parens_if_missing(node, corrector)
           return if parentheses?(node)
+          return if node.send_type? && node.method?(:[])
 
           add_parentheses(node, corrector)
         end
@@ -366,6 +383,23 @@ module RuboCop
           # @!method forwarded_block_arg?(node, block_name)
           def_node_matcher :forwarded_block_arg?, '(block_pass {(lvar %1) nil?})'
 
+          # @!method def_all_anonymous_args?(node)
+          def_node_matcher :def_all_anonymous_args?, <<~PATTERN
+            (
+              def _
+              (args ... (restarg) (kwrestarg) (blockarg nil?))
+              _
+            )
+          PATTERN
+
+          # @!method send_all_anonymous_args?(node)
+          def_node_matcher :send_all_anonymous_args?, <<~PATTERN
+            (
+              send _ _
+              ... (forwarded_restarg) (hash (forwarded_kwrestarg)) (block_pass nil?)
+            )
+          PATTERN
+
           def initialize(def_node, send_node, referenced_lvars, forwardable_args, **config)
             @def_node = def_node
             @send_node = send_node
@@ -397,7 +431,9 @@ module RuboCop
           def classification
             return nil unless forwarded_rest_arg || forwarded_kwrest_arg || forwarded_block_arg
 
-            if can_forward_all?
+            if ruby_32_only_anonymous_forwarding?
+              :all_anonymous
+            elsif can_forward_all?
               :all
             else
               :rest_or_kwrest
@@ -406,16 +442,28 @@ module RuboCop
 
           private
 
+          # rubocop:disable Metrics/CyclomaticComplexity
           def can_forward_all?
             return false if any_arg_referenced?
-            return false if ruby_32_missing_rest_or_kwest?
+            return false if ruby_30_or_lower_optarg?
+            return false if ruby_32_or_higher_missing_rest_or_kwest?
             return false unless offensive_block_forwarding?
             return false if additional_kwargs_or_forwarded_kwargs?
 
             no_additional_args? || (target_ruby_version >= 3.0 && no_post_splat_args?)
           end
+          # rubocop:enable Metrics/CyclomaticComplexity
+
+          # def foo(a = 41, ...) is a syntax error in 3.0.
+          def ruby_30_or_lower_optarg?
+            target_ruby_version <= 3.0 && @def_node.arguments.any?(&:optarg_type?)
+          end
+
+          def ruby_32_only_anonymous_forwarding?
+            def_all_anonymous_args?(@def_node) && send_all_anonymous_args?(@send_node)
+          end
 
-          def ruby_32_missing_rest_or_kwest?
+          def ruby_32_or_higher_missing_rest_or_kwest?
             target_ruby_version >= 3.2 && !forwarded_rest_and_kwrest_args
           end