rubocop 1.56.0 → 1.57.0

data/lib/rubocop/cop/layout/space_inside_parens.rb

@@ -168,7 +168,7 @@ module RuboCop
           # follows, and that the rules for space inside don't apply.
           return true if token2.comment?
 
-          true unless same_line?(token1, token2) && !token1.space_after?
+          !same_line?(token1, token2) || token1.space_after?
         end
       end
     end

data/lib/rubocop/cop/lint/debugger.rb

@@ -95,8 +95,11 @@ module RuboCop
         def assumed_usage_context?(node)
           # Basically, debugger methods are not used as a method argument without arguments.
           return false unless node.arguments.empty? && node.each_ancestor(:send, :csend).any?
+          return true if assumed_argument?(node)
 
-          node.each_ancestor.none?(&:lambda_or_proc?)
+          node.each_ancestor.none? do |ancestor|
+            ancestor.block_type? || ancestor.numblock_type? || ancestor.lambda_or_proc?
+          end
         end
 
         def chained_method_name(send_node)
@@ -109,6 +112,12 @@ module RuboCop
           end
           chained_method_name
         end
+
+        def assumed_argument?(node)
+          parent = node.parent
+
+          parent.call_type? || parent.literal? || parent.pair_type?
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/empty_block.rb

@@ -5,7 +5,7 @@ module RuboCop
     module Lint
       # Checks for blocks without a body.
       # Such empty blocks are typically an oversight or we should provide a comment
-      # be clearer what we're aiming for.
+      # to clarify what we're aiming for.
       #
       # Empty lambdas and procs are ignored by default.
       #

data/lib/rubocop/cop/lint/literal_in_interpolation.rb

@@ -34,7 +34,7 @@ module RuboCop
           # interpolation should not be removed if the expanded value
           # contains a space character.
           expanded_value = autocorrected_value(final_node)
-          return if in_array_percent_literal?(begin_node) && /\s/.match?(expanded_value)
+          return if in_array_percent_literal?(begin_node) && /\s|\A\z/.match?(expanded_value)
 
           add_offense(final_node) do |corrector|
             return if final_node.dstr_type? # nested, fixed in next iteration

data/lib/rubocop/cop/lint/mixed_case_range.rb

@@ -95,7 +95,7 @@ module RuboCop
 
         def skip_range?(range_start, range_end)
           [range_start, range_end].any? do |bound|
-            bound.type == :escape
+            bound.type != :literal
           end
         end
 

data/lib/rubocop/cop/lint/non_atomic_file_operation.rb

@@ -43,7 +43,6 @@ module RuboCop
       #
       class NonAtomicFileOperation < Base
         extend AutoCorrector
-        include Alignment
 
         MSG_REMOVE_FILE_EXIST_CHECK = 'Remove unnecessary existence check ' \
                                       '`%<receiver>s.%<method_name>s`.'
@@ -51,18 +50,20 @@ module RuboCop
         MAKE_FORCE_METHODS = %i[makedirs mkdir_p mkpath].freeze
         MAKE_METHODS = %i[mkdir].freeze
         REMOVE_FORCE_METHODS = %i[rm_f rm_rf].freeze
-        REMOVE_METHODS = %i[remove remove_dir remove_entry remove_entry_secure
-                            delete unlink remove_file rm rmdir safe_unlink].freeze
-        RESTRICT_ON_SEND = (MAKE_METHODS + MAKE_FORCE_METHODS + REMOVE_METHODS +
-          REMOVE_FORCE_METHODS).freeze
+        REMOVE_METHODS = %i[remove delete unlink remove_file rm rmdir safe_unlink].freeze
+        RECURSIVE_REMOVE_METHODS = %i[remove_dir remove_entry remove_entry_secure].freeze
+        RESTRICT_ON_SEND = (
+          MAKE_METHODS + MAKE_FORCE_METHODS + REMOVE_METHODS + RECURSIVE_REMOVE_METHODS +
+          REMOVE_FORCE_METHODS
+        ).freeze
 
         # @!method send_exist_node(node)
