rubocop 1.90.0 → 1.92.0

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

@@ -131,7 +131,9 @@ module RuboCop
       #
       class EndlessMethod < Base
         include ConfigurableEnforcedStyle
+        include LineLengthHelp
         include EndlessMethodRewriter
+        include EndlessMethodBodyHelp
         extend TargetRubyVersion
         extend AutoCorrector
 
@@ -143,6 +145,12 @@ module RuboCop
         MSG_REQUIRE_SINGLE = 'Use endless method definitions for single line methods.'
         MSG_REQUIRE_ALWAYS = 'Use endless method definitions.'
 
+        # `Style/MethodDefParentheses` adds the same parentheses a parameter list needs in
+        # an endless definition, so letting both correct in the same pass would double them.
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses, Style::MethodDefParentheses]
+        end
+
         def on_def(node)
           return if node.assignment_method? || use_heredoc?(node)
 
@@ -166,6 +174,8 @@ module RuboCop
           return if node.single_line? || style == :allow_always
 
           add_offense(node, message: MSG_MULTI_LINE) do |corrector|
+            next if endless_parent?(node)
+
             correct_to_multiline(corrector, node)
           end
         end
@@ -175,11 +185,11 @@ module RuboCop
             add_offense(node, message: MSG_MULTI_LINE) do |corrector|
               correct_to_multiline(corrector, node)
             end
-          elsif !node.endless? && can_be_made_endless?(node) && node.body.single_line?
+          elsif !node.endless? && can_be_made_endless?(node) && single_line_when_made_endless?(node)
             return if too_long_when_made_endless?(node)
 
             add_offense(node, message: MSG_REQUIRE_SINGLE) do |corrector|
-              corrector.replace(node, endless_replacement(node))
+              correct_to_endless(corrector, node)
             end
           end
         end
@@ -189,21 +199,58 @@ module RuboCop
           return if too_long_when_made_endless?(node)
 
           add_offense(node, message: MSG_REQUIRE_ALWAYS) do |corrector|
-            corrector.replace(node, endless_replacement(node))
+            correct_to_endless(corrector, node)
           end
         end
 
         def handle_disallow_style(node)
           return unless node.endless?
 
-          add_offense(node) { |corrector| correct_to_multiline(corrector, node) }
+          add_offense(node) do |corrector|
+            next if endless_parent?(node)
+
+            correct_to_multiline(corrector, node)
+          end
+        end
+
+        def endless_parent?(node)
+          node.parent&.any_def_type? && node.parent.endless?
         end
 
         def use_heredoc?(node)
           return false unless (body = node.body)
           return true if body.any_str_type? && body.heredoc?
 
-          body.each_descendant(:str).any?(&:heredoc?)
+          body.each_descendant(:any_str).any?(&:heredoc?)
+        end
+
+        def correct_to_endless(corrector, node)
+          if unparenthesized_arguments?(node)
+            corrector.replace(name_to_arguments_range(node), '(')
+            corrector.replace(signature_to_body_range(node), ') = ')
+          else
+            corrector.replace(signature_to_body_range(node), ' = ')
+          end
+
+          corrector.remove(body_to_end_range(node))
+        end
+
+        def unparenthesized_arguments?(node)
+          node.arguments.any? && !node.arguments.loc.begin
+        end
+
+        def name_to_arguments_range(node)
+          node.loc.name.end.join(node.arguments.source_range.begin)
+        end
+
+        def signature_to_body_range(node)
+          signature_end = node.arguments.any? ? node.arguments.source_range.end : node.loc.name.end
+
+          signature_end.join(node.body.source_range.begin)
+        end
+
+        def body_to_end_range(node)
+          node.body.source_range.end.join(node.loc.end.end)
         end
 
         def endless_replacement(node)
@@ -217,23 +264,56 @@ module RuboCop
         end
 
         def arguments(node, missing = '')
