rubocop 1.69.0 → 1.76.1

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

@@ -11,6 +11,9 @@ module RuboCop
       # will not register an offense, because it allows the initializer to take a different
       # number of arguments as its superclass potentially does.
       #
+      # NOTE: If an initializer takes any arguments and has an empty body, RuboCop
+      # assumes it to *not* be redundant. This is to prevent potential `ArgumentError`.
+      #
       # NOTE: If an initializer argument has a default value, RuboCop assumes it
       # to *not* be redundant.
       #
@@ -19,8 +22,10 @@ module RuboCop
       # initializer.
       #
       # @safety
-      #   This cop is unsafe because if subclass overrides `initialize` method with
-      #   a different arity than superclass.
+      #   This cop is unsafe because removing an empty initializer may alter
+      #   the behavior of the code, particularly if the superclass initializer
+      #   raises an exception. In such cases, the empty initializer may act as
+      #   a safeguard to prevent unintended errors from propagating.
       #
       # @example
       #   # bad
@@ -69,6 +74,10 @@ module RuboCop
       #   end
       #
       #   # good (changes the parameter requirements)
+      #   def initialize(_)
+      #   end
+      #
+      #   # good (changes the parameter requirements)
       #   def initialize(*)
       #   end
       #
@@ -111,7 +120,7 @@ module RuboCop
           return if acceptable?(node)
 
           if node.body.nil?
-            register_offense(node, MSG_EMPTY)
+            register_offense(node, MSG_EMPTY) if node.arguments.empty?
           else
             return if node.body.begin_type?
 

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

@@ -73,10 +73,15 @@ module RuboCop
         LINE_CONTINUATION_PATTERN = /(\\\n)/.freeze
         ALLOWED_STRING_TOKENS = %i[tSTRING tSTRING_CONTENT].freeze
         ARGUMENT_TYPES = %i[
-          kFALSE kNIL kSELF kTRUE tCONSTANT tCVAR tFLOAT tGVAR tIDENTIFIER tINTEGER tIVAR
-          tLBRACK tLCURLY tLPAREN_ARG tSTRING tSTRING_BEG tSYMBOL tXSTRING_BEG
+          kDEF kDEFINED kFALSE kNIL kSELF kTRUE tAMPER tBANG tCARET tCHARACTER tCOLON3 tCONSTANT
+          tCVAR tDOT2 tDOT3 tFLOAT tGVAR tIDENTIFIER tINTEGER tIVAR tLAMBDA tLBRACK tLCURLY
+          tLPAREN_ARG tPIPE tQSYMBOLS_BEG tQWORDS_BEG tREGEXP_BEG tSTAR tSTRING tSTRING_BEG tSYMBEG
+          tSYMBOL tSYMBOLS_BEG tTILDE tUMINUS tUNARY_NUM tUPLUS tWORDS_BEG tXSTRING_BEG
         ].freeze
-        ARGUMENT_TAKING_FLOW_TOKEN_TYPES = %i[tIDENTIFIER kRETURN kBREAK kNEXT kYIELD].freeze
+        ARGUMENT_TAKING_FLOW_TOKEN_TYPES = %i[
+          tIDENTIFIER kBREAK kNEXT kRETURN kSUPER kYIELD
+        ].freeze
+        ARITHMETIC_OPERATOR_TOKENS = %i[tDIVIDE tDSTAR tMINUS tPERCENT tPLUS tSTAR2].freeze
 
         def on_new_investigation
           return unless processed_source.ast
@@ -96,15 +101,20 @@ module RuboCop
         private
 
         def require_line_continuation?(range)
-          !ends_with_backslash_without_comment?(range.source_line) ||
+          !ends_with_uncommented_backslash?(range) ||
             string_concatenation?(range.source_line) ||
-            start_with_arithmetic_operator?(processed_source[range.line]) ||
+            start_with_arithmetic_operator?(range) ||
             inside_string_literal_or_method_with_argument?(range) ||
             leading_dot_method_chain_with_blank_line?(range)
         end
 