-        def_node_search :send_exist_node, <<-PATTERN
+        def_node_search :send_exist_node, <<~PATTERN
           $(send (const nil? {:FileTest :File :Dir :Shell}) {:exist? :exists?} ...)
         PATTERN
 
         # @!method receiver_and_method_name(node)
-        def_node_matcher :receiver_and_method_name, <<-PATTERN
+        def_node_matcher :receiver_and_method_name, <<~PATTERN
           (send (const nil? $_) $_ ...)
         PATTERN
 
@@ -140,6 +141,8 @@ module RuboCop
             'mkdir_p'
           elsif REMOVE_METHODS.include?(node.method_name)
             'rm_f'
+          elsif RECURSIVE_REMOVE_METHODS.include?(node.method_name)
+            'rm_rf'
           else
             node.method_name
           end

data/lib/rubocop/cop/lint/redundant_require_statement.rb

@@ -24,6 +24,10 @@ module RuboCop
       #
       # This cop target those features.
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because if `require 'pp'` is removed from one file,
+      #   `NameError` can be encountered when another file uses `PP.pp`.
+      #
       # @example
       #   # bad
       #   require 'unloaded_feature'

data/lib/rubocop/cop/lint/redundant_safe_navigation.rb

@@ -4,8 +4,12 @@ module RuboCop
   module Cop
     module Lint
       # Checks for redundant safe navigation calls.
-      # `instance_of?`, `kind_of?`, `is_a?`, `eql?`, `respond_to?`, and `equal?` methods
-      # are checked by default. These are customizable with `AllowedMethods` option.
+      # Use cases where a constant is `nil` are rare and an offense is detected
+      # when the receiver is a constant.
+      #
+      # For all receivers, the `instance_of?`, `kind_of?`, `is_a?`, `eql?`, `respond_to?`,
+      # and `equal?` methods are checked by default.
+      # These are customizable with `AllowedMethods` option.
       #
       # The `AllowedMethods` option specifies nil-safe methods,
       # in other words, it is a method that is allowed to skip safe navigation.
@@ -22,6 +26,9 @@ module RuboCop
       #
       # @example
       #   # bad
+      #   Const&.do_something
+      #
+      #   # bad
       #   do_something if attrs&.respond_to?(:[])
       #
       #   # good
@@ -33,6 +40,9 @@ module RuboCop
       #   end
       #
       #   # good
+      #   Const.do_something
+      #
+      #   # good
       #   while node.is_a?(BeginNode)
       #     node = node.parent
       #   end
@@ -63,8 +73,10 @@ module RuboCop
         PATTERN
 
         def on_csend(node)
-          return unless check?(node) && allowed_method?(node.method_name)
-          return if respond_to_nil_specific_method?(node)
+          unless node.receiver.const_type?
+            return unless check?(node) && allowed_method?(node.method_name)
+            return if respond_to_nil_specific_method?(node)
+          end
 
           range = range_between(node.loc.dot.begin_pos, node.source_range.end_pos)
           add_offense(range) { |corrector| corrector.replace(node.loc.dot, '.') }

data/lib/rubocop/cop/lint/safe_navigation_chain.rb

@@ -82,16 +82,23 @@ module RuboCop
         def autocorrect(corrector, offense_range:, send_node:)
           corrector.replace(
             offense_range,
-            add_safe_navigation_operator(
-              offense_range: offense_range,
-              send_node: send_node
-            )
+            add_safe_navigation_operator(offense_range: offense_range, send_node: send_node)
           )
+
+          corrector.wrap(send_node, '(', ')') if require_parentheses?(send_node)
         end
 
         def brackets?(send_node)
           send_node.method?(:[]) || send_node.method?(:[]=)
         end
+
+        def require_parentheses?(send_node)
+          return false unless send_node.comparison_method?
+          return false unless (node = send_node.parent)
+
+          (node.respond_to?(:logical_operator?) && node.logical_operator?) ||
+            (node.respond_to?(:comparison_method?) && node.comparison_method?)
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/to_enum_arguments.rb

@@ -74,7 +74,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
         def argument_match?(send_arg, def_arg)
           def_arg_name = def_arg.children[0]
 
