rubocop 1.91.0 → 1.92.0

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

@@ -21,6 +21,10 @@ module RuboCop
         MSG_NEWLINE = 'Do not use `%<keyword>s %<expr>s;` - use a newline instead.'
         MSG_TERNARY = 'Do not use `%<keyword>s %<expr>s;` - use a ternary operator instead.'
 
+        LOWER_PRECEDENCE_THAN_TERNARY_TYPES = %i[
+          and or if rescue any_match_pattern while until while_post until_post
+        ].freeze
+
         def on_normal_if_unless(node)
           return if node.parent&.if_type?
           return if part_of_ignored_node?(node)
@@ -77,12 +81,14 @@ module RuboCop
         def replacement(node)
           return correct_elsif(node) if node.else_branch&.if_type?
 
-          then_code = node.if_branch ? build_expression(node.if_branch) : 'nil'
-          else_code = node.else_branch ? build_expression(node.else_branch) : 'nil'
+          then_code = node.if_branch ? ternary_operand(node.if_branch) : 'nil'
+          else_code = node.else_branch ? ternary_operand(node.else_branch) : 'nil'
 
           then_code, else_code = else_code, then_code if node.unless?
 
-          "#{ternary_condition(node)} ? #{then_code} : #{else_code}"
+          ternary = "#{ternary_condition(node)} ? #{then_code} : #{else_code}"
+
+          operand_of_parent?(node) ? "(#{ternary})" : ternary
         end
 
         def correct_elsif(node)
@@ -108,7 +114,34 @@ module RuboCop
         # `(a = b) ? c : d`), changing what gets assigned.
         def ternary_condition(node)
           condition = node.condition
-          condition.assignment? ? "(#{condition.source})" : condition.source
+          condition.assignment? ? "(#{condition.source})" : ternary_operand(condition)
+        end
+
+        def ternary_operand(expr)
+          lower_precedence_than_ternary?(expr) ? "(#{expr.source})" : build_expression(expr)
+        end
+
+        # Expressions that bind looser than `?:` (or cannot appear unparenthesized
+        # inside it) would otherwise absorb or break the ternary.
+        def lower_precedence_than_ternary?(node)
+          return true if node.type?(*LOWER_PRECEDENCE_THAN_TERNARY_TYPES)
+          return true if node.send_type? && (node.prefix_not? || prefix_bang_on_command?(node))
+
+          node.type?(:yield, :super, :defined?) && node.arguments.any? && !node.parenthesized?
+        end
+
+        def operand_of_parent?(node)
+          return false unless (parent = node.parent)
+          return true if parent.operator_keyword?
+
+          parent.call_type? && call_operand?(parent, node)
+        end
+
+        def call_operand?(call, node)
+          return false if call.prefix_not?
+          return true if call.receiver.equal?(node)
+
+          call.operator_method? && !call.method?(:[]) && !call.method?(:[]=)
         end
 
         def build_else_branch(second_condition)
@@ -131,6 +164,16 @@ module RuboCop
           result
         end
 
+        # `!foo a` leaves the arguments of `foo` unparenthesized at the end of the operand,
+        # where they would absorb the rest of the ternary.
+        def prefix_bang_on_command?(node)
+          return false unless node.prefix_bang?
+
+          receiver = node.receiver
+
+          require_argument_parentheses?(receiver) || lower_precedence_than_ternary?(receiver)
+        end
+
         def require_argument_parentheses?(node)
           return false if !node.call_type? || node.arithmetic_operation?
 

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

@@ -114,9 +114,31 @@ module RuboCop
           method_call, _lhs, method, _rhs = inverse_candidate?(node)
           return unless method_call && method
 
-          corrector.remove(not_to_receiver(node, method_call))
+          remove_negation(corrector, node, method, method_call)
           corrector.replace(method_call.loc.selector, inverse_methods[method].to_s)
-          remove_end_parenthesis(corrector, node, method, method_call)
+        end
+
+        def remove_negation(corrector, node, method, method_call)
+          if !keep_parentheses?(node, method_call)
+            corrector.remove(not_to_receiver(node, method_call))
+            remove_end_parenthesis(corrector, node, method, method_call)
+          elsif node.parenthesized?
+            corrector.remove(node.loc.selector)
+          else
+            corrector.remove(node.loc.selector.join(node.receiver.source_range.begin))
+          end
+        end
+
+        def keep_parentheses?(node, method_call)
+          return false unless node.receiver.begin_type? || node.parenthesized?
+          return false unless method_call.operator_method?
+          return false unless (parent = node.parent)&.call_type?
+
+          binary_operator?(parent) || parent.receiver.equal?(node)
+        end
+
+        def binary_operator?(node)
+          node.operator_method? && !node.loc.dot && !node.method?(:[]) && !node.method?(:[]=)
         end
 
         def correct_inverse_block(corrector, node)

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

