rubocop 1.91.0 → 1.92.2

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

@@ -17,6 +17,7 @@ module RuboCop
       class MultilineIfModifier < Base
         include StatementModifier
         include Alignment
+        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Favor a normal %<keyword>s-statement over a modifier ' \
@@ -27,31 +28,70 @@ module RuboCop
           return unless node.modifier_form? && node.body.multiline?
 
           add_offense(node, message: format(MSG, keyword: node.keyword)) do |corrector|
-            corrector.replace(node, to_normal_if(node))
+            autocorrect(corrector, node)
           end
           ignore_node(node)
         end
 
         private
 
-        def to_normal_if(node)
+        def autocorrect(corrector, node)
+          condition_heredoc, body_heredoc = [node.condition, node.body].map do |part|
+            next unless (range = heredoc_after(part, node))
+
+            corrector.remove(range)
+            range.source.chomp
+          end
+          corrector.replace(node, to_normal_if(node, condition_heredoc, body_heredoc))
+        end
+
+        # Heredocs opened on the modifier line have their bodies after it, so
+        # they are moved along with the part of the `if` they belong to.
+        def heredoc_after(part, node)
+          ranges = part.each_node(:any_str).select(&:heredoc?).map do |heredoc|
+            heredoc.loc.heredoc_body.join(heredoc.loc.heredoc_end)
+          end
+          ranges.select! { |range| range.line > node.last_line }
+          return if ranges.empty?
+
+          range_by_whole_lines(ranges.reduce(:join), include_final_newline: true)
+        end
+
+        def to_normal_if(node, condition_heredoc, body_heredoc)
           indented_body = indented_body(node.body, node)
           condition = "#{node.keyword} #{node.condition.source}"
           indented_end = "#{offset(node)}end"
 
-          [condition, indented_body, indented_end].join("\n")
+          lines = [condition, condition_heredoc, indented_body, body_heredoc, indented_end]
+          lines.compact.join("\n")
         end
 
         def indented_body(body, node)
           body_source = "#{offset(node)}#{body.source}"
