rubocop 1.91.0 → 1.92.1

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

@@ -242,7 +242,13 @@ module RuboCop
         extend AutoCorrector
 
         def self.autocorrect_incompatible_with
-          [Style::NestedParenthesizedCalls, Style::RescueModifier, Style::TrailingCommaInArguments]
+          [
+            Style::NestedParenthesizedCalls,
+            Style::RedundantParentheses,
+            Style::RescueModifier,
+            Style::TernaryParentheses,
+            Style::TrailingCommaInArguments
+          ]
         end
 
         def on_send(node)
@@ -269,7 +275,24 @@ module RuboCop
           return false unless node.arguments.one?
 
           first_node = node.first_argument
-          first_node.begin_type? && first_node.parenthesized_call?
+          return false unless first_node.begin_type? && first_node.parenthesized_call?
+
+          first_node.children.one? && mergeable_parentheses?(first_node.children.first)
+        end
+
+        def mergeable_parentheses?(node)
+          case node.type
+          when :and, :or
+            !node.semantic_operator?
+          when :if, :while, :until
+            !node.modifier_form?
+          when :send
+            !node.keyword?
+          when :rescue, :masgn, :match_pattern, :match_pattern_p
+            false
+          else
+            true
+          end
         end
       end
     end

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

@@ -29,10 +29,16 @@ module RuboCop
       class MethodCallWithoutArgsParentheses < Base
         include AllowedMethods
         include AllowedPattern
+        include ReparsedEquivalence
         extend AutoCorrector
 
         MSG = 'Do not use parentheses for method calls with no arguments.'
 
+        def on_new_investigation
+          @pending_ranges = []
+          super
+        end
+
         # rubocop:disable-next Metrics/CyclomaticComplexity
         def on_send(node)
           return unless !node.arguments? && node.parenthesized?
@@ -46,15 +52,32 @@ module RuboCop
         end
         alias on_csend on_send
 
+        # The parentheses are significant when removing them changes how the
+        # code parses, e.g. when a local variable with the same name is in
+        # scope (`foo = 1; foo()`) or an operator follows (`foo() -1`). The
+        # candidates are verified together, since outside a method definition
+        # each one would otherwise reparse the whole file.
+        def on_investigation_end
+          verified_by_reparse(@pending_ranges).each do |range|
+            add_offense(range) do |corrector|
+              apply_reparse_correction(corrector, range)
+            end
+          end
+
+          super
+        end
+
         private
 
         def register_offense(node)
           range = offense_range(node)
           return if processed_source.contains_comment?(range)
 
-          add_offense(range) do |corrector|
-            corrector.remove(range)
-          end
+          @pending_ranges << range
+        end
+
+        def apply_reparse_correction(corrector, range)
+          corrector.remove(range)
         end
 
         def ineligible_node?(node)

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

@@ -127,7 +127,19 @@ module RuboCop
 
         def correct_arguments(arg_node, corrector)
           corrector.replace(arg_node.loc.begin, ' ')
-          corrector.remove(arg_node.loc.end)
+
+          if code_after_arguments?(arg_node)
+            corrector.replace(arg_node.loc.end, ';')
+          else
+            corrector.remove(arg_node.loc.end)
+          end
+        end
+
+        def code_after_arguments?(arg_node)
+          closing = arg_node.loc.end
+          rest = closing.source_line[(closing.column + 1)..].strip
+
+          !rest.empty? && !rest.start_with?(';', '#')
         end
 
         def forced_parentheses?(node)
@@ -137,8 +149,11 @@ module RuboCop
           # 3. Argument lists containing an anonymous rest arguments forwarding (`*`)
           # 4. Argument lists containing an anonymous keyword rest arguments forwarding (`**`)
           # 5. Argument lists containing an anonymous block forwarding (`&`)
-          # Removing the parens would be a syntax error here.
-          node.endless? || anonymous_arguments?(node)
+          # 6. Argument lists that begin on a line below the method name
+          # 7. Argument lists that begin with a destructuring parameter (`(a, b)`)
+          # Removing the parens would be a syntax error, or a change of the parameters, here.
+          node.endless? || anonymous_arguments?(node) || arguments_on_own_line?(node) ||
+            destructuring_first_argument?(node)
         end
 
         def require_parentheses?(args)
@@ -176,6 +191,17 @@ module RuboCop
 
           last_argument.blockarg_type? && last_argument.name.nil?
         end
+
+        def arguments_on_own_line?(node)
+          return false unless (first_argument = node.first_argument)
+          return false unless parentheses?(node.arguments)
+
+          node.arguments.loc.begin.line != first_argument.first_line
+        end
+
+        def destructuring_first_argument?(node)
+          node.first_argument&.mlhs_type?
+        end
       end
     end
   end

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

@@ -125,13 +125,19 @@ module RuboCop
         private
 
         def check(node)
-          return if node.else?
+          return if node.else? || guard_clause_cop_conflict?(node)
 
           add_offense(node, message: format(message_template, type: node.type)) do |corrector|
             autocorrect(corrector, node)
           end
         end
 
+        def guard_clause_cop_conflict?(node)
+          return false unless node.if_type? && @config.cop_enabled?('Style/GuardClause')
+
+          [node.if_branch, node.else_branch].compact.any?(&:guard_clause?)
+        end
+
         def message_template
           case empty_else_style
           when :empty

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

@@ -117,17 +117,26 @@ module RuboCop
 
         def separate_mixins(node)
           arguments = node.arguments.reverse
-          mixins = ["#{node.method_name} #{arguments.first.source}"]
+          mixins = [mixin_call(node.method_name, arguments.first.source, node.parenthesized?)]
 
           arguments[1..].inject(mixins) do |replacement, arg|
-            replacement << "#{indent(node)}#{node.method_name} #{arg.source}"
+            call = mixin_call(node.method_name, arg.source, node.parenthesized?)
+            replacement << "#{indent(node)}#{call}"
           end.join("\n")
         end
 
         def group_mixins(node, mixins)
           mixin_names = mixins.reverse.flat_map { |mixin| mixin.arguments.map(&:source) }
 
-          "#{node.method_name} #{mixin_names.join(', ')}"
+          mixin_call(node.method_name, mixin_names.join(', '), mixins.any?(&:parenthesized?))
+        end
+
+        def mixin_call(method_name, arguments_source, parenthesized)
+          if parenthesized
+            "#{method_name}(#{arguments_source})"
+          else
+            "#{method_name} #{arguments_source}"
+          end
         end
       end
     end

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),