@@ -61,6 +61,12 @@ module RuboCop
 
         minimum_target_ruby_version 3.4
 
+        # `Style/StabbyLambdaParentheses` wraps the parameter this cop removes in the same pass,
+        # which would leave an empty parameter list that forbids `it`.
+        def self.autocorrect_incompatible_with
+          [Style::Lambda, Style::StabbyLambdaParentheses]
+        end
+
         def on_block(node)
           return unless style == :always
           return unless node.arguments.one?
@@ -68,9 +74,10 @@ module RuboCop
           # `restarg`, `kwrestarg`, `blockarg` nodes can return early.
           return unless node.first_argument.arg_type?
 
-          variables = find_block_variables(node, node.first_argument.source)
+          block_argument_name = node.first_argument.source
+          return if used_within_inner_block?(node.body, block_argument_name)
 
-          variables.each do |variable|
+          find_block_variables(node, block_argument_name).each do |variable|
             add_offense(variable, message: MSG_USE_IT_PARAMETER) do |corrector|
               corrector.remove(node.arguments)
               corrector.replace(variable, 'it')
@@ -111,7 +118,29 @@ module RuboCop
         def find_block_variables(node, block_argument_name)
           return [] unless node.body
 
-          node.body.each_descendant(:lvar).select do |descendant|
+          ranges = inner_block_ranges(node.body)
+
+          block_variables(node.body, block_argument_name).reject do |variable|
+            ranges.any? { |range| range.contains?(variable.source_range) }
+          end
+        end
+
+        def inner_block_ranges(body)
+          body.each_node(:any_block).map { |block| block.loc.begin.join(block.loc.end) }
+        end
+
+        def used_within_inner_block?(body, block_argument_name)
+          return false unless body
+
+          ranges = inner_block_ranges(body)
+
+          block_variables(body, block_argument_name).any? do |variable|
+            ranges.any? { |range| range.contains?(variable.source_range) }
+          end
+        end
+
+        def block_variables(body, block_argument_name)
+          body.each_descendant(:lvar).select do |descendant|
             descendant.source == block_argument_name
           end
         end

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

@@ -75,7 +75,9 @@ module RuboCop
 
         def remove_kwargs(kwarg_nodes, corrector)
           kwarg_nodes.each do |kwarg|
-            with_space = range_with_surrounding_space(kwarg.source_range)
+            range = range_with_surrounding_space(kwarg.source_range, side: :left, whitespace: true)
+            with_space = range_with_surrounding_space(range, side: :right)
+
             corrector.remove(range_with_surrounding_comma(with_space, :left))
           end
         end

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

@@ -48,6 +48,8 @@ module RuboCop
       #       end
       class Lambda < Base
         include ConfigurableEnforcedStyle
+        include PatternMatchingHelp
+        include RescueNode
         extend AutoCorrector
 
         LITERAL_MESSAGE = 'Use the `-> { ... }` lambda literal syntax for %<modifier>s lambdas.'
@@ -71,6 +73,7 @@ module RuboCop
           selector = node.send_node.source
 
           return unless offending_selector?(node, selector)
+          return if uncorrectable_lambda_literal?(node)
 
           add_offense(node.send_node, message: message(node, selector)) do |corrector|
             if node.send_node.lambda_literal?
@@ -91,6 +94,21 @@ module RuboCop
           selector == OFFENDING_SELECTORS[:style][style][lines]
         end
 
+        def uncorrectable_lambda_literal?(node)
+          return false unless node.send_node.lambda_literal?
+          return true if in_pattern?(node)
+          return false unless rescue_or_ensure_clause?(node.body)
+
+          LambdaLiteralToMethodCorrector.new(node).replace_delimiters?
+        end
+
+        def rescue_or_ensure_clause?(body)
+          return false unless body
+          return true if body.ensure_type?
+
+          body.rescue_type? && !rescue_modifier?(body.resbody_branches.first)
+        end
+
         def message(node, selector)
           message = selector == '->' ? METHOD_MESSAGE : LITERAL_MESSAGE
 

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

