rubocop 1.90.0 → 1.92.0

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

@@ -49,7 +49,7 @@ module RuboCop
         end
 
         def replaced_exploded(node, command, message)
-          arg = string_message?(message) ? message.source : "#{message.source}.to_s"
+          arg = message_source(message)
           arg = node.parenthesized? ? "(#{arg})" : " #{arg}"
           "#{command}#{arg}"
         end
@@ -63,19 +63,31 @@ module RuboCop
             next if message.nil_type?
 
             add_offense(node, message: MSG_2) do |corrector|
-              corrector.replace(new_call, replaced_compact(message))
+              corrector.replace(new_call, message_source(message))
             end
           end
         end
 
-        def replaced_compact(message)
+        def message_source(message)
           if string_message?(message)
             message.source
+          elsif require_parentheses?(message)
+            "(#{message.source}).to_s"
           else
             "#{message.source}.to_s"
           end
         end
 
+        def require_parentheses?(message)
+          if message.call_type?
+            !message.method?(:[]) &&
+              (message.operator_method? || (message.arguments? && !message.parenthesized?))
+          else
+            !(message.basic_literal? || message.variable? ||
+              message.type?(:const, :self, :begin, :array))
+          end
+        end
+
         # @!method exploded?(node)
         def_node_matcher :exploded?, <<~PATTERN
           (send nil? ${:raise :fail} (const {nil? cbase} :RuntimeError) $_)

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

@@ -52,7 +52,7 @@ module RuboCop
             ${nil? basic_literal? const_type?})
         PATTERN
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler -- the matched body is a literal or a constant
           redundant_fetch_block_candidate?(node) do |send, body|
             return if should_not_check?(send, body)
 
@@ -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

@@ -57,12 +57,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_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)
@@ -170,7 +171,10 @@ module RuboCop
             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)
+          if argument_of_parenthesized_method_call?(begin_node, node) &&
+             !keyword_logical_operator?(node)
+            return 'a method argument'
+          end
           return 'a one-line rescue' if oneline_rescue_parentheses_required?(begin_node, node)
 
           return if begin_node.chained?
@@ -229,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?
 
@@ -315,6 +329,13 @@ module RuboCop
             (node.end.nil? && begin_node == parent.children.last)
         end
 
+        # `and`/`or` keyword operators bind looser than the method-argument
+        # boundary, so `foo((x and y))` cannot drop its parentheses without
+        # becoming a syntax error (unlike `&&`/`||`).
+        def keyword_logical_operator?(node)
+          node.operator_keyword? && node.semantic_operator?
+        end
+
         def disallowed_one_line_pattern_matching?(begin_node, node)
           if (parent = begin_node.parent)
             return false if parent.any_def_type? && parent.endless?

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_character_class.rb

@@ -74,7 +74,7 @@ module RuboCop
 
           non_redundant =
             whitespace_in_free_space_mode?(node, class_elem) ||
-            backslash_b?(class_elem) || octal_requiring_char_class?(class_elem) ||
+            backslash_b?(class_elem) || backreference_requiring_char_class?(class_elem) ||
             requires_escape_outside_char_class?(class_elem)
 
           !non_redundant
@@ -104,10 +104,11 @@ module RuboCop
           elem == '\b'
         end
 
-        def octal_requiring_char_class?(elem)
-          # The octal escapes \1 to \7 only work inside a character class
-          # because they would be a backreference outside it.
-          elem.match?(/\A\\[1-7]\z/)
+        def backreference_requiring_char_class?(elem)
+          # `\1` to `\9` only match a literal digit inside a character class;
+          # outside it they are backreferences (and a syntax error when the
+          # referenced group does not exist), so the class is not redundant.
+          elem.match?(/\A\\[1-9]\z/)
         end
 
         def requires_escape_outside_char_class?(elem)

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

@@ -27,19 +27,39 @@ module RuboCop
         def_node_matcher :redundant_regexp_constructor, <<~PATTERN
           (send
             (const {nil? cbase} :Regexp) {:new :compile}
-            (regexp $... (regopt $...)))
+            $(regexp _* (regopt _*)))
         PATTERN
 
         def on_send(node)
-          return unless (regexp, regopt = redundant_regexp_constructor(node))
+          return unless (regexp = redundant_regexp_constructor(node))
 
           add_offense(node, message: format(MSG, method: node.method_name)) do |corrector|
-            pattern = regexp.map(&:source).join
-            regopt = regopt.join
+            next if ambiguous_slash_regexp?(node, regexp)
 
-            corrector.replace(node, "/#{pattern}/#{regopt}")
+            # 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/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
@@ -112,6 +114,13 @@ module RuboCop
           end
         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)

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

@@ -54,6 +54,9 @@ 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)
+
             parenthesized = parenthesized?(rescue_node)
 
             correct_rescue_block(corrector, rescue_node, parenthesized)
@@ -95,15 +98,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)

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

@@ -98,22 +98,23 @@ module RuboCop
           second.int_type? ? second.to_a.first : :unknown
         end
 