-        def ends_with_backslash_without_comment?(source_line)
-          source_line.gsub(/#.+/, '').end_with?('\\')
+        def ends_with_uncommented_backslash?(range)
+          # A line continuation always needs to be the last character on the line, which
+          # means that it is impossible to have a comment following a continuation.
+          # Therefore, if the line contains a comment, it cannot end with a continuation.
+          return false if processed_source.line_with_comment?(range.line)
+
+          range.source_line.end_with?(LINE_CONTINUATION)
         end
 
         def string_concatenation?(source_line)
@@ -112,10 +122,13 @@ module RuboCop
         end
 
         def inside_string_literal_or_method_with_argument?(range)
+          line_range = range_by_whole_lines(range)
+
           processed_source.tokens.each_cons(2).any? do |token, next_token|
             next if token.line == next_token.line
 
-            inside_string_literal?(range, token) || method_with_argument?(token, next_token)
+            inside_string_literal?(range, token) ||
+              method_with_argument?(line_range, token, next_token)
           end
         end
 
@@ -129,16 +142,15 @@ module RuboCop
           return true unless (node = find_node_for_line(range.last_line))
           return false if argument_newline?(node)
 
-          source = node.source
-          while (node = node.parent)
-            source = node.source
-          end
-          parse(source.gsub("\\\n", "\n")).valid_syntax?
+          # Check if source is still valid without the continuation
+          source = processed_source.raw_source.dup
+          source[range.begin_pos, range.length] = "\n"
+          parse(source).valid_syntax?
         end
 
         def inspect_end_of_ruby_code_line_continuation
           last_line = processed_source.lines[processed_source.ast.last_line - 1]
-          return unless last_line.end_with?(LINE_CONTINUATION)
+          return unless code_ends_with_continuation?(last_line)
 
           last_column = last_line.length
           line_continuation_range = range_between(last_column - 1, last_column)
@@ -148,6 +160,12 @@ module RuboCop
           end
         end
 
+        def code_ends_with_continuation?(last_line)
+          return false if processed_source.line_with_comment?(processed_source.ast.last_line)
+
+          last_line.end_with?(LINE_CONTINUATION)
+        end
+
         def inside_string_literal?(range, token)
           ALLOWED_STRING_TOKENS.include?(token.type) && token.pos.overlaps?(range)
         end
@@ -156,15 +174,14 @@ module RuboCop
         #
         #   do_something \
         #     argument
-        def method_with_argument?(current_token, next_token)
+        def method_with_argument?(line_range, current_token, next_token)
           return false unless ARGUMENT_TAKING_FLOW_TOKEN_TYPES.include?(current_token.type)
+          return false unless current_token.pos.overlaps?(line_range)
 
           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?
@@ -177,11 +194,10 @@ 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|
-            return node if node.respond_to?(:expression) && node.expression&.last_line == last_line
+            return node if same_line?(node, last_line)
           end
         end
 
@@ -210,8 +226,9 @@ module RuboCop
           node.call_type? && !node.arguments.empty?
         end
 
-        def start_with_arithmetic_operator?(source_line)
-          %r{\A\s*[+\-*/%]}.match?(source_line)
+        def start_with_arithmetic_operator?(range)
+          line_range = processed_source.buffer.line_range(range.line + 1)
+          ARITHMETIC_OPERATOR_TOKENS.include?(processed_source.first_token_of(line_range).type)
         end
       end
     end

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

@@ -13,14 +13,16 @@ module RuboCop
       #   # good
       #   x if y.z.nil?
       #
-      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?, '(send {(send _recv _msg) str array hash} :[] ...)'
+        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 $...)'
@@ -39,10 +41,15 @@ module RuboCop
 
         private
 
+        def variable?(node)
+          node.respond_to?(:variable?) && node.variable?
+        end
+
         def parens_allowed?(node)
           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
@@ -50,7 +57,7 @@ module RuboCop
         def ignore_syntax?(node)
           return false unless (parent = node.parent)
 
-          parent.while_post_type? || parent.until_post_type? || parent.match_with_lvasgn_type? ||
+          parent.type?(:while_post, :until_post, :match_with_lvasgn) ||
             like_method_argument_parentheses?(parent) || multiline_control_flow_statements?(node)
         end
 
