rubocop 1.90.0 → 1.92.0

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

@@ -54,6 +54,10 @@ module RuboCop
 
         MSG = 'Convert `if-elsif` to `case-when`.'
 
+        def self.autocorrect_incompatible_with
+          [Style::IfInsideElse]
+        end
+
         def on_if(node)
           return unless should_check?(node)
 
@@ -106,7 +110,7 @@ module RuboCop
           when :or
             find_target(node.lhs)
           when :match_with_lvasgn
-            lhs, rhs = *node # rubocop:disable InternalAffairs/NodeDestructuring
+            lhs, rhs = *node # rubocop:disable InternalAffairs/NodeDestructuring -- `match_with_lvasgn` has no named operand accessors
             if lhs.regexp_type?
               rhs
             elsif rhs.regexp_type?
@@ -171,7 +175,7 @@ module RuboCop
               return collect_conditions(node.lhs, target, conditions) &&
                      collect_conditions(node.rhs, target, conditions)
             when :match_with_lvasgn
-              lhs, rhs = *node # rubocop:disable InternalAffairs/NodeDestructuring
+              lhs, rhs = *node # rubocop:disable InternalAffairs/NodeDestructuring -- `match_with_lvasgn` has no named operand accessors
               condition_from_binary_op(lhs, rhs, target)
             when :send
               condition_from_send_node(node, target)
@@ -224,10 +228,9 @@ module RuboCop
         end
 
         def branch_conditions(node)
-          conditions = []
-          while node&.if_type? && !node.ternary?
+          conditions = [node.condition]
+          while (node = node.else_branch)&.if_type? && node.elsif?
             conditions << node.condition
-            node = node.else_branch
           end
           conditions
         end
@@ -258,7 +261,7 @@ module RuboCop
         def regexp_with_working_captures?(node)
           case node.type
           when :match_with_lvasgn
-            lhs, _rhs = *node # rubocop:disable InternalAffairs/NodeDestructuring
+            lhs, _rhs = *node # rubocop:disable InternalAffairs/NodeDestructuring -- `match_with_lvasgn` has no named operand accessors
             node.loc.selector.source == '=~' && regexp_with_named_captures?(lhs)
           when :send
             node.method?(:match) &&

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

@@ -65,6 +65,12 @@ module RuboCop
         NESTED_MSG = 'Use nested module/class definitions instead of compact style.'
         COMPACT_MSG = 'Use compact module/class definition instead of nested style.'
 
+        # `Style/StructInheritance` turns a class definition into a constant assignment in
+        # the same pass, which the compacted `class` keyword would then precede.
+        def self.autocorrect_incompatible_with
+          [Style::StructInheritance]
+        end
+
         def on_class(node)
           return if node.parent_class && style_for_classes != :nested
 
@@ -117,7 +123,10 @@ module RuboCop
         end
 
         def heuristic_namespace_keyword(node)
-          class_definition = node.left_sibling&.each_node(:class)&.find do |class_node|
+          left_sibling = node.left_sibling
+          return 'module' unless left_sibling.is_a?(AST::Node)
+
+          class_definition = left_sibling.each_node(:class).find do |class_node|
             class_node.identifier == node.identifier.namespace
           end
 
@@ -194,33 +203,62 @@ module RuboCop
             "#{node.body.children.first.const_name}"
         end
 
-        # rubocop:disable-next Metrics/AbcSize
         def remove_end(corrector, body)
-          remove_begin_pos = if same_line?(body.loc.name, body.loc.end)
-                               body.loc.name.end_pos
-                             else
-                               body.loc.end.begin_pos - leading_spaces(body).size
-                             end
-          adjustment = processed_source.raw_source[remove_begin_pos] == ';' ? 0 : 1
-          range = range_between(remove_begin_pos, body.loc.end.end_pos + adjustment)
+          range = if same_line?(body.loc.name, body.loc.end)
+                    single_line_end_range(body)
+                  else
+                    multiline_end_range(body)
+                  end
 
           corrector.remove(range)
         end
 
-        def unindent(corrector, node)
-          return unless node.body.children.last
+        def single_line_end_range(body)
+          raw = processed_source.raw_source
+          pos = body.loc.end.begin_pos
+          pos -= 1 while raw[pos - 1] == ' '
+          pos -= 1 if raw[pos - 1] == ';'
+          range_between(pos, body.loc.end.end_pos)
+        end
 