-        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def range_size(range_node)
-          vals = range_node.to_a
-          return :unknown unless vals.all? { |val| val.nil? || val.int_type? }
-
-          low, high = vals.map { |val| val.nil? ? 0 : val.children[0] }
-          return :unknown unless low.zero? && high >= 0
+          low, high = range_node.to_a
+          # An endless range takes the rest of the collection, whatever its size.
+          return :unknown unless zero_or_beginless?(low) && high&.int_type? && high.value >= 0
 
           case range_node.type
           when :erange
-            (low...high).size
+            high.value
           when :irange
-            (low..high).size
+            high.value + 1
           end
         end
 
+        def zero_or_beginless?(low)
+          low.nil? || (low.int_type? && low.value.zero?)
+        end
+
         def source_range(shuffle_node, node)
           shuffle_node.loc.selector.join(node.source_range.end)
         end

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

@@ -37,15 +37,20 @@ module RuboCop
         private
 
         def check(node, var_type)
-          return unless (rhs = node.expression)
+          return unless (rhs = unparenthesized(node.expression))
 
           if rhs.send_type? && rhs.arguments.one?
             check_send_node(node, rhs, node.name, var_type)
-          elsif rhs.operator_keyword?
+          elsif rhs.operator_keyword? && rhs.logical_operator?
             check_boolean_node(node, rhs, node.name, var_type)
           end
         end
 
+        def unparenthesized(node)
+          node = node.children.first while node&.begin_type? && node.children.one?
+          node
+        end
+
         def check_send_node(node, rhs, var_name, var_type)
           return unless OPS.include?(rhs.method_name)
 
@@ -68,26 +73,18 @@ module RuboCop
         end
 
         def autocorrect(corrector, node)
-          rhs = node.expression
+          rhs = unparenthesized(node.expression)
 
           if rhs.send_type?
-            autocorrect_send_node(corrector, node, rhs)
+            apply_autocorrect(corrector, node, rhs.method_name, rhs.first_argument)
           elsif rhs.operator_keyword?
-            autocorrect_boolean_node(corrector, node, rhs)
+            apply_autocorrect(corrector, node, rhs.loc.operator.source, rhs.rhs)
           end
         end
 
-        def autocorrect_send_node(corrector, node, rhs)
-          apply_autocorrect(corrector, node, rhs, rhs.method_name, rhs.first_argument)
-        end
-
-        def autocorrect_boolean_node(corrector, node, rhs)
-          apply_autocorrect(corrector, node, rhs, rhs.loc.operator.source, rhs.rhs)
-        end
-
-        def apply_autocorrect(corrector, node, rhs, operator, new_rhs)
+        def apply_autocorrect(corrector, node, operator, new_rhs)
           corrector.insert_before(node.loc.operator, operator)
-          corrector.replace(rhs, new_rhs.source)
+          corrector.replace(node.expression, new_rhs.source)
         end
       end
     end

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

@@ -121,7 +121,6 @@ module RuboCop
           tokens[1]&.type == :tSTRING_DBEG && tokens[2]&.semicolon?
         end
 
-        # rubocop:disable-next Metrics/AbcSize, Metrics/MethodLength
         def register_semicolon(line, column, after_expression, token_before_semicolon = nil)
           range = source_range(processed_source.buffer, line, column)
 
@@ -134,13 +133,11 @@ module RuboCop
               # See: https://github.com/rubocop/rubocop/issues/10791
               if token_before_semicolon&.regexp_dots?
                 node = find_node(range_nodes, token_before_semicolon)
+                corrector.wrap(node, '(', ')') if node
               elsif token_before_semicolon&.type == :tLABEL
-                node = find_node(value_omission_pair_nodes, token_before_semicolon).parent
-                space = node.parent.loc.selector.end.join(node.source_range.begin)
-                corrector.remove(space)
+                parenthesize_arguments(corrector, value_omission_hash(token_before_semicolon))
               end
 
-              corrector.wrap(node, '(', ')') if node
               corrector.remove(range)
             end
           end
@@ -161,6 +158,20 @@ module RuboCop
           end
         end
 
+        def value_omission_hash(token_before_semicolon)
+          find_node(value_omission_pair_nodes, token_before_semicolon)&.parent
+        end
+
+        def parenthesize_arguments(corrector, hash_node)
+          return unless hash_node
+
+          call = hash_node.parent
+          before_arguments = args_begin(call).begin.join(call.first_argument.source_range.begin)
+
+          corrector.replace(before_arguments, '(')
+          corrector.insert_after(call.last_argument, ')')
+        end
+
         def expressions_per_line(exprs)
           # create a map matching lines to the number of expressions on them
           exprs_lines = exprs.map(&:last_line)

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

@@ -33,7 +33,7 @@ module RuboCop
 
         MSG = 'Name `%<method>s` block params `|%<params>s|`.'
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler -- checks block parameter names
           return unless node.single_line?
 
           return unless eligible_method?(node)