rubocop 1.91.0 → 1.92.1

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

@@ -83,7 +83,7 @@ module RuboCop
           control_op_condition(cond) do |first_child, rest_children|
             return if require_parentheses?(node, first_child)
             return if semicolon_separated_expressions?(first_child, rest_children)
-            return if modifier_op?(first_child)
+            return if modifier_op?(first_child) || first_child.masgn_type?
             return if parens_allowed?(cond)
 
             message = message(cond)

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

@@ -101,10 +101,7 @@ module RuboCop
             return if exception.send_type? && exception.first_argument&.hash_type?
 
             add_offense(node, message: format(COMPACT_MSG, method: node.method_name)) do |corrector|
-              replacement = correction_exploded_to_compact(node)
-
-              corrector.replace(node, replacement)
-              opposite_style_detected
+              replace_raise(corrector, node, correction_exploded_to_compact(node))
             end
           else
             correct_style_detected
@@ -121,13 +118,22 @@ module RuboCop
           return if allowed_non_exploded_type?(first_arg)
 
           add_offense(node, message: format(EXPLODED_MSG, method: node.method_name)) do |corrector|
-            replacement = correction_compact_to_exploded(node)
-
-            corrector.replace(node, replacement)
-            opposite_style_detected
+            replace_raise(corrector, node, correction_compact_to_exploded(node))
           end
         end
 
+        def replace_raise(corrector, node, replacement)
+          opposite_style_detected
+          return if inside_corrected_raise?(node)
+
+          corrector.replace(node, replacement)
+          ignore_node(node)
+        end
+
+        def inside_corrected_raise?(node)
+          node.each_ancestor(:send).any? { |ancestor| ignored_node?(ancestor) }
+        end
+
         def use_new_method?(first_arg)
           first_arg.send_type? && first_arg.receiver && first_arg.method?(:new)
         end
@@ -152,7 +158,11 @@ module RuboCop
         end
 
         def requires_parens?(parent)
-          parent.operator_keyword? || (parent.if_type? && parent.ternary?)
+          return true if parent.operator_keyword?
+          return true if parent.type?(:call, :super, :yield, :array, :pair)
+          return true if parent.any_def_type? && parent.endless?
+
+          parent.if_type? && parent.ternary?
         end
       end
     end

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)
@@ -184,7 +191,8 @@ module RuboCop
         def use_modifier_form_after_multiline_begin_block?(node)
           return false unless (parent = node.parent)
 
-          node.multiline? && parent.if_type? && parent.modifier_form?
+          node.multiline? && parent.if_type? && parent.modifier_form? &&
+            !parent.condition.equal?(node)
         end
 
         def correct_modifier_form_after_multiline_begin_block(corrector, node)
@@ -222,7 +230,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)

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

@@ -29,8 +29,7 @@ module RuboCop
                          operation_produces_immutable_object?(node.receiver))
 
           add_offense(node) do |corrector|
-            corrector.remove(node.loc.dot)
-            corrector.remove(node.loc.selector)
+            corrector.remove(node.loc.dot.join(node.loc.selector))
           end
         end
 
@@ -57,12 +56,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