-          node.arguments.any? ? node.arguments.source : missing
+          return missing unless node.arguments.any?
+          return parenthesized_arguments(node) if unparenthesized_arguments?(node)
+
+          node.arguments.source
+        end
+
+        def parenthesized_arguments(node)
+          padding = space_inside_parens? ? ' ' : ''
+
+          "(#{padding}#{node.arguments.source}#{padding})"
+        end
+
+        def space_inside_parens?
+          return false unless config.cop_enabled?('Layout/SpaceInsideParens')
+
+          config.for_cop('Layout/SpaceInsideParens')['EnforcedStyle'] != 'no_space'
         end
 
         def can_be_made_endless?(node)
-          node.body && !node.body.begin_type? && !node.body.kwbegin_type?
+          return false unless node.body
+          return false if comment_in_discarded_range?(node)
+
+          endless_method_body?(node.body)
+        end
+
+        def single_line_when_made_endless?(node)
+          !endless_replacement(node).include?("\n")
         end
 
         def too_long_when_made_endless?(node)
           return false unless config.cop_enabled?('Layout/LineLength')
 
-          offset = modifier_offset(node)
+          line_length(line_when_made_endless(node)) > max_line_length
+        end
+
+        def comment_in_discarded_range?(node)
+          discarded_ranges = [signature_to_body_range(node), body_to_end_range(node)]
 
-          endless_replacement(node).length + offset > max_line_length
+          processed_source.each_comment_in_lines(node.first_line..node.last_line).any? do |comment|
+            discarded_ranges.any? { |range| range.contains?(comment.source_range) }
+          end
         end
 
-        def modifier_offset(node)
-          same_line?(node.parent, node) ? node.loc.column - node.parent.loc.column : 0
+        def line_when_made_endless(node)
+          keyword_element = node.loc.keyword
+          code_before = keyword_element.source_line[0...keyword_element.column]
+          end_element = node.loc.end
+          code_after = end_element.source_line[end_element.last_column..]
+
+          "#{code_before}#{endless_replacement(node)}#{code_after}"
         end
       end
     end

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

@@ -5,11 +5,15 @@ module RuboCop
     module Style
       # Checks for exact regexp match inside `Regexp` literals.
       #
+      # `=~` returns an index and `match` returns `MatchData`, so they are only
+      # autocorrected when their value is used as a condition. The same goes for
+      # safe navigation calls, which return `nil` for a `nil` receiver.
+      #
       # @example
       #
       #   # bad
       #   string =~ /\Astring\z/
-      #   string === /\Astring\z/
+      #   /\Astring\z/ === string
       #   string.match(/\Astring\z/)
       #   string.match?(/\Astring\z/)
       #
@@ -27,14 +31,15 @@ module RuboCop
 
         MSG = 'Use `%<prefer>s`.'
         RESTRICT_ON_SEND = %i[=~ === !~ match match?].freeze
+        BOOLEAN_METHODS = %i[=== !~ match?].to_set.freeze
 
+        # `String#===` is plain equality, so `===` only matches with the regexp as its receiver.
         # @!method exact_regexp_match(node)
         def_node_matcher :exact_regexp_match, <<~PATTERN
-          (call
-            _ {:=~ :=== :!~ :match :match?}
-            (regexp
-              (str $_)
-              (regopt)))
+          {
+            (call _ {:=~ :!~ :match :match?} (regexp (str $_) (regopt)))
+            (send (regexp (str $_) (regopt)) :=== _)
+          }
         PATTERN
 
         def on_send(node)
@@ -44,16 +49,48 @@ module RuboCop
           return unless exact_match_pattern?(parsed_regexp)
 
           string = escape_single_quotes(parsed_regexp[1].text)
-          prefer = "#{receiver.source} #{new_method(node)} '#{string}'"
+          subject = node.method?(:===) ? node.first_argument : receiver
+          prefer = "#{subject.source} #{new_method(node)} '#{string}'"
 
           add_offense(node, message: format(MSG, prefer: prefer)) do |corrector|
-            corrector.replace(node, prefer)
+            autocorrect(corrector, node, prefer)
           end
         end
         alias on_csend on_send
 
         private
 