@@ -72,7 +79,7 @@ module RuboCop
           ancestor = node.ancestors.first
           return false unless ancestor
 
-          !ancestor.begin_type? && !ancestor.def_type? && !ancestor.block_type?
+          !ancestor.type?(:begin, :any_def, :any_block)
         end
 
         def allowed_ternary?(node)
@@ -89,17 +96,17 @@ module RuboCop
         end
 
         def like_method_argument_parentheses?(node)
-          return false if !node.send_type? && !node.super_type? && !node.yield_type?
+          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)
           return false unless (parent = node.parent)
           return false if parent.single_line?
 
-          parent.return_type? || parent.next_type? || parent.break_type?
+          parent.type?(:return, :next, :break)
         end
 
         def empty_parentheses?(node)
@@ -116,6 +123,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?
@@ -128,6 +142,10 @@ module RuboCop
           node = begin_node.children.first
 
           if (message = find_offense_message(begin_node, node))
+            if node.range_type? && !argument_of_parenthesized_method_call?(begin_node, node)
+              begin_node = begin_node.parent
+            end
+
             return offense(begin_node, message)
           end
 
@@ -137,13 +155,20 @@ module RuboCop
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def find_offense_message(begin_node, node)
           return 'a keyword' if keyword_with_redundant_parentheses?(node)
-          return 'a literal' if disallowed_literal?(begin_node, node)
+          return 'a literal' if node.literal? && disallowed_literal?(begin_node, node)
           return 'a variable' if node.variable?
           return 'a constant' if node.const_type?
+          if node.assignment? && (begin_node.parent.nil? || begin_node.parent.begin_type?)
+            return 'an assignment'
+          end
           if node.lambda_or_proc? && (node.braces? || node.send_node.lambda_literal?)
             return 'an expression'
           end
+          if node.any_match_pattern_type? && node.each_ancestor.none?(&:operator_keyword?)
+            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 if begin_node.chained?
 
@@ -151,6 +176,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'
@@ -165,11 +191,23 @@ module RuboCop
         # @!method interpolation?(node)
         def_node_matcher :interpolation?, '[^begin ^^dstr]'
 
-        def allow_in_multiline_conditions?
-          parentheses_around_condition_config = config.for_cop('Style/ParenthesesAroundCondition')
-          return false unless parentheses_around_condition_config['Enabled']
+        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)
 
-          !!parentheses_around_condition_config['AllowInMultilineConditions']
+          parent.call_type? && parent.parenthesized? && parent.receiver != begin_node
+        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 check_send(begin_node, node)
@@ -207,7 +245,13 @@ module RuboCop
         end
 
         def disallowed_literal?(begin_node, node)
-          node.literal? && !node.range_type? && !raised_to_power_negative_numeric?(begin_node, node)
+          if node.range_type?
+            return false unless (parent = begin_node.parent)
+
+            parent.begin_type? && parent.children.one?
+          else
+            !raised_to_power_negative_numeric?(begin_node, node)
+          end
         end
 
         def raised_to_power_negative_numeric?(begin_node, node)
@@ -244,7 +288,7 @@ module RuboCop
         end
 
         def only_begin_arg?(args)
-          args.one? && args.first.begin_type?
+          args.one? && args.first&.begin_type?
         end
 
         def first_argument?(node)
@@ -279,9 +323,9 @@ module RuboCop
         end
 
         def do_end_block_in_method_chain?(begin_node, node)
-          return false unless (block = node.each_descendant(:block, :numblock).first)
+          return false unless (block = node.each_descendant(:any_block).first)
 
-          block.keywords? && begin_node.each_ancestor(:send, :csend).any?
+          block.keywords? && begin_node.each_ancestor(:call).any?
         end
       end
     end

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

@@ -73,6 +73,9 @@ module RuboCop
             new_argument.gsub!("'", "\\\\'")
             new_argument.gsub!('\"', '"')
             quote = "'"
+          elsif new_argument.include?('\'')
+            new_argument.gsub!("'", "\\\\'")
+            quote = "'"
           elsif new_argument.include?('\\')
             quote = '"'
           else

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for unnecessary single-element Regexp character classes.
+      # Checks for unnecessary single-element `Regexp` character classes.
       #
       # @example
       #

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for redundant escapes inside Regexp literals.
+      # Checks for redundant escapes inside `Regexp` literals.
       #
       # @example
       #   # bad

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