-          body_source.each_line.map do |line|
-            if line == "\n"
+          verbatim_lines = verbatim_lines_in(body)
+          body_source.each_line.with_index(body.first_line).map do |line, line_number|
+            if line == "\n" || verbatim_lines.include?(line_number)
               line
             else
               line.sub(/^\s{#{offset(node).length}}/, indentation(node))
             end
           end.join
         end
+
+        def verbatim_lines_in(body)
+          body.each_node(:any_str).filter_map { |str| verbatim_line_range(str) }.flat_map(&:to_a)
+        end
+
+        # The indentation of a line that starts inside a string is part of the
+        # string. Only squiggly heredocs strip it from their bodies, and a `<<`
+        # terminator has to stay at the start of its line.
+        def verbatim_line_range(str)
+          if str.heredoc?
+            str.loc.heredoc_body.line..str.loc.heredoc_end.line unless str.source.start_with?('<<~')
+          elsif str.loc?(:begin) && str.loc?(:end)
+            (str.first_line + 1)..str.last_line
+          end
+        end
       end
     end
   end

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

@@ -50,10 +50,17 @@ module RuboCop
         # Requires `then` for write `in` and its body on the same line.
         def require_then?(in_pattern_node)
           return true unless in_pattern_node.pattern.single_line?
+          return true if ends_with_endless_range?(in_pattern_node.pattern)
           return false unless in_pattern_node.body
 
           same_line?(in_pattern_node, in_pattern_node.body)
         end
+
+        def ends_with_endless_range?(node)
+          node.each_node(:range).any? do |range|
+            range.end.nil? && range.source_range.end_pos == node.source_range.end_pos
+          end
+        end
       end
     end
   end

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

@@ -27,6 +27,7 @@ module RuboCop
         def on_def(node)
           return unless node.arguments?
           return if opening_line(node) == closing_line(node)
+          return if node.arguments.any?(&:multiline?)
           return if correction_exceeds_max_line_length?(node)
           return unless (begin_of_arguments = node.arguments.loc.begin)
 
@@ -78,11 +79,7 @@ module RuboCop
         def correction_exceeds_max_line_length?(node)
           return false unless max_line_length
 
-          indentation_width(node) + definition_width(node) > max_line_length
-        end
-
-        def indentation_width(node)
-          processed_source.line_indentation(node.source_range.line)
+          node.source_range.column + definition_width(node) > max_line_length
         end
 
         def definition_width(node)

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

@@ -7,7 +7,8 @@ module RuboCop
       #
       # NOTE: `return if ... else ... end` is syntax error. If `return` is used before
       # multiline ternary operator expression, it will be autocorrected to single-line
-      # ternary operator. The same is true for `break`, `next`, and method call.
+      # ternary operator. The same is true for `break`, `next`, `yield`, `super`,
+      # `defined?` without parentheses, and method call.
       #
       # @example
       #   # bad
@@ -39,7 +40,7 @@ module RuboCop
 
         MSG_IF = 'Avoid multi-line ternary operators, use `if` or `unless` instead.'
         MSG_SINGLE_LINE = 'Avoid multi-line ternary operators, use single-line instead.'
-        SINGLE_LINE_TYPES = %i[return break next send csend].freeze
+        SINGLE_LINE_TYPES = %i[return break next send csend super yield].freeze
 
         def on_if(node)
           return unless offense?(node)
@@ -90,7 +91,10 @@ module RuboCop
         end
 
         def enforce_single_line_ternary_operator?(node)
-          SINGLE_LINE_TYPES.include?(node.parent&.type) && !use_assignment_method?(node.parent)
+          return false unless (parent = node.parent)
+          return !parent.parenthesized? if parent.defined_type?
+
+          SINGLE_LINE_TYPES.include?(parent.type) && !use_assignment_method?(parent)
         end
 
         def use_assignment_method?(node)

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

@@ -50,10 +50,17 @@ module RuboCop
           unless when_node.conditions.first.first_line == when_node.conditions.last.last_line
             return true
           end
+          return true if ends_with_endless_range?(when_node.conditions.last)
           return false unless when_node.body
 
           same_line?(when_node, when_node.body)
         end
+
+        def ends_with_endless_range?(node)
+          node.each_node(:range).any? do |range|
+            range.end.nil? && range.source_range.end_pos == node.source_range.end_pos
+          end
+        end
       end
     end
   end

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

@@ -146,6 +146,13 @@ module RuboCop
 
         MSG = 'Freeze mutable objects assigned to constants.'
 
+        # With `Recursive: true`, `.freeze` is appended to a nested literal. When the literal
+        # is the last element and spans multiple lines, the trailing comma lands between the literal
+        # and the `.freeze` appended in the same pass.
+        def self.autocorrect_incompatible_with
+          [Style::HashAsLastArrayItem, Style::TrailingCommaInArrayLiteral, Style::TrailingCommaInHashLiteral]
+        end
+
         def on_casgn(node)
           if node.expression.nil? # This is only the case for `CONST += ...` or similar
             parent = node.parent
@@ -188,10 +195,12 @@ module RuboCop
         end
 
         def strict_check(value)
+          return if value.assignment?
           return if immutable_literal?(value)
           return if operation_produces_immutable_object?(value)
           return if frozen_string_literal?(value)
           return if shareable_constant_value?(value)
+          return if parenthesized_immutable_value?(value)
 
           true
         end
@@ -219,15 +228,32 @@ module RuboCop
             return
           end
 
+          return expand_omitted_hash_value(corrector, node.parent) if omitted_hash_value?(node)
+
+          wrap_for_freeze(corrector, node, expr)
+          corrector.insert_after(expr, '.freeze')
+
+          freeze_nested_literals(corrector, node) if recursive?
+        end
+
+        def omitted_hash_value?(node)
+          node.parent&.pair_type? && node.parent.value_omission?
+        end
+
+        def expand_omitted_hash_value(corrector, pair)
+          key = pair.key.value
+
+          corrector.replace(pair, "#{key}: #{key}.freeze")
+        end
+
+        def wrap_for_freeze(corrector, node, expr)
           if node.array_type? && !node.bracketed?
             corrector.wrap(expr, '[', ']')
+          elsif node.hash_type? && !node.braces?
+            corrector.wrap(expr, '{ ', ' }')
           elsif requires_parentheses?(node)
             corrector.wrap(expr, '(', ')')
           end
-
-          corrector.insert_after(expr, '.freeze')
-
-          freeze_nested_literals(corrector, node) if recursive?
         end
 
         # Recursively freezes every nested mutable literal inside an array or
@@ -253,13 +279,14 @@ module RuboCop
         # Returns the child literals of an array or hash node that may
         # themselves need freezing. For hashes, both keys and values are
         # included. Percent-literal arrays (e.g. `%w(a b)`) are skipped because
-        # `.freeze` cannot be appended to their contents.
+        # `.freeze` cannot be appended to their contents. Splat elements are
+        # skipped because the splatted object is not stored in the array.
         def literal_children(node)
           case node.type
           when :array
             return [] if node.percent_literal?
 
-            node.children
+            node.children.reject(&:splat_type?)
           when :hash
             node.children.flat_map { |child| child.pair_type? ? child.children : [] }
           else
@@ -293,12 +320,30 @@ module RuboCop
           recent_shareable_value? node
         end
 
+        def parenthesized_immutable_value?(value)
+          return false if !value.begin_type? || !value.children.one?
+
+          inner = value.children.first
+
+          !inner.assignment? && !strict_check(inner)
+        end
+
         def frozen_regexp_or_range_literals?(node)
           target_ruby_version >= 3.0 && node.type?(:regexp, :range)
         end
 
         def requires_parentheses?(node)
-          node.range_type? || (node.send_type? && node.loc.dot.nil?)
+          if node.range_type? || node.operator_keyword? || unparenthesized_method_call?(node)
+            return true
+          end
+
+          node.if_type? && node.ternary?
+        end
+
+        def unparenthesized_method_call?(node)
+          return false unless node.call_type?
+
+          node.loc.dot.nil? || (node.arguments.any? && !node.parenthesized?)
         end
 
         def correct_splat_expansion(corrector, expr, splat_value)

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

@@ -118,7 +118,8 @@ module RuboCop
           if node.ternary?
             node.if_branch
           else
-            range_between(node.condition.source_range.end_pos, node.loc.else.begin_pos)
+            if_start = node.loc.begin || node.condition.source_range
+            range_between(if_start.end_pos, node.loc.else.begin_pos)
           end
         end
 

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

@@ -11,6 +11,13 @@ module RuboCop
       # and their combinations, allowing safe replacement when the receiver matches.
       # It works with variables, instance variables, class variables, and constants.
       #
+      # @safety
+      #   This cop is unsafe because the receiver may not be an Array. For a Hash,
+      #   `hash[hash.size - 1]` looks up the key `hash.size - 1`, which `hash[-1]`
+      #   does not. Even for an Array, `arr[arr.length - n]` wraps around to an
+      #   element from the end when `n` exceeds the length, while `arr[-n]`
+      #   returns `nil`.
+      #
       # @example
       #   # bad
       #   arr[arr.count - 2]
@@ -188,8 +195,9 @@ module RuboCop
             return false
           end
           return true if length_receiver.source == array_receiver.source
+          return false unless (base_receiver = extract_base_receiver(array_receiver))
 
-          !extract_base_receiver(array_receiver).nil?
+          base_receiver.source == (extract_base_receiver(length_receiver) || length_receiver).source
         end
 
         def receivers_match_strict?(length_receiver, array_receiver)

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

@@ -19,6 +19,19 @@ module RuboCop
 
         MSG = 'Avoid using nested modifiers.'
 
+        # Operands that would otherwise bind differently next to `&&`/`||`, or
+        # not parse at all.
+        # @!method low_precedence?(node)
+        def_node_matcher :low_precedence?, <<~PATTERN
+          {
+            [{and or} semantic_operator?]
+            [send prefix_not?]
+            [if ternary?]
+            assignment?
+            [{csend yield super} arguments? !parenthesized? !operator_method?]
+          }
+        PATTERN
+
         def on_while(node)
           check(node)
         end
@@ -63,8 +76,10 @@ module RuboCop
         end
 
         def left_hand_operand(node, operator)
-          expr = node.condition.source
-          expr = "(#{expr})" if node.condition.or_type? && operator == '&&'
+          expr = operand_source(node.condition)
+          if (node.condition.or_type? && operator == '&&') || low_precedence?(node.condition)
+            expr = "(#{expr})"
+          end
           expr
         end
 
@@ -72,17 +87,20 @@ module RuboCop
           condition = node.condition
           negated = left_hand_keyword != node.keyword
 
-          expr = if condition.send_type? && !condition.arguments.empty? &&
-                    !condition.operator_method?
-                   add_parentheses_to_method_arguments(condition)
-                 else
-                   condition.source
-                 end
+          expr = operand_source(condition)
           expr = "(#{expr})" if requires_parens?(condition, negated)
           expr = "!#{expr}" if negated
           expr
         end
 
+        def operand_source(condition)
+          if condition.send_type? && !condition.arguments.empty? && !condition.operator_method?
+            add_parentheses_to_method_arguments(condition)
+          else
+            condition.source
+          end
+        end
+
         def add_parentheses_to_method_arguments(send_node)
           expr = +''
           expr << "#{send_node.receiver.source}." if send_node.receiver
@@ -97,6 +115,7 @@ module RuboCop
           # whole expression (e.g. `!(a && b)`, not `!a && b`).
           (negated && node.operator_keyword?) ||
             node.or_type? ||
+            low_precedence?(node) ||
             !(RuboCop::AST::Node::COMPARISON_OPERATORS & node.children).empty?
         end
       end

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

@@ -26,7 +26,7 @@ module RuboCop
 
           node.each_descendant(:if).select(&:ternary?).each do |nested_ternary|
             add_offense(nested_ternary) do |corrector|
-              next if part_of_ignored_node?(node)
+              next if part_of_ignored_node?(node) || contains_heredoc?(node)
 
               autocorrect(corrector, node)
               ignore_node(node)
@@ -36,21 +36,39 @@ module RuboCop
 
         private
 
+        def contains_heredoc?(node)
+          node.each_descendant(:any_str).any?(&:heredoc?)
+        end
+
         def autocorrect(corrector, if_node)
           replace_loc_and_whitespace(corrector, if_node.loc.question, "\n")
           replace_loc_and_whitespace(corrector, if_node.loc.colon, "\nelse\n")
-          corrector.replace(if_node.if_branch, remove_parentheses(if_node.if_branch.source))
-          corrector.wrap(if_node, 'if ', "\nend")
-        end
+          remove_parentheses(corrector, if_node.if_branch)
 
-        def remove_parentheses(source)
-          if source.start_with?('(') && source.end_with?(')')
-            source.delete_prefix('(').delete_suffix(')')
+          if modifier_position?(if_node)
+            corrector.wrap(if_node, '(if ', "\nend)")
           else
-            source
+            corrector.wrap(if_node, 'if ', "\nend")
           end
         end
 
+        def remove_parentheses(corrector, node)
+          return unless node.begin_type? && node.parenthesized_call?
+
+          corrector.remove(node.loc.begin)
+          corrector.remove(node.loc.end)
+        end
+
+        # An `if` right after `return`, as the operand of `not` or `defined?`, or as
+        # the first argument of a call without parentheses would be parsed as a modifier.
+        def modifier_position?(node)
+          return false unless (parent = node.parent)
+          return true if parent.type?(:return, :break, :next)
+          return false if !parent.type?(:call, :super, :yield, :defined?) || parent.parenthesized?
+
+          parent.prefix_not? || parent.first_argument.equal?(node)
+        end
+
         def replace_loc_and_whitespace(corrector, range, replacement)
           corrector.replace(
             range_with_surrounding_space(range: range, whitespace: true),

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

@@ -181,11 +181,11 @@ module RuboCop
         def autocorrect_modifier(corrector, node)
           body = node.if_branch || node.else_branch
 
-          replacement =
-            "next #{node.inverse_keyword} #{node.condition.source}\n" \
-            "#{' ' * node.source_range.column}#{body.source}"
+          next_code = "next #{node.inverse_keyword} #{node.condition.source}\n" \
+                      "#{' ' * node.source_range.column}"
 
-          corrector.replace(node, replacement)
+          corrector.insert_before(node, next_code)
+          corrector.remove(range_between(body.source_range.end_pos, node.source_range.end_pos))
         end
 
         def autocorrect_block(corrector, node)
@@ -231,7 +231,7 @@ module RuboCop
 
           # end_range starts with the final newline of the if body
           lines = (node.source_range.line + 1)...node.loc.end.line
-          lines = lines.to_a - heredoc_lines(node)
+          lines = lines.to_a - string_content_lines(node)
           # Skip blank lines
           lines.reject { |lineno| /\A\s*\z/.match?(buffer.source_line(lineno)) }
         end
@@ -250,11 +250,25 @@ module RuboCop
           lines.map { |lineno| buffer.source_line(lineno) =~ /\S/ }.min
         end
 
-        def heredoc_lines(node)
-          node.each_node(:dstr)
-              .select(&:heredoc?)
-              .map { |n| n.loc.heredoc_body }
-              .flat_map { |b| (b.line...b.last_line).to_a }
+        # Lines that start inside a string literal or a heredoc body, whose
+        # leading whitespace is part of the string value.
+        def string_content_lines(node)
+          buffer = node.source_range.source_buffer
+          ranges = node.each_node(:any_str).filter_map { |str| string_content_range(str) }
+
+          ranges.flat_map do |range|
+            (range.line..range.last_line).select do |lineno|
+              (range.begin_pos...range.end_pos).cover?(buffer.line_range(lineno).begin_pos)
+            end
+          end
+        end
+
+        def string_content_range(node)
+          if node.heredoc?
+            node.loc.heredoc_body
+          elsif node.loc?(:begin) && node.loc?(:end)
+            node.loc.begin.end.join(node.loc.end.begin)
+          end
         end
 
         def reindent_line(corrector, lineno, delta, buffer)

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

@@ -44,6 +44,7 @@ module RuboCop
 
         def on_send(node)
           return unless node.receiver
+          return if prefer_comparison? && comment_before_dot?(node)
 
           style_check?(node) do
             add_offense(node.loc.selector) do |corrector|
@@ -58,12 +59,19 @@ module RuboCop
 
         private
 
+        def comment_before_dot?(node)
+          return false unless node.loc.dot
+
+          processed_source.contains_comment?(node.receiver.source_range.end.join(node.loc.dot))
+        end
+
         def autocorrect_to_comparison(corrector, node)
-          range = node.loc.dot.join(node.loc.selector.end)
+          range = node.receiver.source_range.end.join(node.loc.selector.end)
           corrector.replace(range, ' == nil')
-          # The new `== nil` binds looser than an enclosing operator (e.g. `<<`,
-          # `!`), so wrap it to keep the original precedence.
-          corrector.wrap(node, '(', ')') if operator_expression?(node.parent)
+
+          return if !operator_expression?(node.parent) && !receiver_of_parent?(node)
+
+          corrector.wrap(node, '(', ')')
         end
 
         def autocorrect_to_predicate(corrector, node)
@@ -88,6 +96,10 @@ module RuboCop
             node.assignment?
         end
 
+        def receiver_of_parent?(node)
+          node.parent&.call_type? && node.parent.receiver.equal?(node)
+        end
+
         def operator_send?(node)
           node.send_type? && node.operator_method? && !node.method?(:[]) && !node.method?(:[]=)
         end

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

@@ -130,7 +130,7 @@ module RuboCop
 
         def operator_expression?(node)
           node.operator_keyword? ||
-            (node.send_type? && node.binary_operation?) ||
+            (node.send_type? && node.operator_method?) ||
             (node.if_type? && node.ternary?) ||
             node.type?(:range, :iflipflop, :eflipflop) ||
             node.assignment?

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

@@ -54,11 +54,10 @@ module RuboCop
         end
 
         def requires_parens?(child)
-          child.operator_keyword? ||
-            (child.send_type? && child.binary_operation?) ||
-            (child.if_type? && child.ternary?) ||
-            child.type?(:range, :iflipflop, :eflipflop) ||
-            child.assignment?
+          return true if child.operator_keyword? || operator_method_requiring_parens?(child)
+          return true if child.if_type? && child.ternary?
+
+          child.type?(:range, :iflipflop, :eflipflop) || child.assignment?
         end
 
         def correct_opposite_method(corrector, range, child)
@@ -74,6 +73,12 @@ module RuboCop
         def correct_without_parens(corrector, range)
           corrector.replace(range, '!')
         end
+
+        def operator_method_requiring_parens?(child)
+          return false unless child.send_type?
+
+          child.binary_operation? || (child.unary_operation? && child.method?(:~))
+        end
       end
     end
   end

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

@@ -90,6 +90,7 @@ module RuboCop
         def on_send(node)
           numeric, replacement = check(node)
           return unless numeric
+          return if handled_by_bitwise_predicate?(node)
 
           return if allowed_method_name?(node.method_name) ||
                     node.each_ancestor(:send, :any_block).any? do |ancestor|
@@ -98,7 +99,10 @@ module RuboCop
 
           message = format(MSG, prefer: replacement, current: node.source)
           add_offense(node, message: message) do |corrector|
+            next if inside_corrected_predicate?(node)
+
             corrector.replace(node, replacement)
+            ignore_node(node)
           end
         end
 
@@ -108,6 +112,16 @@ module RuboCop
           allowed_method?(name) || matches_allowed_pattern?(name)
         end
 
+        def handled_by_bitwise_predicate?(node)
+          bitwise_predicate_candidate?(node) &&
+            config.for_cop('Style/BitwisePredicate').fetch('Enabled') &&
+            BitwisePredicate.support_target_ruby_version?(target_ruby_version)
+        end
+
+        def inside_corrected_predicate?(node)
+          node.each_ancestor(:send).any? { |ancestor| ignored_node?(ancestor) }
+        end
+
         def check(node)
           numeric, operator =
             if style == :predicate
@@ -124,7 +138,7 @@ module RuboCop
         def replacement(node, numeric, operation)
           if style == :predicate
             [parenthesized_source(numeric), REPLACEMENTS.invert[operation.to_s]].join('.')
-          elsif negated?(node)
+          elsif comparison_requires_parentheses?(node)
             "(#{numeric.source} #{REPLACEMENTS[operation.to_s]} 0)"
           else
             [numeric.source, REPLACEMENTS[operation.to_s], 0].join(' ')
@@ -140,7 +154,7 @@ module RuboCop
         end
 
         def require_parentheses?(node)
-          node.send_type? && node.binary_operation? && !node.parenthesized?
+          node.send_type? && node.operator_method? && !node.parenthesized?
         end
 
         def replacement_supported?(operator)
@@ -159,10 +173,11 @@ module RuboCop
           end
         end
 
-        def negated?(node)
-          return false unless (parent = node.parent)
+        def comparison_requires_parentheses?(node)
+          return false unless (parent = node.parent)&.call_type?
+          return true if parent.receiver.equal?(node)
 
-          parent.send_type? && parent.method?(:!)
+          parent.operator_method? && !parent.method?(:[]) && !parent.method?(:[]=)
         end
 
         # @!method predicate(node)
@@ -179,6 +194,14 @@ module RuboCop
         def_node_matcher :inverted_comparison, <<~PATTERN
           (send (int 0) ${:== :> :<} [$(...) !gvar_type?])
         PATTERN
+
+        # @!method bitwise_predicate_candidate?(node)
+        def_node_matcher :bitwise_predicate_candidate?, <<~PATTERN
+          {
+            (send {(begin (send _ :& _)) (send _ :& _)} {:positive? :zero?})
+            (send {(begin (send _ :& _)) (send _ :& _)} {:> :==} (int 0))
+          }
+        PATTERN
       end
     end
   end