-          last_child_leading_spaces = leading_spaces(node.body.children.last)
-          return if spaces_size(leading_spaces(node)) == spaces_size(last_child_leading_spaces)
+        def multiline_end_range(body)
+          remove_begin_pos = body.loc.end.begin_pos - leading_spaces(body).size
+          adjustment = processed_source.raw_source[remove_begin_pos] == ';' ? 0 : 1
+          range_between(remove_begin_pos, body.loc.end.end_pos + adjustment)
+        end
 
-          column_delta = configured_indentation_width - spaces_size(last_child_leading_spaces)
-          return if column_delta.zero?
+        def unindent(corrector, node)
+          column_delta = unindent_column_delta(node)
+          return unless column_delta&.negative?
+
+          range = unindentable_range(node.body)
+          return unless range
 
           AlignmentCorrector.correct(
-            corrector, processed_source, node, column_delta, tab_indentation: true
+            corrector, processed_source, range, column_delta, tab_indentation: true
           )
         end
 
+        def unindent_column_delta(node)
+          body = node.body.children.last
+          return unless body
+
+          node_indentation = spaces_size(leading_spaces(node))
+          body_indentation = spaces_size(leading_spaces(body))
+
+          node_indentation + configured_indentation_width - body_indentation
+        end
+
+        def unindentable_range(body)
+          first_line = body.loc.name.line + 1
+          last_line = body.loc.end.line - 1
+          return if first_line > last_line
+
+          buffer = processed_source.buffer
+          range_between(buffer.line_range(first_line).begin_pos,
+                        buffer.line_range(last_line).end_pos)
+        end
+
         def leading_spaces(node)
           node.source_range.source_line[/\A\s*/]
         end

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

@@ -72,6 +72,7 @@ module RuboCop
           return unless def_self_style?
           return unless node.identifier.self_type?
           return unless all_methods_public?(node)
+          return unless def_nodes(node).all? { |def_node| no_code_after?(def_node.source_range) }
 
           add_offense(node, message: MSG_SCLASS) do |corrector|
             autocorrect_sclass(node, corrector)
@@ -112,6 +113,13 @@ module RuboCop
           end
         end
 
+        def no_code_after?(range)
+          trailing = processed_source.lines[range.last_line - 1][range.last_column..].to_s.strip
+          trailing = trailing.sub(/\A;+\s*/, '')
+
+          trailing.empty? || trailing.start_with?('#')
+        end
+
         def autocorrect_sclass(node, corrector)
           rewritten_defs = []
 

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

@@ -60,19 +60,18 @@ module RuboCop
       #   end
       #
       class CombinableLoops < Base
+        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Combine this loop with the previous loop.'
 
-        # rubocop:disable-next Metrics/CyclomaticComplexity
         def on_block(node)
           return unless node.parent&.begin_type?
           return unless collection_looping_method?(node)
-          return unless same_collection_looping_block?(node, node.left_sibling)
-          return unless node.body && node.left_sibling.body
+          return unless combinable_looping_blocks?(node, node.left_sibling)
 
           add_offense(node) do |corrector|
-            next unless node.arguments == node.left_sibling.arguments
+            next unless combinable_blocks?(node, node.left_sibling)
 
             combine_with_left_sibling(corrector, node)
           end
@@ -87,9 +86,7 @@ module RuboCop
           return unless node.body && node.left_sibling.body
 
           add_offense(node) do |corrector|
-            # Combining loops with different iteration variables would leave the second
-            # body referencing an undefined variable, so only autocorrect when they match.
-            next unless node.variable == node.left_sibling.variable
+            next unless combinable_fors?(node, node.left_sibling)
 
             combine_with_left_sibling(corrector, node)
           end
@@ -110,25 +107,102 @@ module RuboCop
             sibling.send_node.arguments == node.send_node.arguments
         end
 
+        def combinable_looping_blocks?(node, sibling)
+          same_collection_looping_block?(node, sibling) && node.body && sibling.body
+        end
+
         def same_collection_looping_for?(node, sibling)
           sibling&.for_type? && node.collection == sibling.collection
         end
 