@@ -87,12 +87,14 @@ module RuboCop
             send_arg.hash_type? &&
               send_arg.pairs.any? { |pair| passing_keyword_arg?(pair, def_arg_name) }
           when :kwrestarg
-            send_arg.each_child_node(:kwsplat).any? { |child| child.source == def_arg.source }
+            send_arg.each_child_node(:kwsplat, :forwarded_kwrestarg).any? do |child|
+              child.source == def_arg.source
+            end
           when :forward_arg
             send_arg.forwarded_args_type?
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
       end
     end
   end

data/lib/rubocop/cop/lint/useless_assignment.rb

@@ -7,12 +7,18 @@ module RuboCop
       # scope.
       # The basic idea for this cop was from the warning of `ruby -cw`:
       #
-      #   assigned but unused variable - foo
+      # [source,console]
+      # ----
+      # assigned but unused variable - foo
+      # ----
       #
       # Currently this cop has advanced logic that detects unreferenced
       # reassignments and properly handles varied cases such as branch, loop,
       # rescue, ensure, etc.
       #
+      # NOTE: Given the assignment `foo = 1, bar = 2`, removing unused variables
+      # can lead to a syntax error, so this case is not autocorrected.
+      #
       # @safety
       #   This cop's autocorrection is unsafe because removing assignment from
       #   operator assignment can cause NameError if this assignment has been used to declare
@@ -51,25 +57,24 @@ module RuboCop
           scope.variables.each_value { |variable| check_for_unused_assignments(variable) }
         end
 
+        # rubocop:disable Metrics/AbcSize
         def check_for_unused_assignments(variable)
           return if variable.should_be_unused?
 
           variable.assignments.each do |assignment|
-            next if assignment.used?
+            next if assignment.used? || part_of_ignored_node?(assignment.node)
 
             message = message_for_useless_assignment(assignment)
+            range = offense_range(assignment)
 
-            location = if assignment.regexp_named_capture?
-                         assignment.node.children.first.source_range
-                       else
-                         assignment.node.loc.name
-                       end
-
-            add_offense(location, message: message) do |corrector|
-              autocorrect(corrector, assignment)
+            add_offense(range, message: message) do |corrector|
+              autocorrect(corrector, assignment) unless sequential_assignment?(assignment.node)
             end
+
+            ignore_node(assignment.node) if chained_assignment?(assignment.node)
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         def message_for_useless_assignment(assignment)
           variable = assignment.variable
@@ -77,6 +82,28 @@ module RuboCop
           format(MSG, variable: variable.name) + message_specification(assignment, variable).to_s
         end
 
+        def offense_range(assignment)
+          if assignment.regexp_named_capture?
+            assignment.node.children.first.source_range
+          else
+            assignment.node.loc.name
+          end
+        end
+
+        def sequential_assignment?(node)
+          if node.lvasgn_type? && node.expression&.array_type? &&
+             node.each_descendant.any?(&:assignment?)
+            return true
+          end
+          return false unless node.parent
+
+          sequential_assignment?(node.parent)
+        end
+
+        def chained_assignment?(node)
+          node.respond_to?(:expression) && node.expression&.lvasgn_type?
+        end
+
         def message_specification(assignment, variable)
           if assignment.multiple_assignment?
             multiple_assignment_message(variable.name)
@@ -96,8 +123,7 @@ module RuboCop
           return_value_node = return_value_node_of_scope(scope)
           return unless assignment.meta_assignment_node.equal?(return_value_node)
 
-          " Use `#{assignment.operator.sub(/=$/, '')}` " \
-            "instead of `#{assignment.operator}`."
+          " Use `#{assignment.operator.delete_suffix('=')}` instead of `#{assignment.operator}`."
         end
 
         def similar_name_message(variable)

data/lib/rubocop/cop/metrics/block_length.rb

@@ -12,6 +12,7 @@ module RuboCop
       # Available are: 'array', 'hash', 'heredoc', and 'method_call'. Each construct
       # will be counted as one line regardless of its actual size.
       #
