rubocop 1.88.0 → 1.88.2

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

@@ -57,11 +57,15 @@ module RuboCop
         private
 
         def parentheses_required?(node, arguments_range)
-          return true if node.single_line? && !node.endless?
-
           end_pos = arguments_range.end.end_pos
           token_after_argument = range_between(end_pos, end_pos + 1).source
 
+          # A `;` after the parentheses (e.g. `def foo(); end`) already separates the
+          # signature from the body, so the parentheses can be removed (`def foo; end`).
+          return false if token_after_argument == ';'
+
+          return true if node.single_line? && !node.endless?
+
           token_after_argument == '='
         end
       end

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

@@ -35,6 +35,10 @@ module RuboCop
         PATTERN
 
         def on_send(node)
+          # A trailing block (e.g. `Dir.each_child(path).none? { ... }`) changes
+          # the meaning and is not equivalent to `Dir.empty?`.
+          return if node.block_literal?
+
           offensive?(node) do |const_node, arg_node|
             replacement = "#{bang(node)}#{const_node.source}.empty?(#{arg_node.source})"
             add_offense(node, message: format(MSG, replacement: replacement)) do |corrector|

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

@@ -140,7 +140,11 @@ module RuboCop
         end
 
         def method_allowed?(node)
-          allowed_methods.include?(node.method_name)
+          # For a modifier form like `module_function def foo; end`, `node` is the
+          # `module_function`/`ruby2_keywords` send; the real method name is on its
+          # `def`/`defs` argument, not the modifier itself.
+          method_name = node.send_type? ? node.first_argument.method_name : node.method_name
+          allowed_methods.include?(method_name)
         end
 
         def allowed_methods

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

@@ -40,7 +40,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Do not use empty `case` condition, instead use an `if` expression.'
-        NOT_SUPPORTED_PARENT_TYPES = %i[return break next send csend].freeze
+        NOT_SUPPORTED_PARENT_TYPES = %i[return break next send csend yield super].freeze
 
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_case(case_node)
@@ -90,7 +90,17 @@ module RuboCop
             range = range_between(conditions.first.source_range.begin_pos,
                                   conditions.last.source_range.end_pos)
 
-            corrector.replace(range, conditions.map(&:source).join(' || '))
+            corrector.replace(range, conditions.map { |c| parenthesize_condition(c) }.join(' || '))
+          end
+        end
+
+        # A condition that binds looser than `||` (e.g. a ternary, range, or
+        # assignment) must be parenthesized so the joined `||` keeps its meaning.
+        def parenthesize_condition(condition)
+          if condition.assignment? || condition.type?(:if, :and, :or, :range)
+            "(#{condition.source})"
+          else
+            condition.source
           end
         end
 

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

@@ -101,12 +101,19 @@ module RuboCop
 
         def autocorrect_class_new(corrector, node, class_new_node)
           indent = ' ' * node.loc.column
-          class_name = node.name
+          class_name = constant_name(node)
           parent_class_name = class_new_node.first_argument.source
 
           corrector.replace(node, "class #{class_name} < #{parent_class_name}\n#{indent}end")
         end
 
+        # Preserve any namespace on the assigned constant (e.g. `Foo::Bar`),
+        # which `node.name` drops.
+        def constant_name(node)
+          namespace = node.namespace
+          namespace ? "#{namespace.source}::#{node.name}" : node.name
+        end
+
         def autocorrect_class_definition(corrector, node)
           class_name = node.identifier.source
           parent_class_name = node.parent_class.source

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

@@ -42,6 +42,10 @@ module RuboCop
         MSG = 'Use an empty string literal instead of heredoc.'
 
         def on_heredoc(node)
+          # A backtick heredoc (`<<~`CMD``) executes a command, so it cannot be
+          # replaced with an empty string literal.
+          return if node.xstr_type?
+
           heredoc_body = node.loc.heredoc_body
 
           return unless heredoc_body.source.empty?

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