@@ -28,8 +28,9 @@ module RuboCop
         def on_send(node)
           return unless node.receiver
           # Rewriting the call rebuilds it as a single expression, which would drop
-          # any comments inside the argument list, so leave it to be fixed manually.
-          return if comments_in_node?(node)
+          # any comments or heredoc bodies inside the argument list, so leave it to be
+          # fixed manually.
+          return if comments_in_node?(node) || heredoc_argument?(node)
 
           if offense?(node)
             prefer = prefer(node)
@@ -59,6 +60,10 @@ module RuboCop
           end
         end
 
+        def heredoc_argument?(node)
+          node.arguments.any? { |argument| argument.each_node(:any_str).any?(&:heredoc?) }
+        end
+
         def offense?(node)
           (explicit_style? && node.implicit_call?) || (implicit_style? && !node.implicit_call?)
         end

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

@@ -112,8 +112,7 @@ module RuboCop
 
         def on_block(node)
           return unless each_block_with_push?(node)
-
-          dest_var = find_dest_var(node)
+          return unless (dest_var = find_dest_var(node))
 
           if offending_empty_array_tap?(node, dest_var)
             asgn = dest_var.declaration_node

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

@@ -40,6 +40,8 @@ module RuboCop
             return if legitimate_call_with_parentheses?(node)
             return if allowed_camel_case_method_call?(node)
             return if allowed_string_interpolation_method_call?(node)
+            return if code_after_closing_parenthesis_on_its_own_line?(node)
+            return if comment_before_first_argument?(node)
 
             (@pending_omit_offenses ||= []) << node
           end
@@ -104,11 +106,30 @@ module RuboCop
               inside_string_interpolation?(node)
           end
 
+          def code_after_closing_parenthesis_on_its_own_line?(node)
+            closing = node.loc.end
+            return false if node.arguments.none? || node.last_argument.last_line == closing.line
+
+            rest = closing.source_line[(closing.column + 1)..].strip
+
+            !rest.empty? && !rest.start_with?('#')
+          end
+
+          # Without the parentheses, a comment before the first argument would end the call there,
+          # and a line continuation can't carry the call past a comment.
+          def comment_before_first_argument?(node)
+            return false unless (first_argument = node.first_argument)
+
+            lines = node.loc.begin.line...first_argument.first_line
+            processed_source.each_comment_in_lines(lines).any?
+          end
+
           def parentheses_at_the_end_of_multiline_call?(node)
-            node.multiline? &&
-              node.loc.begin.source_line
-                  .gsub(TRAILING_WHITESPACE_REGEX, '')
-                  .end_with?('(')
+            return false unless node.multiline?
+
+            opening = node.loc.begin
+
+            opening.source_line[(opening.column + 1)..].gsub(TRAILING_WHITESPACE_REGEX, '').empty?
           end
 
           def legitimate_call_with_parentheses?(node) # rubocop:disable Metrics/PerceivedComplexity
@@ -137,9 +158,13 @@ module RuboCop
             parent = node.parent&.any_block_type? ? node.parent.parent : node.parent
             return false unless parent
 
-            logical_operator?(parent) ||
-              (parent.send_type? &&
-              parent.arguments.any? { |argument| logical_operator?(argument) })
+            if logical_operator?(parent) || command_assignment_before_keyword_operator?(parent)
+              return true
+            end
+
+            parent.send_type? && parent.arguments.any? do |argument|
+              logical_operator?(argument)
+            end
           end
 
           def call_in_optional_arguments?(node)
@@ -229,6 +254,15 @@ module RuboCop
             node.operator_keyword? && node.logical_operator?
           end
 
+          def command_assignment_before_keyword_operator?(node)
+            return false unless node.assignment?
+
+            node = node.parent while node.parent&.assignment?
+            return false unless (operator = node.parent)
+
+            operator.operator_keyword? && operator.semantic_operator?
+          end
+
           def hash_literal?(node)
             node.hash_type? && node.braces?
           end
@@ -262,10 +296,11 @@ module RuboCop
           end
 
           def forwards_anonymous_rest_arguments?(node)
-            return false unless (last_argument = node.last_argument)
-            return true if last_argument.forwarded_restarg_type?
+            node.arguments.any? do |argument|
+              next true if argument.forwarded_restarg_type?
 
-            last_argument.hash_type? && last_argument.children.any?(&:forwarded_kwrestarg_type?)
+              argument.hash_type? && argument.children.any?(&:forwarded_kwrestarg_type?)
+            end
           end
         end
       end

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