+      # NOTE: This cop does not apply for `Struct` definitions.
       #
       # NOTE: The `ExcludedMethods` configuration is deprecated and only kept
       # for backwards compatibility. Please use `AllowedMethods` and `AllowedPatterns`
@@ -40,7 +41,6 @@ module RuboCop
       #     )
       #   end                 # 6 points
       #
-      # NOTE: This cop does not apply for `Struct` definitions.
       class BlockLength < Base
         include CodeLength
         include AllowedMethods

data/lib/rubocop/cop/metrics/class_length.rb

@@ -11,6 +11,8 @@ module RuboCop
       # Available are: 'array', 'hash', 'heredoc', and 'method_call'. Each construct
       # will be counted as one line regardless of its actual size.
       #
+      # NOTE: This cop also applies for `Struct` definitions.
+      #
       # @example CountAsOne: ['array', 'heredoc', 'method_call']
       #
       #   class Foo
@@ -34,8 +36,6 @@ module RuboCop
       #     )
       #   end                 # 6 points
       #
-      #
-      # NOTE: This cop also applies for `Struct` definitions.
       class ClassLength < Base
         include CodeLength
 

data/lib/rubocop/cop/metrics/method_length.rb

@@ -54,7 +54,7 @@ module RuboCop
         alias on_defs on_def
 
         def on_block(node)
-          return unless node.send_node.method?(:define_method)
+          return unless node.method?(:define_method)
 
           check_code_length(node)
         end

data/lib/rubocop/cop/metrics/utils/code_length_calculator.rb

@@ -10,7 +10,7 @@ module RuboCop
           include Util
 
           FOLDABLE_TYPES = %i[array hash heredoc send csend].freeze
-          CLASSLIKE_TYPES = %i[class module sclass].freeze
+          CLASSLIKE_TYPES = %i[class module].freeze
           private_constant :FOLDABLE_TYPES, :CLASSLIKE_TYPES
 
           def initialize(node, processed_source, count_comments: false, foldable_types: [])
@@ -145,7 +145,7 @@ module RuboCop
 
           def extract_body(node)
             case node.type
-            when :class, :module, :block, :numblock, :def, :defs
+            when :class, :module, :sclass, :block, :numblock, :def, :defs
               node.body
             when :casgn
               _scope, _name, value = *node

data/lib/rubocop/cop/mixin/multiline_expression_indentation.rb

@@ -20,16 +20,17 @@ module RuboCop
         range = offending_range(node, lhs, rhs, style)
         check(range, node, lhs, rhs)
       end
+      alias on_csend on_send
 
       private
 
-      # In a chain of method calls, we regard the top send node as the base
+      # In a chain of method calls, we regard the top call node as the base
       # for indentation of all lines following the first. For example:
       # a.
       #   b c { block }.            <-- b is indented relative to a
       #   d                         <-- d is indented relative to a
       def left_hand_side(lhs)
-        while lhs.parent&.send_type? && lhs.parent.loc.dot && !lhs.parent.assignment_method?
+        while lhs.parent&.call_type? && lhs.parent.loc.dot && !lhs.parent.assignment_method?
           lhs = lhs.parent
         end
         lhs

data/lib/rubocop/cop/mixin/preceding_following_alignment.rb

@@ -75,7 +75,7 @@ module RuboCop
       end
 
       def aligned_token?(range, line)
-        aligned_words?(range, line) || aligned_dot?(range, line) || aligned_assignment?(range, line)
+        aligned_words?(range, line) || aligned_assignment?(range, line)
       end
 
       def aligned_operator?(range, line)
@@ -83,13 +83,11 @@ module RuboCop
       end
 
       def aligned_words?(range, line)
-        /\s\S/.match?(line[range.column - 1, 2])
-      end
-
-      def aligned_dot?(range, line)
-        char = line[range.column]
+        left_edge = range.column
+        return true if /\s\S/.match?(line[left_edge - 1, 2])
 
-        char == '.' && char == range.source[0]
+        token = range.source
+        token == line[left_edge, token.length]
       end
 
       def aligned_assignment?(range, line)

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

@@ -136,7 +136,7 @@ module RuboCop
         end
 
         def filename_good?(basename)