@@ -118,6 +118,7 @@ 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
@@ -175,7 +176,7 @@ module RuboCop
         def on_argument(node)
           if node.mlhs_type?
             on_args(node)
-          else
+          elsif node.respond_to?(:name)
             @local_variables_scopes[node] << node.name
           end
         end

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

@@ -21,12 +21,8 @@ module RuboCop
       #   args += foo
       #   hash.merge!(other)
       #
-      #   # bad
-      #   self.foo = foo.concat(ary)
-      #
       #   # good
       #   foo.concat(ary)
-      #   self.foo += ary
       #
       class RedundantSelfAssignment < Base
         include RangeHelp
@@ -49,10 +45,20 @@ module RuboCop
           gvasgn: :gvar
         }.freeze
 
+        # @!method redundant_self_assignment?
+        def_node_matcher :redundant_self_assignment?, <<~PATTERN
+          (call
+            %1 _
+            (call
+              (call
+                %1 %2) #method_returning_self?
+              ...))
+        PATTERN
+
         # rubocop:disable Metrics/AbcSize
         def on_lvasgn(node)
           return unless (rhs = node.rhs)
-          return unless rhs.send_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]
@@ -77,6 +83,7 @@ module RuboCop
             corrector.remove(correction_range(node))
           end
         end
+        alias on_csend on_send
 
         private
 
@@ -84,31 +91,10 @@ module RuboCop
           METHODS_RETURNING_SELF.include?(method_name)
         end
 
-        # @!method redundant_self_assignment?(node, method_name)
-        def_node_matcher :redundant_self_assignment?, <<~PATTERN
-          (send
-            (self) _
-            (send
-              (send
-                {(self) nil?} %1) #method_returning_self?
-              ...))
-        PATTERN
-
-        # @!method redundant_nonself_assignment?(node, receiver, method_name)
-        def_node_matcher :redundant_nonself_assignment?, <<~PATTERN
-          (send
-            %1 _
-            (send
-              (send
-                %1 %2) #method_returning_self?
-              ...))
-        PATTERN
-
         def redundant_assignment?(node)
-          receiver_name = node.method_name.to_s[0...-1].to_sym
+          receiver_name = node.method_name.to_s.delete_suffix('=').to_sym
 
-          redundant_self_assignment?(node, receiver_name) ||
-            redundant_nonself_assignment?(node, node.receiver, receiver_name)
+          redundant_self_assignment?(node, node.receiver, receiver_name)
         end
 
         def correction_range(node)

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

@@ -93,9 +93,9 @@ module RuboCop
             (call $(call _ $:sort_by _) ${:last :first})
             (send $(send _ $:sort_by _) ${:[] :at :slice} {(int 0) (int -1)})
 
-            (call ({block numblock} $(call _ ${:sort_by :sort}) ...) ${:last :first})
+            (call (any_block $(call _ ${:sort_by :sort}) ...) ${:last :first})
             (call
-              ({block numblock} $(call _ ${:sort_by :sort}) ...)
+              (any_block $(call _ ${:sort_by :sort}) ...)
               ${:[] :at :slice} {(int 0) (int -1)}
             )
           }

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/redundant_string_escape.rb

@@ -41,7 +41,7 @@ module RuboCop
         MSG = 'Redundant escape of %<char>s inside string literal.'
 
         def on_str(node)
-          return if node.parent&.regexp_type? || node.parent&.xstr_type? || node.character_literal?
+          return if node.parent&.type?(:regexp, :xstr) || node.character_literal?
 
           str_contents_range = str_contents_range(node)
 
@@ -147,7 +147,7 @@ module RuboCop
         end
 
         def heredoc?(node)
-          (node.str_type? || node.dstr_type?) && node.heredoc?
+          node.type?(:str, :dstr) && node.heredoc?
         end
 
         def delimiter?(node, char)

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.def_type? || node.defs_type? || node.lambda?
+          node.any_def_type? || node.lambda?
         end
 
         # @!method chained_send?(node)