+        def combinable_blocks?(node, sibling)
+          return false unless node.arguments == sibling.arguments
+          # Numbered and `it` parameters are implicit, so `arguments` is empty for both.
+          return false unless node.argument_list == sibling.argument_list
+          return false if directive_after_opening?(node)
+
+          !node.body.type?(:rescue, :ensure) && !sibling.body.type?(:rescue, :ensure)
+        end
+
+        # Combining loops with different iteration variables would leave the second
+        # body referencing an undefined variable, so only autocorrect when they match.
+        def combinable_fors?(node, sibling)
+          node.variable == sibling.variable && !directive_after_opening?(node)
+        end
+
+        # The opening is removed, so a directive after it would end up on a line of
+        # its own, where it covers the rest of the file instead of a single line.
+        def directive_after_opening?(node)
+          opening_line = loop_opening(node).line
+          return false if opening_line == node.body.first_line
+
+          comment = processed_source.comment_at_line(opening_line)
+          comment && DirectiveComment.new(comment).start_with_marker?
+        end
+
+        # The block arguments or `{`/`do` of a block, or the `do` or collection of a `for` loop.
+        def loop_opening(node)
+          if node.for_type?
+            node.loc.begin || node.collection.source_range
+          else
+            (node.block_type? && node.arguments.source_range) || node.loc.begin
+          end
+        end
+
         def combine_with_left_sibling(corrector, node)
-          corrector.remove(node.left_sibling.body.source_range.end.join(node.left_sibling.loc.end))
-          corrector.remove(node.source_range.begin.join(node.body.source_range.begin))
+          corrector.remove(closing_with_preceding_space(node.left_sibling, node))
+          corrector.remove(opening_with_following_space(node))
 
           correct_end_of_block(corrector, node)
         end
 
+        # Comments and heredoc bodies before the closing delimiter are kept. When
+        # the next loop starts on the delimiter's line, the line break before the
+        # delimiter is kept too, so that a comment doesn't swallow the next loop.
+        def closing_with_preceding_space(loop, next_loop)
+          separate_lines = !same_line?(loop.loc.end, next_loop)
+
+          range_with_surrounding_space(
+            loop.loc.end, side: :left, newlines: separate_lines, whitespace: separate_lines
+          )
+        end
+
+        # Comments between the opening and the body are kept.
+        def opening_with_following_space(node)
+          opening = node.source_range.begin.join(loop_opening(node))
+
+          range_with_surrounding_space(opening, side: :right, whitespace: true)
+        end
+
         def correct_end_of_block(corrector, node)
           return unless node.left_sibling.respond_to?(:braces?)
-          return if node.right_sibling&.any_block_type?
+          return if combined_with_right_sibling?(node)
 
-          end_of_block = node.left_sibling.braces? ? '}' : ' end'
+          end_of_block = first_combined_block(node).braces? ? '}' : ' end'
           corrector.remove(node.loc.end)
           corrector.insert_before(node.source_range.end, end_of_block)
         end
+
+        def combined_with_right_sibling?(node)
+          sibling = node.right_sibling
+          return false unless sibling&.any_block_type?
+          # A disabled loop isn't corrected, so it doesn't get merged into this one.
+          return false unless enabled_lines?(sibling.source_range)
+
+          same_collection_looping_block?(sibling, node) && sibling.body &&
+            combinable_blocks?(sibling, node)
+        end
+
+        def first_combined_block(node)
+          first = node.left_sibling
+
+          while (previous = first.left_sibling) && enabled_lines?(first.source_range) &&
+                combinable_looping_blocks?(first, previous) && combinable_blocks?(first, previous)
+            first = previous
+          end
+
+          first
+        end
       end
     end
   end

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

@@ -23,6 +23,7 @@ module RuboCop
       #   list.push(qux, quux, corge)
       #
       class ConcatArrayLiterals < Base
+        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
@@ -30,6 +31,14 @@ module RuboCop
           'Use `push` with elements as arguments without array brackets instead of `%<current>s`.'
         RESTRICT_ON_SEND = %i[concat].freeze
 
+        # `Style/MethodCallWithArgsParentheses` removing the parentheses of the `push(...)`
+        # this cop writes in the same pass drops the line continuation a multiline call needs.
+        # `Style/TrailingCommaInArguments` adds a comma after the array literal this cop
+        # replaces with its elements in the same pass.
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses, Style::TrailingCommaInArguments]
+        end
+
         # rubocop:disable-next Metrics
         def on_send(node)
           return if node.arguments.empty?
@@ -54,17 +63,13 @@ module RuboCop
             if use_percent_literal
               next unless prefer
 