-          basename = basename.sub(/^\./, '')
+          basename = basename.delete_prefix('.')
           basename = basename.sub(/\.[^.]+$/, '')
           # special handling for Action Pack Variants file names like
           # some_file.xlsx+mobile.axlsx

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

@@ -80,6 +80,7 @@ module RuboCop
         minimum_target_ruby_version 2.7
 
         FORWARDING_LVAR_TYPES = %i[splat kwsplat block_pass].freeze
+        ADDITIONAL_ARG_TYPES = %i[lvar arg].freeze
 
         FORWARDING_MSG = 'Use shorthand syntax `...` for arguments forwarding.'
         ARGS_MSG = 'Use anonymous positional arguments forwarding (`*`).'
@@ -115,11 +116,11 @@ module RuboCop
         end
 
         def only_forwards_all?(send_classifications)
-          send_classifications.each_value.all? { |c, _, _| c == :all }
+          send_classifications.all? { |_, c, _, _| c == :all }
         end
 
         def add_forward_all_offenses(node, send_classifications, forwardable_args)
-          send_classifications.each do |send_node, (_c, forward_rest, _forward_kwrest)|
+          send_classifications.each do |send_node, _c, forward_rest, _forward_kwrest|
             register_forward_all_offense(send_node, send_node, forward_rest)
           end
 
@@ -132,7 +133,7 @@ module RuboCop
 
           rest_arg, kwrest_arg, _block_arg = *forwardable_args
 
-          send_classifications.each do |send_node, (_c, forward_rest, forward_kwrest)|
+          send_classifications.each do |send_node, _c, forward_rest, forward_kwrest|
             if forward_rest
               register_forward_args_offense(def_node.arguments, rest_arg)
               register_forward_args_offense(send_node, forward_rest)
@@ -156,7 +157,7 @@ module RuboCop
         end
 
         def classify_send_nodes(def_node, send_nodes, referenced_lvars, forwardable_args)
-          send_nodes.to_h do |send_node|
+          send_nodes.filter_map do |send_node|
             classification_and_forwards = classification_and_forwards(
               def_node,
               send_node,
@@ -164,8 +165,10 @@ module RuboCop
               forwardable_args
             )
 
-            [send_node, classification_and_forwards]
-          end.compact
+            next unless classification_and_forwards
+
+            [send_node, *classification_and_forwards]
+          end
         end
 
         def classification_and_forwards(def_node, send_node, referenced_lvars, forwardable_args)
@@ -212,7 +215,7 @@ module RuboCop
         end
 
         def arguments_range(node, first_node)
-          arguments = node.arguments
+          arguments = node.arguments.reject { |arg| ADDITIONAL_ARG_TYPES.include?(arg.type) }
 
           start_node = first_node || arguments.first
 
@@ -279,7 +282,7 @@ module RuboCop
 
             if can_forward_all?
               :all
-            elsif target_ruby_version >= 3.2
+            else
               :rest_or_kwrest
             end
           end
@@ -290,7 +293,7 @@ module RuboCop
             return false if any_arg_referenced?
             return false if ruby_32_missing_rest_or_kwest?
             return false unless offensive_block_forwarding?
-            return false if forward_additional_kwargs?
+            return false if additional_kwargs_or_forwarded_kwargs?
 
             no_additional_args? || (target_ruby_version >= 3.0 && no_post_splat_args?)
           end
@@ -332,12 +335,20 @@ module RuboCop
           end
 
           def no_post_splat_args?
-            splat_index = arguments.index(forwarded_rest_arg)
-            arg_after_splat = arguments[splat_index + 1]
+            return true unless (splat_index = arguments.index(forwarded_rest_arg))
 
+            arg_after_splat = arguments[splat_index + 1]
             [nil, :hash, :block_pass].include?(arg_after_splat&.type)
           end
 
+          def additional_kwargs_or_forwarded_kwargs?
+            additional_kwargs? || forward_additional_kwargs?
+          end
+
+          def additional_kwargs?
+            @def_node.arguments.any? { |a| a.kwarg_type? || a.kwoptarg_type? }
+          end
+
           def forward_additional_kwargs?
             return false unless forwarded_kwrest_arg
 

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

