rubocop 1.91.0 → 1.92.0

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

@@ -78,7 +78,10 @@ module RuboCop
         ].freeze
 
         def on_if(node)
-          return if node.modifier_form? || node.elsif_conditional? || !offense?(node)
+          return unless redundant_condition_offense?(node)
+          return if node.each_ancestor(:if).any? do |ancestor|
+            redundant_condition_offense?(ancestor)
+          end
 
           message = message(node)
 
@@ -89,6 +92,10 @@ module RuboCop
 
         private
 
+        def redundant_condition_offense?(node)
+          !node.modifier_form? && !node.elsif_conditional? && offense?(node)
+        end
+
         def message(node)
           if redundant_condition?(node)
             REDUNDANT_CONDITION
@@ -240,10 +247,10 @@ module RuboCop
         end
 
         # rubocop:disable-next Metrics/AbcSize
-        def if_source(if_branch, arithmetic_operation)
+        def if_source(if_branch, binary_operator)
           if branches_have_method?(if_branch.parent) && if_branch.parenthesized?
             if_branch.source.delete_suffix(')')
-          elsif arithmetic_operation
+          elsif binary_operator
             argument_source = if_branch.first_argument.source
 
             "#{if_branch.receiver.source} #{if_branch.method_name} (#{argument_source}"
@@ -257,8 +264,8 @@ module RuboCop
           end
         end
 
-        def else_source(else_branch, arithmetic_operation) # rubocop:disable Metrics/AbcSize
-          if arithmetic_operation
+        def else_source(else_branch, binary_operator) # rubocop:disable Metrics/AbcSize
+          if binary_operator
             "#{else_branch.first_argument.source})"
           elsif branches_have_method?(else_branch.parent)
             else_source_if_has_method(else_branch)
@@ -295,11 +302,11 @@ module RuboCop
 
         def make_ternary_form(node)
           _condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring -- takes all three branches in one step
-          arithmetic_operation = use_arithmetic_operation?(if_branch)
+          binary_operator = branches_have_method?(node) && binary_operator?(if_branch)
 
           ternary_form = [
-            if_source(if_branch, arithmetic_operation),
-            else_source(else_branch, arithmetic_operation)
+            if_source(if_branch, binary_operator),
+            else_source(else_branch, binary_operator)
           ].join(' || ')
           ternary_form += ')' if branches_have_method?(node) && if_branch.parenthesized?
 
@@ -320,17 +327,27 @@ module RuboCop
 
         def require_parentheses?(node)
           (node.basic_conditional? && node.modifier_form?) ||
-            node.range_type? ||
-            node.rescue_type? ||
-            (node.respond_to?(:semantic_operator?) && node.semantic_operator?)
+            node.range_type? || node.rescue_type? ||
+            (node.respond_to?(:semantic_operator?) && node.semantic_operator?) ||
+            low_precedence_keyword?(node)
+        end
+
+        # e.g. `not foo`, `return foo`, and `yield foo`
+        def low_precedence_keyword?(node)
+          return node.prefix_not? if node.send_type?
+
+          node.type?(:return, :next, :break, :yield, :super) &&
+            node.arguments? && !node.parenthesized?
         end
 
         def require_braces?(node)
           node.hash_type? && !node.braces?
         end
 
-        def use_arithmetic_operation?(node)
-          node.respond_to?(:arithmetic_operation?) && node.arithmetic_operation?
+        # Any binary operator binds tighter than `||`, so the fallback must be
+        # parenthesized as its argument, e.g. `stack << (foo || :new)`.
+        def binary_operator?(node)
+          node.binary_operation? && !node.dot?
         end
 
         def without_argument_parentheses_method?(node)

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

@@ -25,6 +25,12 @@ module RuboCop
         MSG = 'Remove the redundant double splat and braces, use keyword arguments directly.'
         MERGE_METHODS = %i[merge merge!].freeze
 
+        # `Style/TrailingCommaInHashLiteral` adds a comma to the hash literal whose braces
+        # this cop removes in the same pass, which would leave a dangling comma.
+        def self.autocorrect_incompatible_with
+          [Style::TrailingCommaInHashLiteral]
+        end
+
         # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_hash(node)
           return if node.pairs.empty? || node.pairs.any?(&:hash_rocket?)

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

@@ -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)
@@ -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/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