rubocop 1.72.1 → 1.81.7

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Check for redundant line continuation.
+      # Checks for redundant line continuation.
       #
       # This cop marks a line continuation as redundant if removing the backslash
       # does not result in a syntax error.
@@ -181,9 +181,7 @@ module RuboCop
           ARGUMENT_TYPES.include?(next_token.type)
         end
 
-        # rubocop:disable Metrics/AbcSize
         def argument_newline?(node)
-          node = node.to_a.last if node.assignment?
           return false if node.parenthesized_call?
 
           node = node.children.first if node.root? && node.begin_type?
@@ -196,7 +194,6 @@ module RuboCop
             node.loc.selector.line != node.first_argument.loc.line
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         def find_node_for_line(last_line)
           processed_source.ast.each_node do |node|

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

@@ -13,21 +13,17 @@ module RuboCop
       #   # good
       #   x if y.z.nil?
       #
-      # rubocop:disable Metrics/ClassLength
-      class RedundantParentheses < Base
+      class RedundantParentheses < Base # rubocop:disable Metrics/ClassLength
         include Parentheses
         extend AutoCorrector
 
-        ALLOWED_NODE_TYPES = %i[and or send splat kwsplat].freeze
+        ALLOWED_NODE_TYPES = %i[or send splat kwsplat].freeze
 
         # @!method square_brackets?(node)
         def_node_matcher :square_brackets?, <<~PATTERN
           (send `{(send _recv _msg) str array hash const #variable?} :[] ...)
         PATTERN
 
-        # @!method method_node_and_args(node)
-        def_node_matcher :method_node_and_args, '$(call _recv _msg $...)'
-
         # @!method rescue?(node)
         def_node_matcher :rescue?, '{^resbody ^^resbody}'
 
@@ -50,6 +46,7 @@ module RuboCop
           empty_parentheses?(node) ||
             first_arg_begins_with_hash_literal?(node) ||
             rescue?(node) ||
+            in_pattern_matching_in_method_argument?(node) ||
             allowed_pin_operator?(node) ||
             allowed_expression?(node)
         end
@@ -79,7 +76,7 @@ module RuboCop
           ancestor = node.ancestors.first
           return false unless ancestor
 
-          !ancestor.type?(:begin, :def, :any_block)
+          !ancestor.type?(:begin, :any_def, :any_block)
         end
 
         def allowed_ternary?(node)
@@ -99,7 +96,7 @@ module RuboCop
           return false unless node.type?(:send, :super, :yield)
 
           node.arguments.one? && !node.parenthesized? &&
-            !node.arithmetic_operation? && node.first_argument.begin_type?
+            !node.operator_method? && node.first_argument.begin_type?
         end
 
         def multiline_control_flow_statements?(node)
@@ -123,6 +120,13 @@ module RuboCop
           hash_literal && first_argument?(node) && !parentheses?(hash_literal) && !parenthesized
         end
 
+        def in_pattern_matching_in_method_argument?(begin_node)
+          return false unless begin_node.parent&.call_type?
+          return false unless (node = begin_node.children.first)
+
+          target_ruby_version <= 2.7 ? node.match_pattern_type? : node.match_pattern_p_type?
+        end
+
         def method_chain_begins_with_hash_literal(node)
           return if node.nil?
           return node if node.hash_type?
@@ -135,12 +139,14 @@ module RuboCop
           node = begin_node.children.first
 
           if (message = find_offense_message(begin_node, node))
-            begin_node = begin_node.parent if node.range_type?
+            if node.range_type? && !argument_of_parenthesized_method_call?(begin_node, node)
+              begin_node = begin_node.parent
+            end
 
             return offense(begin_node, message)
           end
 
-          check_send(begin_node, node) if node.call_type?
+          check_send(begin_node, node) if call_node?(node)
         end
 
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
@@ -155,7 +161,12 @@ module RuboCop
           if node.lambda_or_proc? && (node.braces? || node.send_node.lambda_literal?)
             return 'an expression'
           end
+          if disallowed_one_line_pattern_matching?(begin_node, node)
+            return 'a one-line pattern matching'
+          end
           return 'an interpolated expression' if interpolation?(begin_node)
+          return 'a method argument' if argument_of_parenthesized_method_call?(begin_node, node)
+          return 'a one-line rescue' if oneline_rescue_parentheses_required?(begin_node, node)
 
           return if begin_node.chained?
 
@@ -163,6 +174,7 @@ module RuboCop
             return if node.semantic_operator? && begin_node.parent
             return if node.multiline? && allow_in_multiline_conditions?
             return if ALLOWED_NODE_TYPES.include?(begin_node.parent&.type)
+            return if !node.and_type? && begin_node.parent&.and_type?
             return if begin_node.parent&.if_type? && begin_node.parent.ternary?
 
             'a logical expression'
@@ -177,14 +189,44 @@ module RuboCop
         # @!method interpolation?(node)
         def_node_matcher :interpolation?, '[^begin ^^dstr]'
 
+        def argument_of_parenthesized_method_call?(begin_node, node)
+          if node.basic_conditional? || node.rescue_type? || method_call_parentheses_required?(node)
+            return false
+          end
+          return false unless (parent = begin_node.parent)
+
+          parent.call_type? && parent.parenthesized? && parent.receiver != begin_node
+        end
+
+        def oneline_rescue_parentheses_required?(begin_node, node)
+          return false unless node.rescue_type?
+          return false unless (parent = begin_node.parent)
+          return false if parent.if_type? && parent.ternary?
+          return false if parent.conditional? && parent.condition == begin_node
+
+          !parent.type?(:call, :array, :pair)
+        end
+
+        def method_call_parentheses_required?(node)
+          return false unless node.call_type?
+
+          (node.receiver.nil? || node.loc.dot) && node.arguments.any?
+        end
+
         def allow_in_multiline_conditions?
           !!config.for_enabled_cop('Style/ParenthesesAroundCondition')['AllowInMultilineConditions']
         end
 
+        def call_node?(node)
+          node.call_type? || (node.any_block_type? && node.braces? && !node.lambda_or_proc?)
+        end
+
         def check_send(begin_node, node)
+          node = node.send_node if node.any_block_type?
+
           return check_unary(begin_node, node) if node.unary_operation?
 
-          return unless method_call_with_redundant_parentheses?(node)
+          return unless method_call_with_redundant_parentheses?(begin_node, node)
           return if call_chain_starts_with_int?(begin_node, node) ||
                     do_end_block_in_method_chain?(begin_node, node)
 
@@ -195,8 +237,7 @@ module RuboCop
           return if begin_node.chained?
 
           node = node.children.first while suspect_unary?(node)
-
-          return if node.send_type? && !method_call_with_redundant_parentheses?(node)
+          return unless method_call_with_redundant_parentheses?(begin_node, node)
 
           offense(begin_node, 'a unary operation')
         end
@@ -225,6 +266,15 @@ module RuboCop
           end
         end
 
+        def disallowed_one_line_pattern_matching?(begin_node, node)
+          if (parent = begin_node.parent)
+            return false if parent.any_def_type? && parent.endless?
+            return false if parent.assignment?
+          end
+
+          node.any_match_pattern_type? && node.each_ancestor.none?(&:operator_keyword?)
+        end
+
         def raised_to_power_negative_numeric?(begin_node, node)
           return false unless node.numeric_type?
 
@@ -249,13 +299,19 @@ module RuboCop
           end
         end
 
-        def method_call_with_redundant_parentheses?(node)
-          return false unless node.call_type?
+        def method_call_with_redundant_parentheses?(begin_node, node)
+          return false unless node.type?(:call, :super, :yield, :defined?)
           return false if node.prefix_not?
+          return true if singular_parenthesized_parent?(begin_node)
+
+          node.arguments.empty? || parentheses?(node) || square_brackets?(node)
+        end
 
-          send_node, args = method_node_and_args(node)
+        def singular_parenthesized_parent?(begin_node)
+          return true unless begin_node.parent
+          return false if begin_node.parent.type?(:splat, :kwsplat)
 
-          args.empty? || parentheses?(send_node) || square_brackets?(send_node)
+          parentheses?(begin_node) && begin_node.parent.children.one?
         end
 
         def only_begin_arg?(args)
@@ -299,7 +355,6 @@ module RuboCop
           block.keywords? && begin_node.each_ancestor(:call).any?
         end
       end
-      # rubocop:enable Metrics/ClassLength
     end
   end
 end

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

@@ -66,6 +66,7 @@ module RuboCop
           DETERMINISTIC_REGEX.match?(regexp_node.source)
         end
 
+        # rubocop:disable Metrics/MethodLength
         def preferred_argument(regexp_node)
           new_argument = replacement(regexp_node)
 
@@ -73,6 +74,8 @@ module RuboCop
             new_argument.gsub!("'", "\\\\'")
             new_argument.gsub!('\"', '"')
             quote = "'"
+          elsif new_argument.include?("\\'")
+            quote = "'"
           elsif new_argument.include?('\'')
             new_argument.gsub!("'", "\\\\'")
             quote = "'"
@@ -84,6 +87,7 @@ module RuboCop
 
           "#{quote}#{new_argument}#{quote}"
         end
+        # rubocop:enable Metrics/MethodLength
 
         def replacement(regexp_node)
           regexp_content = regexp_node.content

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

@@ -41,6 +41,7 @@ module RuboCop
         ALLOWED_ALWAYS_ESCAPES = " \n[]^\\#".chars.freeze
         ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES = '-'.chars.freeze
         ALLOWED_OUTSIDE_CHAR_CLASS_METACHAR_ESCAPES = '.*+?{}()|$'.chars.freeze
+        INTERPOLATION_SIGILS = %w[@ $].freeze
 
         def on_regexp(node)
           each_escape(node) do |char, index, within_character_class|
@@ -64,6 +65,7 @@ module RuboCop
           # different versions of Ruby so that e.g. /\i/ != /i/
           return true if /[[:alnum:]]/.match?(char)
           return true if ALLOWED_ALWAYS_ESCAPES.include?(char) || delimiter?(node, char)
+          return true if requires_escape_to_avoid_interpolation?(node.source[index], char)
 
           if within_character_class
             ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES.include?(char) &&
@@ -95,6 +97,12 @@ module RuboCop
           delimiters.include?(char)
         end
 
+        def requires_escape_to_avoid_interpolation?(char_before_escape, escaped_char)
+          # Preserve escapes after '#' that would otherwise trigger interpolation:
+          # '#@ivar', '#@@cvar', and '#$gvar'.
+          char_before_escape == '#' && INTERPOLATION_SIGILS.include?(escaped_char)
+        end
+
         def each_escape(node)
           node.parsed_tree&.traverse&.reduce(0) do |char_class_depth, (event, expr)|
             yield(expr.text[1], expr.ts, !char_class_depth.zero?) if expr.type == :escape

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

@@ -67,6 +67,9 @@ module RuboCop
 
         def on_or_asgn(node)
           allow_self(node.lhs)
+
+          lhs_name = node.lhs.lvasgn_type? ? node.lhs.name : node.lhs
+          add_lhs_to_local_variables_scopes(node.rhs, lhs_name)
         end
         alias on_and_asgn on_or_asgn
 
@@ -118,15 +121,16 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_if(node)
           # Allow conditional nodes to use `self` in the condition if that variable
           # name is used in an `lvasgn` or `masgn` within the `if`.
-          node.child_nodes.each do |child_node|
-            if child_node.lvasgn_type?
-              add_lhs_to_local_variables_scopes(node.condition, child_node.lhs)
-            elsif child_node.masgn_type?
-              add_masgn_lhs_variables(node.condition, child_node.lhs)
+          node.each_descendant(:lvasgn, :masgn) do |descendant_node|
+            if descendant_node.lvasgn_type?
+              add_lhs_to_local_variables_scopes(node.condition, descendant_node.lhs)
+            else
+              add_masgn_lhs_variables(node.condition, descendant_node.lhs)
             end
           end
         end

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

@@ -58,7 +58,7 @@ module RuboCop
         # rubocop:disable Metrics/AbcSize
         def on_lvasgn(node)
           return unless (rhs = node.rhs)
-          return unless rhs.call_type? && method_returning_self?(rhs.method_name)
+          return unless rhs.type?(:any_block, :call) && method_returning_self?(rhs.method_name)
           return unless (receiver = rhs.receiver)
 
           receiver_type = ASSIGNMENT_TYPE_TO_RECEIVER_TYPE[node.type]

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

@@ -21,6 +21,7 @@ module RuboCop
 
         MSG_BLOCK = 'Use `sort` instead of `sort_by { |%<var>s| %<var>s }`.'
         MSG_NUMBLOCK = 'Use `sort` instead of `sort_by { _1 }`.'
+        MSG_ITBLOCK = 'Use `sort` instead of `sort_by { it }`.'
 
         def on_block(node)
           redundant_sort_by_block(node) do |send, var_name|
@@ -36,7 +37,17 @@ module RuboCop
           redundant_sort_by_numblock(node) do |send|
             range = sort_by_range(send, node)
 
-            add_offense(range, message: format(MSG_NUMBLOCK)) do |corrector|
+            add_offense(range, message: MSG_NUMBLOCK) do |corrector|
+              corrector.replace(range, 'sort')
+            end
+          end
+        end
+
+        def on_itblock(node)
+          redundant_sort_by_itblock(node) do |send|
+            range = sort_by_range(send, node)
+
+            add_offense(range, message: MSG_ITBLOCK) do |corrector|
               corrector.replace(range, 'sort')
             end
           end
@@ -54,6 +65,11 @@ module RuboCop
           (numblock $(call _ :sort_by) 1 (lvar :_1))
         PATTERN
 
+        # @!method redundant_sort_by_itblock(node)
+        def_node_matcher :redundant_sort_by_itblock, <<~PATTERN
+          (itblock $(call _ :sort_by) _ (lvar :it))
+        PATTERN
+
         def sort_by_range(send, node)
           range_between(send.loc.selector.begin_pos, node.loc.end.end_pos)
         end

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

@@ -155,7 +155,7 @@ module RuboCop
         end
 
         def preferred_delimiters
-          config.for_cop('Style/PercentLiteralDelimiters') ['PreferredDelimiters']['%r'].chars
+          config.for_cop('Style/PercentLiteralDelimiters')['PreferredDelimiters']['%r'].chars
         end
 
         def allowed_omit_parentheses_with_percent_r_literal?(node)

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

@@ -67,11 +67,13 @@ module RuboCop
           node.parent && parentheses?(node.parent)
         end
 
+        # rubocop:disable Metrics/AbcSize
         def correct_rescue_block(corrector, node, parenthesized)
           operation = node.body
 
           node_indentation, node_offset = indentation_and_offset(node, parenthesized)
 
+          corrector.wrap(operation, '[', ']') if operation.array_type? && !operation.bracketed?
           corrector.remove(range_between(operation.source_range.end_pos, node.source_range.end_pos))
           corrector.insert_before(operation, "begin\n#{node_indentation}")
           corrector.insert_after(heredoc_end(operation) || operation, <<~RESCUE_CLAUSE.chop)
@@ -81,6 +83,7 @@ module RuboCop
             #{node_offset}end
           RESCUE_CLAUSE
         end
+        # rubocop:enable Metrics/AbcSize
 
         def indentation_and_offset(node, parenthesized)
           node_indentation = indentation(node)

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

@@ -47,7 +47,7 @@ module RuboCop
 
         def on_return(node)
           # Check Lint/NonLocalExitFromIterator first before this cop
-          node.each_ancestor(:block, :def, :defs) do |n|
+          node.each_ancestor(:block, :any_def) do |n|
             break if scoped_node?(n)
 
             send_node, args_node, _body_node = *n
@@ -83,7 +83,7 @@ module RuboCop
         end
 
         def scoped_node?(node)
-          node.type?(:def, :defs) || node.lambda?
+          node.any_def_type? || node.lambda?
         end
 
         # @!method chained_send?(node)

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

@@ -86,6 +86,10 @@ module RuboCop
       #   foo.baz = bar if foo
       #   foo.baz + bar if foo
       #   foo.bar > 2 if foo
+      #
+      #   foo ? foo[index] : nil    # Ignored `foo&.[](index)` due to unclear readability benefit.
+      #   foo ? foo[idx] = v : nil  # Ignored `foo&.[]=(idx, v)` due to unclear readability benefit.
+      #   foo ? foo * 42 : nil      # Ignored `foo&.*(42)` due to unclear readability benefit.
       class SafeNavigation < Base # rubocop:disable Metrics/ClassLength
         include NilMethods
         include RangeHelp
@@ -138,6 +142,7 @@ module RuboCop
         # @!method strip_begin(node)
         def_node_matcher :strip_begin, '{ (begin $!begin) $!(begin) }'
 
+        # rubocop:disable Metrics/AbcSize
         def on_if(node)
           return if allowed_if_condition?(node)
 
@@ -146,13 +151,16 @@ module RuboCop
 
           body = extract_if_body(node)
           method_call = receiver.parent
+          return if dotless_operator_call?(method_call) || method_call.double_colon?
 
           removal_ranges = [begin_range(node, body), end_range(node, body)]
 
           report_offense(node, method_chain, method_call, *removal_ranges) do |corrector|
+            corrector.replace(receiver, checked_variable.source) if checked_variable.csend_type?
             corrector.insert_before(method_call.loc.dot, '&') unless method_call.safe_navigation?
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         def on_and(node) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
           collect_and_clauses(node).each do |(lhs, lhs_operator_range), (rhs, _rhs_operator_range)|
@@ -174,12 +182,19 @@ module RuboCop
               range_with_surrounding_space(range: lhs.source_range, side: :right),
               range_with_surrounding_space(range: lhs_operator_range, side: :right),
               offense_range: range_between(lhs.source_range.begin_pos, rhs.source_range.end_pos)
-            )
+            ) do |corrector|
+              corrector.replace(rhs_receiver, lhs_receiver.source)
+            end
+            ignore_node(node)
           end
         end
 
+        private
+
         def report_offense(node, rhs, rhs_receiver, *removal_ranges, offense_range: node)
           add_offense(offense_range) do |corrector|
+            next if ignored_node?(node)
+
             # If the RHS is an `or` we cannot safely autocorrect because in order to remove
             # the non-nil check we need to add safe-navs to all clauses where the receiver is used
             next if and_with_rhs_or?(node)
@@ -193,8 +208,6 @@ module RuboCop
           end
         end
 
-        private
-
         def find_method_chain(node)
           return node unless node&.parent&.call_type?
 
@@ -227,10 +240,10 @@ module RuboCop
         end
 
         def offending_node?(node, lhs_receiver, rhs, rhs_receiver) # rubocop:disable Metrics/CyclomaticComplexity
-          return false if lhs_receiver != rhs_receiver || rhs_receiver.nil?
+          return false if !matching_nodes?(lhs_receiver, rhs_receiver) || rhs_receiver.nil?
           return false if use_var_only_in_unless_modifier?(node, lhs_receiver)
           return false if chain_length(rhs, rhs_receiver) > max_chain_length
-          return false if unsafe_method_used?(rhs, rhs_receiver.parent)
+          return false if unsafe_method_used?(node, rhs, rhs_receiver.parent)
           return false if rhs.send_type? && rhs.method?(:empty?)
 
           true
@@ -248,6 +261,20 @@ module RuboCop
           end
         end
 
+        def dotless_operator_call?(method_call)
+          return true if dotless_operator_method?(method_call)
+
+          method_call = method_call.parent while method_call.parent.send_type?
+
+          dotless_operator_method?(method_call)
+        end
+
+        def dotless_operator_method?(method_call)
+          return false if method_call.loc.dot
+
+          method_call.method?(:[]) || method_call.method?(:[]=) || method_call.operator_method?
+        end
+
         def handle_comments(corrector, node, method_call)
           comments = comments(node)
           return if comments.empty?
@@ -306,11 +333,29 @@ module RuboCop
 
           receiver = method_chain.receiver
 
-          return receiver if receiver == checked_variable
+          return receiver if matching_nodes?(receiver, checked_variable)
 
           find_matching_receiver_invocation(receiver, checked_variable)
         end
 
+        def matching_nodes?(left, right)
+          left == right || matching_call_nodes?(left, right)
+        end
+
+        def matching_call_nodes?(left, right)
+          return false unless left && right.respond_to?(:call_type?)
+          return false unless left.call_type? && right.call_type?
+
+          # Compare receiver and method name, but ignore the difference between
+          # safe navigation method call (`&.`) and dot method call (`.`).
+          left_receiver, left_method, *left_args = left.children
+          right_receiver, right_method, *right_args = right.children
+
+          left_method == right_method &&
+            matching_nodes?(left_receiver, right_receiver) &&
+            left_args == right_args
+        end
+
         def chain_length(method_chain, method)
           method.each_ancestor(:call).inject(0) do |total, ancestor|
             break total + 1 if ancestor == method_chain
@@ -319,21 +364,24 @@ module RuboCop
           end
         end
 
-        def unsafe_method_used?(method_chain, method)
-          return true if unsafe_method?(method)
+        def unsafe_method_used?(node, method_chain, method)
+          return true if unsafe_method?(node, method)
 
           method.each_ancestor(:send).any? do |ancestor|
             break true unless config.cop_enabled?('Lint/SafeNavigationChain')
 
-            break true if unsafe_method?(ancestor)
+            break true if unsafe_method?(node, ancestor)
             break true if nil_methods.include?(ancestor.method_name)
             break false if ancestor == method_chain
           end
         end
 
-        def unsafe_method?(send_node)
-          negated?(send_node) ||
-            send_node.assignment? ||
+        def unsafe_method?(node, send_node)
+          return true if negated?(send_node)
+
+          return false if node.respond_to?(:ternary?) && node.ternary?
+
+          send_node.assignment? ||
             (!send_node.dot? && !send_node.safe_navigation?)
         end
 
@@ -362,8 +410,7 @@ module RuboCop
                                                  method_chain)
           start_method.each_ancestor do |ancestor|
             break unless %i[send block].include?(ancestor.type)
-            next unless ancestor.send_type?
-            next if ancestor.safe_navigation?
+            next if !ancestor.send_type? || ancestor.operator_method?
 
             corrector.insert_before(ancestor.loc.dot, '&')
 

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

@@ -59,6 +59,7 @@ module RuboCop
           {
             (block call (args (arg $_)) ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
             (numblock call $1 ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
+            (itblock call $_ ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
           }
         PATTERN
 
@@ -137,6 +138,7 @@ module RuboCop
           return unless (block_arg_name, regexp_method_send_node = regexp_match?(block_node))
 
           block_arg_name = :"_#{block_arg_name}" if block_node.numblock_type?
+
           return unless calls_lvar?(regexp_method_send_node, block_arg_name)
 
           regexp_method_send_node
@@ -150,7 +152,8 @@ module RuboCop
           return node.child_nodes.first if node.match_with_lvasgn_type?
 
           if node.receiver.lvar_type? &&
-             (block.numblock_type? || node.receiver.source == block.first_argument.source)
+             (block.type?(:numblock, :itblock) ||
+              node.receiver.source == block.first_argument.source)
             node.first_argument
           elsif node.first_argument.lvar_type?
             node.receiver