@@ -44,13 +44,18 @@ module RuboCop
         def_node_matcher :str_node, '(send (const {nil? cbase} :String) :new)'
 
         # @!method array_with_block(node)
-        def_node_matcher :array_with_block, '(block (send (const {nil? cbase} :Array) :new) args _)'
+        def_node_matcher :array_with_block, <<~PATTERN
+          {
+            (block (send (const {nil? cbase} :Array) :new) args _)
+            ({numblock itblock} (send (const {nil? cbase} :Array) :new) ...)
+          }
+        PATTERN
 
         # @!method hash_with_block(node)
         def_node_matcher :hash_with_block, <<~PATTERN
           {
             (block (send (const {nil? cbase} :Hash) :new) args _)
-            (numblock (send (const {nil? cbase} :Hash) :new) ...)
+            ({numblock itblock} (send (const {nil? cbase} :Hash) :new) ...)
           }
         PATTERN
 

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

@@ -45,36 +45,46 @@ module RuboCop
         MSG_TRAILING_CONDITIONAL = 'Do not use trailing conditionals in string interpolation.'
         MSG_TERNARY = 'Do not return empty strings in string interpolation.'
 
-        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
         def on_interpolation(node)
           node.each_child_node(:if) do |child_node|
             if style == :trailing_conditional
-              if empty_if_outcome?(child_node)
-                ternary_style_autocorrect(child_node, child_node.else_branch.source, 'unless')
-              end
-
-              if empty_else_outcome?(child_node)
-                ternary_style_autocorrect(child_node, child_node.if_branch.source, 'if')
-              end
+              trailing_conditional_correction(child_node)
             elsif style == :ternary
-              next unless child_node.modifier_form?
-
-              ternary_component = if child_node.unless?
-                                    "'' : #{child_node.if_branch.source}"
-                                  else
-                                    "#{child_node.if_branch.source} : ''"
-                                  end
-
-              add_offense(node, message: MSG_TRAILING_CONDITIONAL) do |corrector|
-                corrector.replace(node, "\#{#{child_node.condition.source} ? #{ternary_component}}")
-              end
+              ternary_correction(node, child_node)
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
 
         private
 
+        def trailing_conditional_correction(child_node)
+          # A modifier `if`/`unless` is already a trailing conditional and has
+          # no `else` branch, so the ternary-to-trailing rewrite does not apply.
+          return if child_node.modifier_form?
+
+          if empty_if_outcome?(child_node)
+            ternary_style_autocorrect(child_node, child_node.else_branch.source, 'unless')
+          end
+
+          return unless empty_else_outcome?(child_node)
+
+          ternary_style_autocorrect(child_node, child_node.if_branch.source, 'if')
+        end
+
+        def ternary_correction(node, child_node)
+          return unless child_node.modifier_form?
+
+          ternary_component = if child_node.unless?
+                                "'' : #{child_node.if_branch.source}"
+                              else
+                                "#{child_node.if_branch.source} : ''"
+                              end
+
+          add_offense(node, message: MSG_TRAILING_CONDITIONAL) do |corrector|
+            corrector.replace(node, "\#{#{child_node.condition.source} ? #{ternary_component}}")
+          end
+        end
+
         def empty_if_outcome?(node)
           empty_branch_outcome?(node.if_branch)
         end

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

@@ -45,6 +45,10 @@ module RuboCop
         def on_send(node)
           return unless env_home?(node)
           return if node.arguments.count == 2 && !node.arguments[1].nil_type?
+          # `ENV.fetch('HOME') { default }` supplies a fallback, just like
+          # `ENV.fetch('HOME', default)`. `Dir.home` ignores the block, so
+          # converting would silently drop it.
+          return if node.block_node
 
           add_offense(node) do |corrector|
             corrector.replace(node, 'Dir.home')

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

@@ -34,7 +34,7 @@ module RuboCop
           even_odd_candidate?(node) do |base_number, method, arg|
             replacement_method = replacement_method(arg, method)
             add_offense(node, message: format(MSG, method: replacement_method)) do |corrector|