@@ -11,6 +11,15 @@ module RuboCop
       # The `array1.intersect?(array2)` method is faster than
       # `(array1 & array2).any?` and is more readable.
       #
+      # In cases like the following, compatibility is not ensured,
+      # so it will not be detected when using block argument.
+      #
+      # [source,ruby]
+      # ----
+      # ([1] & [1,2]).any? { |x| false }    # => false
+      # [1].intersect?([1,2]) { |x| false } # => true
+      # ----
+      #
       # @safety
       #   This cop cannot guarantee that `array1` and `array2` are
       #   actually arrays while method `intersect?` is for arrays only.
@@ -68,16 +77,15 @@ module RuboCop
         RESTRICT_ON_SEND = (STRAIGHT_METHODS + NEGATED_METHODS).freeze
 
         def on_send(node)
+          return if (parent = node.parent) && (parent.block_type? || parent.numblock_type?)
           return unless (receiver, argument, method_name = bad_intersection_check?(node))
 
           message = message(receiver.source, argument.source, method_name)
 
           add_offense(node, message: message) do |corrector|
-            if straight?(method_name)
-              corrector.replace(node, "#{receiver.source}.intersect?(#{argument.source})")
-            else
-              corrector.replace(node, "!#{receiver.source}.intersect?(#{argument.source})")
-            end
+            bang = straight?(method_name) ? '' : '!'
+
+            corrector.replace(node, "#{bang}#{receiver.source}.intersect?(#{argument.source})")
           end
         end
 

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

@@ -8,6 +8,11 @@ module RuboCop
       # `==`, `equal?`, and `eql?` custom method definitions are allowed by default.
       # These are customizable with `AllowedMethods` option.
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because there is no guarantee that
+      #   the constant `Foo` exists when autocorrecting `var.class.name == 'Foo'` to
+      #   `var.instance_of?(Foo)`.
+      #
       # @example
       #   # bad
       #   var.class == Date

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

@@ -25,6 +25,7 @@ module RuboCop
       #   # bad
       #   items.collect
       #   items.collect!
+      #   items.collect_concat
       #   items.inject
       #   items.detect
       #   items.find_all
@@ -33,6 +34,7 @@ module RuboCop
       #   # good
       #   items.map
       #   items.map!
+      #   items.flat_map
       #   items.reduce
       #   items.find
       #   items.select

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

@@ -93,8 +93,9 @@ module RuboCop
         end
 
         def same_collection_looping_block?(node, sibling)
-          (sibling&.block_type? || sibling&.numblock_type?) &&
-            sibling.send_node.method?(node.method_name) &&
+          return false if sibling.nil? || (!sibling.block_type? && !sibling.numblock_type?)
+
+          sibling.method?(node.method_name) &&
             sibling.receiver == node.receiver &&
             sibling.send_node.arguments == node.send_node.arguments
         end

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

@@ -74,7 +74,7 @@ module RuboCop
           new_arguments =
             node.arguments.map do |arg|
               if arg.percent_literal?
-                arg.children.map(&:value).map(&:inspect)
+                arg.children.map { |child| child.value.inspect }
               else
                 arg.children.map(&:source)
               end

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

@@ -40,9 +40,13 @@ 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
 
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_case(case_node)
-          return if case_node.condition
+          if case_node.condition || NOT_SUPPORTED_PARENT_TYPES.include?(case_node.parent&.type)
+            return
+          end
 
           branch_bodies = [*case_node.when_branches.map(&:body), case_node.else_branch].compact
 
@@ -52,6 +56,7 @@ module RuboCop
 
           add_offense(case_node.loc.keyword) { |corrector| autocorrect(corrector, case_node) }
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         private
 

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

@@ -80,7 +80,7 @@ module RuboCop
         private
 
         def suspect_enumerable?(node)
-          node.multiline? && node.send_node.method?(:each) && !node.send_node.arguments?
+          node.multiline? && node.method?(:each) && !node.send_node.arguments?
         end
       end
     end