rubocop 1.91.0 → 1.92.0

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::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
@@ -293,12 +302,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|
@@ -108,6 +109,12 @@ 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 check(node)
           numeric, operator =
             if style == :predicate
@@ -124,7 +131,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 +147,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 +166,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 +187,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

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

@@ -102,6 +102,7 @@ module RuboCop
           return replaced_node unless node.parent
           return "(#{replaced_node})" if node.parent.operator_keyword?
           return "(#{replaced_node})" if node.parent.send_type? && node.parent.operator_method?
+          return "(#{replaced_node})" if parent_binds_tighter_than_ternary?(node)
 
           replaced_node
         end
@@ -124,6 +125,14 @@ module RuboCop
             "#{expr_replacement(else_branch)}"
         end
 
+        def parent_binds_tighter_than_ternary?(node)
+          parent = node.parent
+          return parent.receiver.equal?(node) if parent.call_type?
+          return parent.namespace.equal?(node) if parent.type?(:const, :casgn)
+
+          parent.if_type? && parent.ternary? && parent.condition.equal?(node)
+        end
+
         def expr_replacement(node)
           return 'nil' if node.nil?
 
@@ -131,7 +140,9 @@ module RuboCop
         end
 
         def requires_parentheses?(node)
-          return true if %i[and or if].include?(node.type)
+          return true if node.type?(
+            :and, :or, :if, :rescue, :while, :until, :while_post, :until_post, :any_match_pattern
+          )
           return true if node.assignment?
           return true if method_call_with_changed_precedence?(node)
 
@@ -139,7 +150,7 @@ module RuboCop
         end
 
         def method_call_with_changed_precedence?(node)
-          return false unless node.send_type? && node.arguments?
+          return false unless node.call_type? && node.arguments?
           return false if node.parenthesized_call?
 
           !node.operator_method?

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

@@ -86,10 +86,21 @@ module RuboCop
         end
 
         def include_same_character_as_used_for_delimiter?(node, type)
-          return false unless %w[%w %i].include?(type)
-
           used_delimiters = matchpairs(begin_source(node)[-1])
-          contains_delimiter?(node, used_delimiters)
+          return contains_delimiter?(node, used_delimiters) if %w[%w %i].include?(type)
+          return false unless %w[%q %s %r].include?(type)
+
+          contains_escaped_delimiter?(node, used_delimiters)
+        end
+
+        # Without interpolation an escaped delimiter means something different
+        # once the delimiters change (`%q!it\!s!` is `"it!s"`, but `%q(it\!s)`
+        # is `"it\\!s"`). For a regexp the match stays the same, but its source
+        # changes. Interpolating literals read `\!` as `!` with any delimiter.
+        def contains_escaped_delimiter?(node, delimiters)
+          body = node.loc.begin.end.join(node.loc.end.begin).source
+
+          body.scan(/\\./m).any? { |escape| delimiters.include?(escape[1]) }
         end
 
         def contains_delimiter?(node, delimiters)

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

@@ -183,7 +183,7 @@ module RuboCop
         end
 
         def adjusted_source(expr_node, block_node)
-          source = expr_node.source
+          source = element_source(expr_node)
           return source unless block_node.numblock_type?
           return source if block_node.method?(:each_with_object)
 
@@ -194,6 +194,22 @@ module RuboCop
         def indent(node)
           ' ' * node.source_range.column
         end
+
+        def element_source(expr_node)
+          if command_call?(expr_node) || expr_node.assignment? || expr_node.rescue_type?
+            return "(#{expr_node.source})"
+          end
+          return "[#{expr_node.source}]" if expr_node.array_type? && !expr_node.bracketed?
+
+          expr_node.source
+        end
+
+        def command_call?(node)
+          node = node.send_node if node.any_block_type?
+          return false unless node.type?(:call, :super, :yield)
+
+          node.arguments? && !node.parenthesized? && !node.operator_method? && !node.setter_method?
+        end
       end
     end
   end

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

@@ -139,7 +139,7 @@ module RuboCop
           offense_range = node.loc.begin
 
           add_offense(offense_range) do |corrector|
-            if node.parent&.assignment?
+            if node.parent&.assignment? || node.parent&.type?(:return, :next, :break)
               replace_begin_with_statement(corrector, offense_range, node)
             else
               remove_begin(corrector, offense_range, node)
@@ -156,7 +156,7 @@ module RuboCop
           first_child = node.children.first
 
           source = first_child.source
-          source = "(#{source})" if first_child.if_type? && first_child.modifier_form?
+          source = "(#{source})" if low_precedence_statement?(first_child)
 
           corrector.replace(offense_range, source)
           corrector.remove(range_between(offense_range.end_pos, first_child.source_range.end_pos))
@@ -164,6 +164,13 @@ module RuboCop
           restore_removed_comments(corrector, offense_range, node, first_child)
         end
 
+        def low_precedence_statement?(node)
+          return node.modifier_form? if node.basic_conditional?
+          return node.prefix_not? if node.send_type?
+
+          node.operator_keyword? && node.semantic_operator?
+        end
+
         def remove_begin(corrector, offense_range, node)
           if node.parent.respond_to?(:endless?) && node.parent.endless?
             offense_range = range_with_surrounding_space(offense_range, newlines: true)
@@ -222,7 +229,17 @@ module RuboCop
         end
 
         def valid_begin_assignment?(node)
-          node.parent&.assignment? && !node.children.one?
+          node.parent&.assignment? && (!node.children.one? || too_long_when_joined?(node))
+        end
+
+        def too_long_when_joined?(node)
+          statement = node.children.first
+          max = config.for_enabled_cop('Layout/LineLength')['Max']
+          return false unless max && statement.single_line?
+
+          length = statement.source.length
+          length += 2 if low_precedence_statement?(statement)
+          node.loc.column + length > max
         end
 
         def inspect_branches(node)