-              correction = "#{base_number.source}.#{replacement_method}?"
+              correction = "#{receiver_source(base_number)}.#{replacement_method}?"
               corrector.replace(node, correction)
             end
           end
@@ -42,6 +42,16 @@ module RuboCop
 
         private
 
+        def receiver_source(node)
+          # A binary or unary operator receiver (e.g. `a * b`, `-a`) binds looser
+          # than the appended method call, so it must be wrapped in parentheses.
+          if node.send_type? && node.operator_method? && !node.method?(:[])
+            "(#{node.source})"
+          else
+            node.source
+          end
+        end
+
         def replacement_method(arg, method)
           case arg
           when 0

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

@@ -43,7 +43,8 @@ module RuboCop
           return unless (parsed_regexp = parse_regexp(regexp))
           return unless exact_match_pattern?(parsed_regexp)
 
-          prefer = "#{receiver.source} #{new_method(node)} '#{parsed_regexp[1].text}'"
+          string = escape_single_quotes(parsed_regexp[1].text)
+          prefer = "#{receiver.source} #{new_method(node)} '#{string}'"
 
           add_offense(node, message: format(MSG, prefer: prefer)) do |corrector|
             corrector.replace(node, prefer)
@@ -53,6 +54,12 @@ module RuboCop
 
         private
 