+        def autocorrect(corrector, node, prefer)
+          return unless boolean_result?(node) || truthiness_only?(node)
+
+          corrector.replace(node, parenthesize?(node) ? "(#{prefer})" : prefer)
+        end
+
+        # `=~` returns an index, `match` returns `MatchData` and `&.` can return `nil`,
+        # so replacing them with `==` is only safe where the value is used as a condition.
+        def boolean_result?(node)
+          node.send_type? && BOOLEAN_METHODS.include?(node.method_name)
+        end
+
+        def truthiness_only?(node)
+          return true unless node.value_used?
+
+          parent = node.parent
+          if parent.type?(:begin, :and, :or)
+            truthiness_only?(parent)
+          elsif parent.type?(:if, :while, :until)
+            parent.condition.equal?(node)
+          else
+            parent.send_type? && parent.method?(:!)
+          end
+        end
+
+        def parenthesize?(node)
+          return false unless (parent = node.parent)&.call_type?
+
+          parent.receiver.equal?(node) || (parent.operator_method? && !parent.method?(:[]))
+        end
+
         # Escape characters that are special inside a single-quoted string so the
         # generated literal (e.g. for `/\Afoo'bar\z/`) stays valid Ruby.
         def escape_single_quotes(text)

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

@@ -50,8 +50,11 @@ module RuboCop
           (block $_ (args $...) (yield $...))
         PATTERN
 
+        # `Style/LambdaCall` rewrites the `call` that the block argument is appended to, and
+        # `Style/TrailingCommaInArguments` changes the trailing comma where it is appended,
+        # in the same pass.
         def self.autocorrect_incompatible_with
-          [Lint::UnusedMethodArgument]
+          [Lint::UnusedMethodArgument, Style::LambdaCall, Style::TrailingCommaInArguments]
         end
 
         def initialize(config = nil, options = nil)
@@ -70,10 +73,13 @@ module RuboCop
             # this is not a valid ruby pattern, but can happen in haml or erb,
             # so this can cause crashes in haml_lint
             return unless def_node
+            return if argument_forwarding?(def_node)
 
             block_name = extract_block_name(def_node)
 
             add_offense(block_node) do |corrector|
+              next unless can_add_block_argument?(def_node, send_node, block_name)
+
               corrector.remove(block_body_range(block_node, send_node))
 
               add_block_argument(send_node, corrector, block_name)
@@ -84,6 +90,11 @@ module RuboCop
 
         private
 
+        # A block parameter can't be added next to `...`.
+        def argument_forwarding?(def_node)
+          def_node.arguments.any?(&:forward_arg_type?)
+        end
+
         def extract_block_name(def_node)
           if def_node.block_argument?
             def_node.last_argument.name
@@ -92,6 +103,27 @@ module RuboCop
           end
         end
 
