rubocop 1.91.0 → 1.92.2

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

@@ -74,7 +74,8 @@ module RuboCop
         def should_not_check?(send, body)
           (body&.const_type? && !check_for_constant?) ||
             (body&.str_type? && !check_for_string?) ||
-            rails_cache?(send.receiver)
+            rails_cache?(send.receiver) ||
+            unappendable_argument?(send)
         end
 
         # @!method rails_cache?(node)
@@ -107,6 +108,13 @@ module RuboCop
         def check_for_string?
           frozen_string_literals_enabled?
         end
+
+        def unappendable_argument?(send)
+          argument = send.first_argument
+
+          argument.type?(:splat, :forwarded_restarg) ||
+            (argument.hash_type? && !argument.braces?)
+        end
       end
     end
   end

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

@@ -29,8 +29,7 @@ module RuboCop
                          operation_produces_immutable_object?(node.receiver))
 
           add_offense(node) do |corrector|
-            corrector.remove(node.loc.dot)
-            corrector.remove(node.loc.selector)
+            corrector.remove(node.loc.dot.join(node.loc.selector))
           end
         end
 
@@ -57,12 +56,21 @@ module RuboCop
         def_node_matcher :operation_produces_immutable_object?, <<~PATTERN
           {
             (begin (send {float int} {:+ :- :* :** :/ :% :<<} _))
-            (begin (send !{(str _) array} {:+ :- :* :** :/ :%} {float int}))
+            (begin (send #numeric_operation? {:+ :- :* :** :/ :%} {float int}))
             (begin (send _ {:== :=== :!= :<= :>= :< :>} _))
             (send _ {:count :length :size} ...)
             (any_block (send _ {:count :length :size} ...) ...)
           }
         PATTERN
+
+        # @!method numeric_operation?(node)
+        def_node_matcher :numeric_operation?, <<~PATTERN
+          {
+            float int
+            (begin #numeric_operation?)
+            (send #numeric_operation? {:+ :- :* :** :/ :%} #numeric_operation?)
+          }
+        PATTERN
       end
     end
   end

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

@@ -30,6 +30,10 @@ module RuboCop
 
         minimum_target_ruby_version 3.0
 
+        def self.autocorrect_incompatible_with
+          [Layout::MultilineMethodCallBraceLayout]
+        end
+
         # @!method redundant_unfreeze?(node)
         def_node_matcher :redundant_unfreeze?, <<~PATTERN
           {
@@ -41,9 +45,10 @@ module RuboCop
         def on_dstr(node)
           return if uninterpolated_string?(node) || uninterpolated_heredoc?(node)
           return unless redundant_unfreeze?(node.parent)
+          return if comment_outside_string?(node)
 
           add_offense(offense_range(node.parent)) do |corrector|
-            corrector.replace(node.parent, node.source)
+            remove_unfreeze(corrector, node.parent, node)
           end
         end
 
@@ -56,6 +61,24 @@ module RuboCop
             node.loc.selector
           end
         end
+
+        # Only the parts around the string are removed, so that an unfrozen string
+        # interpolated into it can be corrected in the same pass.
+        def remove_unfreeze(corrector, node, string)
+          corrector.remove(node.source_range.begin.join(string.source_range.begin))
+          corrector.remove(string.source_range.end.join(node.source_range.end))
+        end
+
+        def comment_outside_string?(node)
+          call_range = node.parent.source_range
+          string_range = node.source_range
+
+          processed_source.comments.any? do |comment|
+            range = comment.source_range
+
+            call_range.contains?(range) && !string_range.contains?(range)
+          end
+        end
       end
     end
   end

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

@@ -66,7 +66,8 @@ module RuboCop
             rescue?(node) ||
             in_pattern_matching_in_method_argument?(node) ||
             allowed_pin_operator?(node) ||
-            allowed_expression?(node)
+            allowed_expression?(node) ||
+            ParenthesesCorrector.heredoc_strands_code_after_close_paren?(node)
         end
 
         def ignore_syntax?(node)
@@ -232,12 +233,22 @@ module RuboCop
           node = node.send_node if node.any_block_type?
 
           return check_unary(begin_node, node) if node.unary_operation?
+          return if setter_in_condition?(begin_node, node)
 
           return unless method_call_with_redundant_parentheses?(begin_node, node)
 
           offense(begin_node, 'a method call')
         end
 
+        # Like a variable assignment, `if (foo.bar = baz)` is a safe assignment
+        # that `Lint/AssignmentInCondition` asks for, not redundant parentheses.
+        def setter_in_condition?(begin_node, node)
+          return false unless node.setter_method?
+          return false unless (parent = begin_node.parent)&.basic_conditional?
+
+          parent.condition.equal?(begin_node)
+        end
+
         def check_unary(begin_node, node)
           return if begin_node.chained?
 

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

@@ -90,6 +90,8 @@ module RuboCop
             quote = enforce_double_quotes? ? '"' : "'"
           end
 
+          new_argument = escape_interpolation_like_text(new_argument) if quote == '"'
+
           "#{quote}#{new_argument}#{quote}"
         end
 
@@ -109,6 +111,11 @@ module RuboCop
             char
           end.join
         end
+
+        # `#{`, `#$` and `#@` would start an interpolation in a double-quoted string.
+        def escape_interpolation_like_text(string)
+          string.gsub(/#(?=[{$@])/) { '\#' }
+        end
       end
     end
   end

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

@@ -34,12 +34,32 @@ module RuboCop
           return unless (regexp = redundant_regexp_constructor(node))
 
           add_offense(node, message: format(MSG, method: node.method_name)) do |corrector|
+            next if ambiguous_slash_regexp?(node, regexp)
+
             # Reuse the inner literal's own source so its delimiters are preserved.
             # Forcing `/.../` would break patterns like `%r{foo/bar}` that contain
             # an unescaped slash.
             corrector.replace(node, regexp.source)
           end
         end
+
+        private
+
+        # `p / a/` and `p /=a/` parse as division, so a slash regexp starting
+        # with whitespace or `=` can't begin the first argument of a command.
+        def ambiguous_slash_regexp?(node, regexp)
+          return false unless regexp.slash_literal? && regexp.content.match?(/\A[\s=]/)
+
+          begin_pos = node.source_range.begin_pos
+
+          node.each_ancestor(:call).any? do |call|
+            command?(call) && call.first_argument.source_range.begin_pos == begin_pos
+          end
+        end
+
+        def command?(call)
+          call.arguments? && !call.parenthesized? && !call.operator_method? && !call.setter_method?
+        end
       end
     end
   end

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

@@ -43,6 +43,10 @@ module RuboCop
         ALLOWED_OUTSIDE_CHAR_CLASS_METACHAR_ESCAPES = '.*+?{}()|$'.chars.freeze
         INTERPOLATION_SIGILS = %w[@ $].freeze
 
+        def self.autocorrect_incompatible_with
+          [Style::RegexpLiteral]
+        end
+
         def on_regexp(node)
           each_escape(node) do |char, index, within_character_class|
             next if char.valid_encoding? && allowed_escape?(node, char, index,

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

@@ -115,7 +115,7 @@ module RuboCop
 
         def on_send(node)
           return unless node.self_receiver? && regular_method_call?(node)
-          return if node.parent&.mlhs_type?
+          return if multiple_assignment_target?(node)
           return if allowed_send_node?(node)
           return if it_method_in_block?(node)
 
@@ -154,6 +154,14 @@ module RuboCop
           end
         end
 
+        def multiple_assignment_target?(node)
+          return false unless (parent = node.parent)
+
+          parent = parent.parent if parent.splat_type?
+
+          parent.mlhs_type?
+        end
+
         def allowed_send_node?(node)
           @allowed_send_nodes.include?(node) ||
             @local_variables_scopes[node].include?(node.method_name) ||

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

@@ -23,14 +23,20 @@ module RuboCop
       #   foo = bar unless condition
       #
       class RedundantSelfAssignmentBranch < Base
+        include RescueNode
         extend AutoCorrector
 
         MSG = 'Remove the self-assignment branch.'
 
+        STATEMENT_BODY_TYPES = %i[
+          kwbegin def defs block numblock itblock class module sclass rescue ensure
+        ].freeze
+
         def on_lvasgn(node)
           expression = node.expression
 
           return unless use_if_and_else_branch?(expression)
+          return unless statement?(node)
 
           if_branch = expression.if_branch
           else_branch = expression.else_branch
@@ -51,6 +57,28 @@ module RuboCop
           !expression.ternary? || !expression.else?
         end
 
+        def statement?(node)
+          parent = node.parent
+          return true if parent.nil? || parent.type?(*STATEMENT_BODY_TYPES)
+          return parent.loc.begin.nil? if parent.begin_type?
+          return !rescue_modifier?(parent) if parent.resbody_type?
+
+          statement_branch?(node, parent)
+        end
+
+        def statement_branch?(node, parent)
+          case parent.type
+          when :if
+            !parent.ternary? && !node.equal?(parent.condition)
+          when :when, :in_pattern, :while, :until, :for
+            node.equal?(parent.body)
+          when :case, :case_match
+            node.equal?(parent.else_branch)
+          else
+            false
+          end
+        end
+
         def inconvertible_to_modifier?(if_branch, else_branch)
           multiple_statements?(if_branch) || multiple_statements?(else_branch) ||
             (else_branch.respond_to?(:elsif?) && else_branch.elsif?)

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

@@ -123,12 +123,29 @@ module RuboCop
         end
 
         def register_offense(node, sort_node, sorter, accessor)
+          return if code_after_accessor_kept_apart?(node)
+
           message = message(node, sorter, accessor)
           add_offense(offense_range(sort_node, node), message: message) do |corrector|
             autocorrect(corrector, node, sort_node, sorter, accessor)
           end
         end
 
+        def code_after_accessor_kept_apart?(node)
+          return false if with_logical_operator?(node)
+
+          source = before_accessor_source(node)
+          return false if !source.include?("\n") || source.strip.empty?
+
+          rest = code_after_accessor(node)
+
+          !rest.empty? && !rest.match?(/\A(#|&?\.|[)\]},])/)
+        end
+
+        def code_after_accessor(node)
+          processed_source.lines[node.last_line - 1][node.source_range.last_column..].strip
+        end
+
         def offense_range(sort_node, node)
           range_between(sort_node.loc.selector.begin_pos, node.source_range.end_pos)
         end
@@ -146,12 +163,29 @@ module RuboCop
         end
 
         def autocorrect(corrector, node, sort_node, sorter, accessor)
-          # Remove accessor, e.g. `first` or `[-1]`.
-          corrector.remove(range_between(accessor_start(node), node.source_range.end_pos))
           # Replace "sort" or "sort_by" with the appropriate min/max method.
           corrector.replace(sort_node.loc.selector, suggestion(sorter, accessor, arg_value(node)))
-          # Replace to avoid syntax errors when followed by a logical operator.
-          replace_with_logical_operator(corrector, node) if with_logical_operator?(node)
+          remove_accessor(corrector, node)
+        end
+
+        def remove_accessor(corrector, node)
+          if removable_line_break_before_accessor?(node)
+            corrector.remove(node.receiver.source_range.end.join(node.source_range.end))
+          else
+            corrector.remove(range_between(accessor_start(node), node.source_range.end_pos))
+
+            replace_with_logical_operator(corrector, node) if with_logical_operator?(node)
+          end
+        end
+
+        def removable_line_break_before_accessor?(node)
+          source = before_accessor_source(node)
+
+          source.include?("\n") && source.strip.empty?
+        end
+
+        def before_accessor_source(node)
+          node.receiver.source_range.end.join((node.loc.dot || node.loc.selector).begin).source
         end
 
         def replace_with_logical_operator(corrector, node)

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

@@ -104,6 +104,7 @@ module RuboCop
           ['{', '}'] => /\\.|[{}]/,
           ['<', '>'] => /\\.|[<>]/
         }.freeze
+        DELIMITERS_KEEPING_ESCAPE = %w[$ * + . ? ^ | ( ) [ ] { } < >].freeze
 
         def on_regexp(node)
           return if slash_literal?(node) && percent_r_delimiters_conflict?(node)
@@ -119,6 +120,7 @@ module RuboCop
           add_offense(node, message: message) do |corrector|
             correct_delimiters(node, corrector)
             correct_inner_slashes(node, corrector)
+            correct_escaped_delimiters(node, corrector)
           end
         end
 
@@ -174,9 +176,8 @@ module RuboCop
           cop_config['AllowInnerSlashes']
         end
 
-        def node_body(node, include_begin_nodes: false)
-          types = include_begin_nodes ? %i[str begin] : %i[str]
-          node.each_child_node(*types).map(&:source).join
+        def node_body(node)
+          node.each_child_node(:str).map(&:source).join
         end
 
         def slash_literal?(node)
@@ -190,12 +191,20 @@ module RuboCop
         def allowed_omit_parentheses_with_percent_r_literal?(node)
           return false unless node.parent&.call_type?
           return true if node.content.start_with?(' ', '=')
+          return true if first_argument_of_command?(node) && node.content.match?(/\A\s/)
 
           enforced_style = config.for_cop('Style/MethodCallWithArgsParentheses')['EnforcedStyle']
 
           enforced_style == 'omit_parentheses'
         end
 
+        def first_argument_of_command?(node)
+          call = node.parent
+          return false unless call.first_argument.equal?(node)
+
+          !call.parenthesized? && !call.operator_method? && !call.setter_method?
+        end
+
         def correct_delimiters(node, corrector)
           replacement = calculate_replacement(node)
           corrector.replace(node.loc.begin, replacement.first)
@@ -203,32 +212,16 @@ module RuboCop
         end
 
         def correct_inner_slashes(node, corrector)
-          regexp_begin = node.loc.begin.end_pos
-
-          inner_slash_indices(node).each do |index|
-            start = regexp_begin + index
-
-            corrector.replace(
-              range_between(
-                start,
-                start + inner_slash_before_correction(node).length
-              ),
-              inner_slash_after_correction(node)
-            )
-          end
-        end
-
-        def inner_slash_indices(node)
-          text    = node_body(node, include_begin_nodes: true)
           pattern = inner_slash_before_correction(node)
-          index   = -1
-          indices = []
+          replacement = inner_slash_after_correction(node)
 
-          while (index = text.index(pattern, index + 1))
-            indices << index
-          end
+          node.each_child_node(:str) do |str_node|
+            inner_slash_indices(str_node.source, pattern).each do |index|
+              start = str_node.source_range.begin_pos + index
 
-          indices
+              corrector.replace(range_between(start, start + pattern.length), replacement)
+            end
+          end
         end
 
         def inner_slash_before_correction(node)
@@ -239,6 +232,17 @@ module RuboCop
           inner_slash_for(calculate_replacement(node).first)
         end
 
+        def inner_slash_indices(text, pattern)
+          index = -1
+          indices = []
+
+          while (index = text.index(pattern, index + 1))
+            indices << index
+          end
+
+          indices
+        end
+
         def inner_slash_for(opening_delimiter)
           if ['/', '%r/'].include?(opening_delimiter)
             '\/'
@@ -254,6 +258,51 @@ module RuboCop
             %w[/ /]
           end
         end
+
+        def correct_escaped_delimiters(node, corrector)
+          return unless (delimiter = delimiter_to_unescape(node))
+
+          node.each_child_node(:str) do |str_node|
+            text = str_node.source
+
+            escaped_delimiter_indices(text, delimiter).each do |index|
+              start = str_node.source_range.begin_pos + index
+              replacement = escaped_delimiter_replacement(node, delimiter, text[index + 2])
+
+              corrector.replace(range_between(start, start + 2), replacement)
+            end
+          end
+        end
+
+        def delimiter_to_unescape(node)
+          return if slash_literal?(node)
+
+          delimiter = node.delimiters.first
+
+          delimiter unless delimiter == '/' || DELIMITERS_KEEPING_ESCAPE.include?(delimiter)
+        end
+
+        def escaped_delimiter_indices(text, delimiter)
+          indices = []
+          index = 0
+
+          while (index = text.index('\\', index))
+            indices << index if text[index + 1] == delimiter
+            index += 2
+          end
+
+          indices
+        end
+
+        # A bare `#` before `{`, `@` or `$` would start an interpolation between slashes.
+        # `\#` still reads as a literal `#` there, except in extended mode, where `%r#a\#{b}#x`
+        # reads `#{b}` as a comment; `#\{` keeps both that comment and a `#` inside
+        # a character class.
+        def escaped_delimiter_replacement(node, delimiter, next_char)
+          return delimiter unless delimiter == '#' && next_char&.match?(/[{@$]/)
+
+          node.extended? ? '#\\' : '\\#'
+        end
       end
     end
   end

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

@@ -88,6 +88,8 @@ module RuboCop
           return unless previous_older_sibling
 
           add_offense(node, message: format(MSG, name: node.method_name)) do |corrector|
+            next unless own_lines?(previous_older_sibling) && own_lines?(search_node(node))
+
             autocorrect(corrector, node, previous_older_sibling)
           end
         end
@@ -99,25 +101,40 @@ module RuboCop
         end
 
         def find_previous_older_sibling(node) # rubocop:disable Metrics
-          search_node(node).left_siblings.reverse.find do |sibling|
+          oldest = nil
+          search_node(node).left_siblings.reverse_each do |sibling|
             next unless sibling.is_a?(AST::Node)
 
-            sibling = sibling_node(sibling)
-            break unless sibling&.send_type? && sibling.method?(node.method_name)
-            break unless sibling.arguments? && !sibling.receiver
-            break unless in_same_section?(sibling, node)
-            break unless node.first_argument.str_type? && sibling.first_argument.str_type?
+            required = sibling_node(sibling)
+            break unless required&.send_type? && required.method?(node.method_name)
+            break unless required.arguments? && !required.receiver
+            break unless in_same_section?(required, node)
+            break unless node.first_argument.str_type? && required.first_argument.str_type?
 
-            node.first_argument.value < sibling.first_argument.value
+            oldest = sibling if node.first_argument.value < required.first_argument.value
           end
+          oldest
+        end
+
+        def own_lines?(node)
+          range = node.source_range
+          rest_of_line = range.source_buffer.source_line(range.last_line)[range.last_column..]
+
+          begins_its_line?(range) && rest_of_line.match?(/\A\s*(#.*)?\z/)
         end
 
         def autocorrect(corrector, node, previous_older_sibling)
           range1 = range_with_comments_and_lines(previous_older_sibling)
           range2 = range_with_comments_and_lines(node.parent.if_type? ? node.parent : node)
+          source = range2.source
+
+          unless source.end_with?("\n")
+            source += "\n"
+            range2 = range2.with(begin_pos: range2.begin_pos - 1)
+          end
 
           corrector.remove(range2)
-          corrector.insert_before(range1, range2.source)
+          corrector.insert_before(range1.begin, source)
         end
 
         def search_node(node)

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

@@ -54,15 +54,24 @@ module RuboCop
 
           rescue_node = node.parent
           add_offense(rescue_node) do |corrector|
+            # The heredoc body would be left behind when the rescue body is moved.
+            next if heredoc_end(node)
+            next if inside_corrected_rescue_body?(rescue_node)
+
             parenthesized = parenthesized?(rescue_node)
 
             correct_rescue_block(corrector, rescue_node, parenthesized)
             ParenthesesCorrector.correct(corrector, rescue_node.parent) if parenthesized
+            ignore_node(rescue_node)
           end
         end
 
         private
 
+        def inside_corrected_rescue_body?(node)
+          node.each_ancestor(:resbody).any? { |resbody| ignored_node?(resbody.parent) }
+        end
+
         def parenthesized?(node)
           node.parent && parentheses?(node.parent)
         end
@@ -95,15 +104,8 @@ module RuboCop
         end
 
         def heredoc_end(node)
-          return unless node.call_type?
-
-          heredoc = node.arguments.reverse.find do |argument|
-            argument.respond_to?(:heredoc?) && argument.heredoc?
-          end
-
-          return unless heredoc
-
-          heredoc.loc.heredoc_end
+          node.each_node(:any_str).select(&:heredoc?).map { |heredoc| heredoc.loc.heredoc_end }
+              .max_by(&:end_pos)
         end
       end
     end

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

@@ -65,7 +65,7 @@ module RuboCop
           return if correct_style?(node)
 
           add_offense(node) do |corrector|
-            corrected = style == :return ? 'return' : 'return nil'
+            corrected = style == :return ? 'return' : return_nil(node)
 
             corrector.replace(node, corrected)
           end
@@ -79,13 +79,28 @@ module RuboCop
 
         def correct_style?(node)
           (style == :return && !return_nil_node?(node)) ||
-            (style == :return_nil && !return_node?(node))
+            (style == :return_nil && (!return_node?(node) || top_level_return?(node)))
+        end
+
+        def top_level_return?(node)
+          node.each_ancestor(:any_block, :any_def).none?
         end
 
         def scoped_node?(node)
           node.any_def_type? || node.lambda?
         end
 
+        def return_nil(node)
+          return 'return nil' unless (parent = node.parent)
+
+          if (parent.operator_keyword? && parent.logical_operator?) ||
+             (parent.if_type? && parent.ternary?)
+            '(return nil)'
+          else
+            'return nil'
+          end
+        end
+
         # @!method chained_send?(node)
         def_node_matcher :chained_send?, '(send !nil? ...)'
 

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

@@ -116,7 +116,17 @@ module RuboCop
         end
 
         def handle_return(return_node)
-          register_offense(return_node, 'return false') if return_nil?(return_node)
+          return unless return_nil?(return_node)
+
+          replacement = requires_parentheses?(return_node) ? '(return false)' : 'return false'
+          register_offense(return_node, replacement)
+        end
+
+        def requires_parentheses?(node)
+          parent = node.parent
+
+          (parent.operator_keyword? && parent.logical_operator?) ||
+            (parent.if_type? && parent.ternary?)
         end
 
         def handle_nil(nil_node)