+        # Escape characters that are special inside a single-quoted string so the
+        # generated literal (e.g. for `/\Afoo'bar\z/`) stays valid Ruby.
+        def escape_single_quotes(text)
+          text.gsub(/['\\]/) { |char| "\\#{char}" }
+        end
+
         def exact_match_pattern?(parsed_regexp)
           tokens = parsed_regexp.map(&:token)
           return false unless tokens[0] == :bos && tokens[1] == :literal && tokens[2] == :eos

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

@@ -78,10 +78,12 @@ module RuboCop
 
         def acceptable?(node)
           # Using a hardcoded null device is acceptable when inside an array or
-          # inside a hash to ensure behavior doesn't change.
+          # inside a hash to ensure behavior doesn't change. A `str` that is part of
+          # an interpolated or concatenated string (`dstr`) is not a standalone null
+          # device either, and replacing it would corrupt the surrounding string.
           return false unless node.parent
 
-          node.parent.type?(:array, :pair)
+          node.parent.type?(:array, :pair, :dstr)
         end
       end
     end

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

@@ -144,10 +144,22 @@ module RuboCop
         end
 
         def format_single_parameter(arg)
+          # `format(fmt, *args)` is equivalent to `fmt % args`, so unwrap the splat
+          # and render the argument it splats.
+          return format_single_parameter(arg.children.first) if arg.splat_type?
+
           source = arg.source
           return "{ #{source} }" if arg.hash_type?
 
-          arg.send_type? && arg.operator_method? && !arg.parenthesized? ? "(#{source})" : source
+          requires_parentheses?(arg) ? "(#{source})" : source
+        end
+
+        # An argument that binds looser than `%` (a ternary, range, assignment, or
+        # operator call) must be parenthesized to keep its meaning.
+        def requires_parentheses?(arg)
+          return true if arg.assignment? || arg.type?(:if, :and, :or, :range)
+
+          arg.send_type? && arg.operator_method? && !arg.parenthesized?
         end
       end
     end

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

@@ -121,16 +121,24 @@ module RuboCop
         end
 
         def multi_argument(node)
+          # A splat argument can expand to any number of elements, so the pairs
+          # can't be built statically and there is no literal hash to suggest.
+          return if node.arguments.any?(&:splat_type?)
+
           if node.arguments.count.odd?
             add_offense(node, message: MSG_LITERAL_MULTI_ARG)
           else
-            add_offense(node, message: MSG_LITERAL_MULTI_ARG) do |corrector|
-              corrector.replace(node, args_to_hash(node.arguments))
+            correct_multi_argument(node)
+          end
+        end
 
-              parent = node.parent
-              if parent&.send_type? && !parent.method?(:to_h) && !parent.parenthesized?
-                add_parentheses(parent, corrector)
-              end
+        def correct_multi_argument(node)
+          add_offense(node, message: MSG_LITERAL_MULTI_ARG) do |corrector|
+            corrector.replace(node, args_to_hash(node.arguments))
+
+            parent = node.parent
+            if parent&.send_type? && !parent.method?(:to_h) && !parent.parenthesized?
+              add_parentheses(parent, corrector)
             end
           end
         end

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

@@ -74,7 +74,7 @@ module RuboCop
 
         def offense_for_brackets?(node)
           style == :brackets && node.receiver && node.method?(:fetch) && node.arguments.one? &&
-            !node.block_literal?
+            !node.block_literal? && !node.csend_type?
         end
 
         def offense_for_fetch?(node)
@@ -84,11 +84,7 @@ module RuboCop
         def correct_fetch_to_brackets(corrector, node)
           key = node.first_argument.source
 
-          if node.csend_type?
-            corrector.replace(node, "(#{node.receiver.source}[#{key}])")
-          else
-            corrector.replace(node.loc.dot.join(node.source_range.end), "[#{key}]")
-          end
+          corrector.replace(node.loc.dot.join(node.source_range.end), "[#{key}]")
         end
 
         def correct_brackets_to_fetch(corrector, node)

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

@@ -263,6 +263,8 @@ module RuboCop
 
           hash_node = pair_node.parent
           return unless hash_node.parent&.return_type? && !hash_node.braces?
+          # This runs once per pair, but the hash must only be wrapped once.
+          return unless pair_node.equal?(hash_node.pairs.first)
 
           corrector.wrap(hash_node, '{', '}')
         end

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

@@ -216,23 +216,34 @@ module RuboCop
         # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
         def correct_assignment(corrector, node, expression, insert_position)
+          indentation = indentation_of(node.parent)
+
           if insert_position == :after_condition
             assignment = node.parent.source_range.with(end_pos: node.source_range.begin_pos)
             corrector.remove(assignment)
-            corrector.insert_after(node, "\n#{assignment.source}#{expression.source}")
+            corrector.insert_after(node, "\n#{indentation}#{assignment.source}#{expression.source}")
           else
-            corrector.insert_before(node.parent, "#{expression.source}\n")
+            corrector.insert_before(node.parent, "#{expression.source}\n#{indentation}")
           end
         end
 
         def correct_no_assignment(corrector, node, expression, insert_position)
+          indentation = indentation_of(node)
+
           if insert_position == :after_condition
-            corrector.insert_after(node, "\n#{expression.source}")
+            corrector.insert_after(node, "\n#{indentation}#{expression.source}")
           else
-            corrector.insert_before(node, "#{expression.source}\n")
+            corrector.insert_before(node, "#{expression.source}\n#{indentation}")
           end
         end
 
+        # The leading indentation of the line the conditional starts on, so a
+        # hoisted expression keeps the surrounding nesting instead of landing
+        # at column zero.
+        def indentation_of(node)
+          ' ' * node.source_range.column
+        end
+
         def last_child_of_parent?(node)
           return true unless (parent = node.parent)
 

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

@@ -91,7 +91,7 @@ module RuboCop
 
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_if(node)
-          return if endless_method?(node.body) || node.ancestors.any?(&:dstr_type?)
+          return if endless_method?(node.body) || node.each_ancestor(:dstr).any?
 
           condition = node.condition
           return if defined_nodes(condition).any? { |n| defined_argument_is_undefined?(node, n) } ||
@@ -119,7 +119,7 @@ module RuboCop
           if condition.defined_type?
             [condition]
           else
-            condition.each_descendant.select(&:defined_type?)
+            condition.each_descendant(:defined?)
           end
         end
 
@@ -137,7 +137,7 @@ module RuboCop
           if condition.any_match_pattern_type?
             [condition]
           else
-            condition.each_descendant.select(&:any_match_pattern_type?)
+            condition.each_descendant(:any_match_pattern)
           end
         end
 
@@ -350,7 +350,7 @@ module RuboCop
         end
 
         def comment_on_node_line(node)
-          processed_source.comments.find { |c| same_line?(c, node) }
+          processed_source.comment_at_line(node.first_line)
         end
 
         def remove_comment(corrector, _node, comment)

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

@@ -82,7 +82,7 @@ module RuboCop
 
           then_code, else_code = else_code, then_code if node.unless?
 
-          "#{node.condition.source} ? #{then_code} : #{else_code}"
+          "#{ternary_condition(node)} ? #{then_code} : #{else_code}"
         end
 
         def correct_elsif(node)
@@ -103,6 +103,14 @@ module RuboCop
           "#{method.source}(#{arguments.source})"
         end
 
+        # An assignment used as the condition must be parenthesized, otherwise the
+        # assignment would capture the whole ternary (`a = b ? c : d` instead of
+        # `(a = b) ? c : d`), changing what gets assigned.
+        def ternary_condition(node)
+          condition = node.condition
+          condition.assignment? ? "(#{condition.source})" : condition.source
+        end
+
         def build_else_branch(second_condition)
           result = <<~RUBY
             elsif #{second_condition.condition.source}

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

@@ -26,7 +26,7 @@ module RuboCop
         def on_new_investigation
           processed_source.comments.each do |comment|
             next if comment_line?(processed_source[comment.loc.line - 1]) ||
-                    comment.text.match?(/\A# rubocop:(enable|disable)/)
+                    comment.text.match?(/\A# rubocop:(enable|disable|todo)/)
 
             add_offense(comment)
           end

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

@@ -75,7 +75,9 @@ module RuboCop
         def invertible?(node) # rubocop:disable Metrics/CyclomaticComplexity
           case node&.type
           when :begin
-            invertible?(node.children.first)
+            # A multi-statement `begin` evaluates to its last expression, so it
+            # cannot be inverted by negating a single child.
+            node.children.one? && invertible?(node.children.first)
           when :send
             return false if inheritance_check?(node)
 
@@ -124,12 +126,17 @@ module RuboCop
         end
 
         def preferred_logical_condition(node)
-          preferred_lhs = preferred_condition(node.lhs)
-          preferred_rhs = preferred_condition(node.rhs)
+          preferred_lhs = preferred_operand(node, node.lhs)
+          preferred_rhs = preferred_operand(node, node.rhs)
 
           "#{preferred_lhs} #{node.inverse_operator} #{preferred_rhs}"
         end
 
+        def preferred_operand(node, operand)
+          preferred = preferred_condition(operand)
+          parenthesize_inverted_operand?(node, operand) ? "(#{preferred})" : preferred
+        end
+
         def autocorrect(corrector, node)
           case node.type
           when :begin
@@ -138,11 +145,24 @@ module RuboCop
             autocorrect_send_node(corrector, node)
           when :or, :and
             corrector.replace(node.loc.operator, node.inverse_operator)
-            autocorrect(corrector, node.lhs)
-            autocorrect(corrector, node.rhs)
+            autocorrect_operand(corrector, node, node.lhs)
+            autocorrect_operand(corrector, node, node.rhs)
           end
         end
 
+        def autocorrect_operand(corrector, node, operand)
+          autocorrect(corrector, operand)
+          corrector.wrap(operand, '(', ')') if parenthesize_inverted_operand?(node, operand)
+        end
+
+        # When an `and` is nested in an `or`, inverting both operators turns the
+        # `and` into an `or` that now binds looser than its parent, so it must be
+        # parenthesized to keep the original grouping (`a && b || c` inverts to
+        # `(!a || !b) && !c`, not `!a || !b && !c`).
+        def parenthesize_inverted_operand?(node, operand)
+          node.or_type? && operand.and_type?
+        end
+
         def autocorrect_send_node(corrector, node)
           if node.method?(:!)
             corrector.remove(node.loc.selector)

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

@@ -37,6 +37,10 @@ module RuboCop
           return unless (ancestor = node.parent&.parent)
 
           merge_kwargs?(ancestor) do |merge_node, hash_node, other_hash_node|
+            # A block-pass argument (e.g. `merge(other, &block)`) has no keyword
+            # equivalent, so spreading it would produce invalid Ruby (`**&block`).
+            next if other_hash_node.any?(&:block_pass_type?)
+
             add_offense(merge_node) do |corrector|
               autocorrect(corrector, node, hash_node, other_hash_node)
             end

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

@@ -62,11 +62,15 @@ module RuboCop
         end
 
         def append_newline_to_last_kwoptarg(arguments, corrector)
-          last_argument = arguments.last
-          return if last_argument.type?(:kwrestarg, :blockarg)
+          # The newline only needs restoring when the moved keyword argument was
+          # the last parameter, so removing it also consumes the line break before
+          # the body. When a `kwoptarg` already trails the list, the body stays
+          # separated and inserting a newline would leave a spurious blank line.
+          return unless arguments.last.kwarg_type?
+          return if arguments.parent.block_type?
 
           last_kwoptarg = arguments.reverse.find(&:kwoptarg_type?)
-          corrector.insert_after(last_kwoptarg, "\n") unless arguments.parent.block_type?
+          corrector.insert_after(last_kwoptarg, "\n")
         end
 
         def remove_kwargs(kwarg_nodes, corrector)

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

@@ -118,7 +118,13 @@ module RuboCop
         end
 
         def lambda_arg_string(args)
-          args.children.map(&:source).join(', ')
+          # Block-local (shadow) arguments are separated from regular arguments by a
+          # `;`; joining everything with `,` would turn them into extra parameters
+          # and change the lambda's arity.
+          regular, shadow = args.children.partition { |arg| !arg.shadowarg_type? }
+          arg_string = regular.map(&:source).join(', ')
+          arg_string += "; #{shadow.map(&:source).join(', ')}" unless shadow.empty?
+          arg_string
         end
       end
     end

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

@@ -27,6 +27,9 @@ module RuboCop
 
         def on_send(node)
           return unless node.receiver
+          # Rewriting the call rebuilds it as a single expression, which would drop
+          # any comments inside the argument list, so leave it to be fixed manually.
+          return if comments_in_node?(node)
 
           if offense?(node)
             prefer = prefer(node)
@@ -48,6 +51,14 @@ module RuboCop
 
         private
 
+        def comments_in_node?(node)
+          range = node.source_range
+          processed_source.comments.any? do |comment|
+            range.begin_pos <= comment.source_range.begin_pos &&
+              comment.source_range.end_pos <= range.end_pos
+          end
+        end
+
         def offense?(node)
           (explicit_style? && node.implicit_call?) || (implicit_style? && !node.implicit_call?)
         end

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

@@ -6,6 +6,17 @@ module RuboCop
       # Prefer `select` or `reject` over `map { ... }.compact`.
       # This cop also handles `filter_map { ... }`, similar to `map { ... }.compact`.
       #
+      # @safety
+      #   This cop is unsafe because `compact` also removes `nil` elements that
+      #   were already present in the receiver, whereas `select`/`reject` keep
+      #   them. The result therefore differs when the collection contains `nil`:
+      #
+      #   [source,ruby]
+      #   ----
+      #   [nil, 1].map { |e| e if e }.compact # => [1]
+      #   [nil, 1].select { |e| e }           # => [nil, 1]
+      #   ----
+      #
       # @example
       #
       #   # bad

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

@@ -65,7 +65,7 @@ module RuboCop
 
         # @!method suitable_argument_node?(node)
         def_node_matcher :suitable_argument_node?, <<-PATTERN
-          !{splat forwarded-restarg forwarded-args (hash (forwarded-kwrestarg)) (block-pass nil?)}
+          !{splat forwarded-restarg forwarded-args (hash (forwarded-kwrestarg)) block-pass}
         PATTERN
 
         # @!method each_block_with_push?(node)