-              corrector.replace(offense, prefer)
+              rebuild_call(corrector, offense, prefer)
             elsif node.arguments.any? { |argument| argument.children.empty? }
               # In-place bracket removal would leave dangling commas (e.g.
               # `concat([], [b])` -> `push(, b)`), so rebuild the call instead.
-              corrector.replace(offense, preferred_method(node))
+              rebuild_call(corrector, offense, preferred_method(node))
             else
-              corrector.replace(node.loc.selector, 'push')
-              node.arguments.each do |argument|
-                corrector.remove(argument.loc.begin)
-                corrector.remove(argument.loc.end)
-              end
+              remove_brackets(corrector, node)
             end
           end
         end
@@ -94,6 +99,40 @@ module RuboCop
             arg.children.all? { |child| child.type?(:str, :sym) }
           end
         end
+
+        def rebuild_call(corrector, offense, replacement)
+          # The comments inside the call would be lost.
+          return if comment_in?(offense)
+
+          corrector.replace(offense, replacement)
+        end
+
+        def comment_in?(range)
+          processed_source.each_comment_in_lines(range.line..range.last_line).any? do |comment|
+            range.contains?(comment.source_range)
+          end
+        end
+
+        def remove_brackets(corrector, node)
+          closing_ranges = node.arguments.map { |argument| closing_bracket_range(node, argument) }
+          # A comment or a heredoc body there can't be moved out of the way.
+          return unless closing_ranges.all? { |range| range.source.match?(/\A[\s,]*\]\z/) }
+
+          corrector.replace(node.loc.selector, 'push')
+          node.arguments.zip(closing_ranges) do |argument, closing_range|
+            corrector.remove(argument.loc.begin)
+            corrector.remove(closing_range)
+          end
+        end
+
+        # Whatever sits between the last element and the `]` of an array that isn't the
+        # last argument would end up before the following comma (a newline before it is a
+        # syntax error), so it's removed along with the `]`.
+        def closing_bracket_range(node, argument)
+          return argument.loc.end if argument.equal?(node.last_argument)
+
+          range_between(argument.children.last.source_range.end_pos, argument.loc.end.end_pos)
+        end
       end
     end
   end

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

@@ -223,6 +223,10 @@ module RuboCop
           }
         PATTERN
 
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
+
         ASSIGNMENT_TYPES.each do |type|
           define_method :"on_#{type}" do |node|
             return if part_of_ignored_node?(node)

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

@@ -82,12 +82,16 @@ module RuboCop
           end
         end
 
-        # rubocop:disable-next Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity
         def visibility_declaration?(node)
           node.parent.each_child_node(:send).any? do |child|
             next false unless (arguments = visibility_declaration_for(child))
 
-            arguments = arguments.first.children.first.to_a if arguments.first&.splat_type?
+            if (splat = arguments.first)&.splat_type?
+              next true unless splat.children.first.array_type?
+
+              arguments = splat.children.first.children
+            end
             constant_values = arguments.map do |argument|
               # `respond_to?(:value)` is too broad: `int`/`float` nodes respond to it
               # but their value is a `Numeric`, which has no `to_sym` (e.g.

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

@@ -10,6 +10,10 @@ module RuboCop
       #   Autocorrection is unsafe because it will change the inheritance
       #   tree (e.g. return value of `Module#ancestors`) of the constant.
       #
+      #   It is also unsafe because constants that the class body resolves through its
+      #   ancestors (e.g. one provided by an included module) fall out of scope inside
+      #   the block.
+      #
       # @example
       #   # bad
       #   class Person < Data.define(:first_name, :last_name)
@@ -42,6 +46,7 @@ module RuboCop
 
         def on_class(node)
           return unless data_define?(node.parent_class)
+          return if defines_constants?(node.body)
 
           add_offense(node.parent_class) do |corrector|
             corrector.remove(range_with_surrounding_space(node.loc.keyword, newlines: false))
@@ -59,6 +64,15 @@ module RuboCop
 
         private
 
+        # Constants, including nested classes and modules, are scoped to the class when they
+        # are defined in a class body, but leak into the enclosing namespace once moved into a
+        # `Data.define` block, so such a class cannot be rewritten as an assignment.
+        def defines_constants?(class_body)
+          return false unless class_body
+
+          class_body.each_node(:casgn, :class, :module).any?
+        end
+
         def correct_parent(parent, corrector)
           if parent.block_type?
             # Convert a brace block to `do`, so the class's own `end` closes it