+        def can_add_block_argument?(def_node, send_node, block_name)
+          return false if block_name_taken?(def_node, block_name)
+
+          !send_node.zsuper_type? || zsuper_arguments_forwardable?(def_node)
+        end
+
+        def block_name_taken?(def_node, block_name)
+          return false if def_node.block_argument?
+
+          def_node.each_descendant(:argument, :lvasgn).any? { |node| node.name.to_s == block_name }
+        end
+
+        # A destructuring argument can only be passed on as the original value,
+        # and anonymous arguments can only be forwarded since Ruby 3.2.
+        def zsuper_arguments_forwardable?(def_node)
+          def_node.arguments.none? do |arg|
+            arg.mlhs_type? ||
+              (arg.type?(:restarg, :kwrestarg) && !arg.name && target_ruby_version < 3.2)
+          end
+        end
+
         def yielding_arguments?(block_args, yield_args)
           yield_args = yield_args.dup.fill(
             nil,
@@ -110,6 +142,8 @@ module RuboCop
             insert_argument(node, corrector, block_name)
           elsif empty_arguments?(node)
             corrector.replace(node.arguments, "(&#{block_name})")
+          elsif index_call?(node)
+            corrector.replace(node.loc.selector, "[&#{block_name}]")
           elsif call_like?(node)
             correct_call_node(node, corrector, block_name)
           else
@@ -122,6 +156,10 @@ module RuboCop
           node.arguments.is_a?(RuboCop::AST::Node) && node.arguments.loc.begin
         end
 
+        def index_call?(node)
+          node.send_type? && node.method?(:[]) && !node.loc?(:dot)
+        end
+
         def call_like?(node)
           node.type?(:call, :zsuper, :super)
         end
@@ -141,19 +179,21 @@ module RuboCop
                           else
                             "&#{block_name}"
                           end
-          corrector.insert_after(node, "(#{new_arguments})")
-          return unless node.parenthesized?
-
-          args_begin = Util.args_begin(node)
-          args_end = Util.args_end(node)
-          range = range_between(args_begin.begin_pos, args_end.end_pos)
-          corrector.remove(range)
+          if node.parenthesized?
+            corrector.replace(node.loc.begin.join(node.loc.end), "(#{new_arguments})")
+          else
+            corrector.insert_after(node, "(#{new_arguments})")
+          end
         end
 
         def build_new_arguments_for_zsuper(node)
           def_node = node.each_ancestor(:any_def).first
-          def_node.arguments.map do |arg|
-            arg.optarg_type? ? arg.node_parts[0] : arg.source
+          def_node.arguments.filter_map do |arg|
+            case arg.type
+            when :arg, :optarg then arg.name.to_s
+            when :kwarg, :kwoptarg then "#{arg.name}: #{arg.name}"
+            when :restarg, :kwrestarg then arg.source
+            end
           end
         end
 

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

@@ -54,7 +54,7 @@ module RuboCop
           @contain_dev_null_string_in_file = ast.each_descendant(:str).any? do |str|
             content = str.str_content
 
-            valid_string?(content) && content.downcase == '/dev/null' # rubocop:disable Style/FileNull
+            valid_string?(content) && content.downcase == '/dev/null' # rubocop:disable Style/FileNull -- the cop needs the literal it is matching
           end
         end
 
@@ -62,7 +62,7 @@ module RuboCop
           value = node.value
           return unless valid_string?(value)
           return if acceptable?(node)
-          return if value.downcase == 'nul' && !@contain_dev_null_string_in_file # rubocop:disable Style/FileNull
+          return if value.downcase == 'nul' && !@contain_dev_null_string_in_file # rubocop:disable Style/FileNull -- the cop needs the literal it is matching
           return unless REGEXP.match?(value)
 
           add_offense(node, message: format(MSG, source: value)) do |corrector|

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

@@ -97,6 +97,7 @@ module RuboCop
 
         def on_send(node)
           return unless offense_condition?(node)
+          return if comment_before_to_f?(node)
 
           add_offense(node) do |corrector|
             case style
@@ -107,7 +108,7 @@ module RuboCop
               remove_to_f_method(corrector, node.receiver)
               add_to_f_method(corrector, node.first_argument)
             when :fdiv
-              correct_from_slash_to_fdiv(corrector, node, node.receiver, node.first_argument)
+              correct_from_slash_to_fdiv(corrector, node.receiver, node.first_argument)
             end
           end
         end
@@ -141,28 +142,41 @@ module RuboCop
         end
 
         def remove_to_f_method(corrector, send_node)
-          corrector.remove(send_node.loc.dot)
-          corrector.remove(send_node.loc.selector)
+          corrector.remove(send_node.receiver.source_range.end.join(send_node.loc.selector.end))
         end
 
-        def correct_from_slash_to_fdiv(corrector, node, receiver, argument)
-          receiver_source = extract_receiver_source(receiver)
-          argument_source = extract_receiver_source(argument)
+        def comment_before_to_f?(node)
+          operands_losing_to_f(node).any? do |operand|
+            next false unless to_f_method?(operand)
 
-          if argument.respond_to?(:parenthesized?) && !argument.parenthesized?
-            argument_source = "(#{argument_source})"
+            range = operand.receiver.source_range.end.join(operand.loc.selector.begin)
+            processed_source.contains_comment?(range)
           end
-
-          corrector.replace(node, "#{receiver_source}.fdiv#{argument_source}")
         end
 
-        def extract_receiver_source(node)
-          if node.send_type? && node.method?(:to_f)
-            node.receiver.source
+        def operands_losing_to_f(node)
+          case style
+          when :left_coerce, :single_coerce
+            [node.first_argument]
+          when :right_coerce
+            [node.receiver]
           else
-            node.source
+            [node.receiver, node.first_argument]
           end
         end
+
+        def correct_from_slash_to_fdiv(corrector, receiver, argument)
+          remove_to_f_method(corrector, receiver) if to_f_method?(receiver)
+
+          argument_parenthesized = argument.begin_type?
+          corrector.replace(
+            receiver.source_range.end.join(argument.source_range.begin),
+            argument_parenthesized ? '.fdiv' : '.fdiv('
+          )
+
+          remove_to_f_method(corrector, argument) if to_f_method?(argument)
+          corrector.insert_after(argument, ')') unless argument_parenthesized
+        end
       end
     end
   end

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

@@ -52,12 +52,21 @@ module RuboCop
         EACH_LENGTH = 'each'.length
         PREFER_EACH = 'Prefer `each` over `for`.'
         PREFER_FOR = 'Prefer `for` over `each`.'
+        IMPLICIT_PARAMETERS = %i[_1 _2 _3 _4 _5 _6 _7 _8 _9 it].to_set.freeze
+
+        # `Style/RedundantBegin` removes the `begin` of a block body in the same pass,
+        # leaving a `rescue` or `ensure` clause directly in the `for` body.
+        def self.autocorrect_incompatible_with
+          [Style::RedundantBegin]
+        end
 
         def on_for(node)
           if style == :each
             add_offense(node, message: PREFER_EACH) do |corrector|
-              ForToEachCorrector.new(node).call(corrector)
               opposite_style_detected
+              next unless convertible_to_each?(node)
+
+              ForToEachCorrector.new(node).call(corrector)
             end
           else
             correct_style_detected
@@ -69,6 +78,7 @@ module RuboCop
 
           if style == :for
             return unless node.receiver
+            return if rescue_or_ensure_body?(node) || do_end_block_in_collection?(node)
 
             add_offense(node, message: PREFER_FOR) do |corrector|
               EachToForCorrector.new(node).call(corrector)
@@ -84,9 +94,42 @@ module RuboCop
 
         private
 
+        # The loop variable becomes a block parameter, which can only be a local
+        # variable, and the body can't refer to an implicit block parameter
+        # (`_1` or `it`) once the block has an explicit one.
+        def convertible_to_each?(node)
+          return false unless node.variable.each_node.all? { |n| n.type?(:lvasgn, :mlhs, :splat) }
+          return true unless node.body
+
+          node.body.each_node(:send, :lvar).none? { |ref| implicit_parameter?(ref, node) }
+        end
+
+        # Inside a numbered or `it` block, `_1` and `it` are local variables
+        # rather than method calls.
+        def implicit_parameter?(ref, for_node)
+          return false unless implicit_parameter_reference?(ref)
+
+          ref.each_ancestor.take_while { |ancestor| !ancestor.equal?(for_node) }
+             .none?(&:any_block_type?)
+        end
+
+        def implicit_parameter_reference?(ref)
+          return IMPLICIT_PARAMETERS.include?(ref.name) if ref.lvar_type?
+
+          IMPLICIT_PARAMETERS.include?(ref.method_name) && !ref.receiver && !ref.arguments?
+        end
+
         def suspect_enumerable?(node)
           node.multiline? && node.method?(:each) && !node.send_node.arguments?
         end
+
+        def rescue_or_ensure_body?(node)
+          node.body&.type?(:rescue, :ensure)
+        end
+
+        def do_end_block_in_collection?(node)
+          node.receiver.each_node(:any_block).any?(&:keywords?)
+        end
       end
     end
   end

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

@@ -69,9 +69,13 @@ module RuboCop
 
         # @!method variable_argument?(node)
         def_node_matcher :variable_argument?, <<~PATTERN
-          (send {str dstr} :% #autocorrectable?)
+          (send {str dstr} :% !#autocorrectable?)
         PATTERN
 
+        def on_new_investigation
+          @corrected_ranges = nil
+        end
+
         def on_send(node)
           formatter(node) do |selector|
             detected_style = selector == :% ? :percent : selector
@@ -86,10 +90,12 @@ module RuboCop
 
         private
 
+        # Only an argument that is provably not an array can be corrected,
+        # because `String#%` spreads an array argument and `format` does not.
         def autocorrectable?(node)
-          return true if node.lvar_type?
+          return true if node.literal?
 
-          node.send_type? && !AUTOCORRECTABLE_METHODS.include?(node.method_name)
+          node.call_type? && AUTOCORRECTABLE_METHODS.include?(node.method_name)
         end
 
         def message(detected_style)
@@ -101,7 +107,9 @@ module RuboCop
         end
 
         def autocorrect(corrector, node)
-          return if variable_argument?(node)
+          return if variable_argument?(node) || within_corrected_range?(node)
+
+          corrected_ranges << node.source_range
 
           case node.method_name
           when :%
@@ -116,6 +124,14 @@ module RuboCop
           end
         end
 
+        def within_corrected_range?(node)
+          corrected_ranges.any? { |range| range.contains?(node.source_range) }
+        end
+
+        def corrected_ranges
+          @corrected_ranges ||= []
+        end
+
         def autocorrect_from_percent(corrector, node)
           percent_rhs = node.first_argument
           args = case percent_rhs.type
@@ -146,14 +162,20 @@ module RuboCop
         def format_single_parameter(arg)
           # `format(fmt, *args)` is equivalent to `fmt % args`, so unwrap the splat
           # and render the argument it splats.
-          return format_single_parameter(arg.children.first) if arg.splat_type?
+          return format_splatted_parameter(arg.children.first) if arg.splat_type?
 
           source = arg.source
-          return "{ #{source} }" if arg.hash_type?
+          return "{ #{source} }" if arg.hash_type? && !arg.braces?
 
           requires_parentheses?(arg) ? "(#{source})" : source
         end
 
+        def format_splatted_parameter(arg)
+          return "#{arg.source}.to_a" if arg.hash_type?
+
+          format_single_parameter(arg)
+        end
+
         # An argument that binds looser than `%` (a ternary, range, assignment, or
         # operator call) must be parenthesized to keep its meaning.
         def requires_parentheses?(arg)

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

@@ -228,7 +228,7 @@ module RuboCop
           "Prefer #{message_text(style)} over #{message_text(detected_style)}."
         end
 
-        # rubocop:disable-next Style/FormatStringToken
+        # rubocop:disable-next Style/FormatStringToken -- the cop needs the token style it is matching
         def message_text(style)
           {
             annotated: 'annotated tokens (like `%<foo>s`)',

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

@@ -142,7 +142,8 @@ module RuboCop
           end
 
           next_token = processed_source.tokens[token_number]
-          if next_token&.text&.valid_encoding? && Encoding::ENCODING_PATTERN.match?(next_token.text)
+          if next_token&.text&.valid_encoding? &&
+             MagicComment.parse(next_token.text).encoding_specified?
             token = next_token
           end
 

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

@@ -109,6 +109,10 @@ module RuboCop
         MSG = 'Use a guard clause (`%<example>s`) instead of wrapping the ' \
               'code inside a conditional expression.'
 
+        def self.autocorrect_incompatible_with
+          [Style::MissingElse]
+        end
+
         def on_def(node)
           body = node.body
 
@@ -278,7 +282,15 @@ module RuboCop
         end
 
         def accepted_form?(node, ending: false)
-          accepted_if?(node, ending) || node.condition.multiline? || node.parent&.assignment?
+          accepted_if?(node, ending) || node.condition.multiline? ||
+            node.parent&.assignment? || endless_method_body?(node)
+        end
+
+        # The body of an endless method is a single expression, so there is no
+        # room for a guard clause followed by the rest of the code.
+        def endless_method_body?(node)
+          parent = node.parent
+          parent&.any_def_type? && parent.endless?
         end
 
         def trivial?(node)