rubocop 1.91.0 → 1.92.1

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/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
@@ -141,8 +142,27 @@ 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 comment_before_to_f?(node)
+          operands_losing_to_f(node).any? do |operand|
+            next false unless to_f_method?(operand)
+
+            range = operand.receiver.source_range.end.join(operand.loc.selector.begin)
+            processed_source.contains_comment?(range)
+          end
+        end
+
+        def operands_losing_to_f(node)
+          case style
+          when :left_coerce, :single_coerce
+            [node.first_argument]
+          when :right_coerce
+            [node.receiver]
+          else
+            [node.receiver, node.first_argument]
+          end
         end
 
         def correct_from_slash_to_fdiv(corrector, receiver, argument)

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

@@ -52,12 +52,23 @@ 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.
+        # `Style/ItBlockParameter` replaces block parameter references in the body
+        # with `it` in the same pass, while they become `for` loop variables.
+        def self.autocorrect_incompatible_with
+          [Style::RedundantBegin, Style::ItBlockParameter]
+        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,7 +80,8 @@ module RuboCop
 
           if style == :for
             return unless node.receiver
-            return if rescue_or_ensure_body?(node)
+            return unless convertible_to_for?(node)
+            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)
@@ -85,13 +97,52 @@ 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 convertible_to_for?(node)
+          return false if node.type?(:numblock, :itblock)
+          return true unless node.arguments?
+
+          arguments = node.arguments
+          return false if arguments.children.one? && arguments.children.first.restarg_type?
+
+          arguments.each_descendant.all? { |arg| arg.type?(:arg, :restarg, :mlhs) }
+        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/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

@@ -186,40 +186,37 @@ module RuboCop
             return if trivial?(node)
 
             example = "#{conditional_keyword} #{condition.source}; #{scope_exiting_keyword}; end"
-            replacement = <<~RUBY.chomp
-              #{conditional_keyword} #{condition.source}
-                #{scope_exiting_keyword}
-              end
-            RUBY
+            replacement = "#{conditional_keyword} #{condition.source}\n  #{scope_exiting_keyword}"
           end
 
           add_offense(node.loc.keyword, message: format(MSG, example: example)) do |corrector|
             next if node.else? && guard.nil?
 
-            autocorrect(corrector, node, condition, replacement || example, guard)
+            autocorrect(corrector, node, example, replacement, guard)
           end
         end
 
         # rubocop:disable-next Metrics/AbcSize
-        def autocorrect(corrector, node, condition, replacement, guard)
-          corrector.replace(node.loc.keyword.join(condition.source_range), replacement)
-
-          if_branch = node.if_branch
-          else_branch = node.else_branch
-
+        def autocorrect(corrector, node, example, multiline_replacement, guard)
+          range = node.loc.keyword.join(node.condition.source_range)
+          corrector.replace(range, multiline_replacement || example)
           corrector.replace(node.loc.begin, "\n") if node.then?
 
-          if (if_heredoc = find_heredoc_argument(if_branch))
-            autocorrect_heredoc_argument(corrector, node, if_heredoc, else_branch, guard)
-          elsif (else_heredoc = find_heredoc_argument(else_branch))
-            autocorrect_heredoc_argument(corrector, node, else_heredoc, if_branch, guard)
-          else
-            corrector.remove(node.loc.end)
-            return unless node.else?
+          branches = [node.if_branch, node.else_branch]
+          guard_branch, leave_branch = guard == :else ? branches.reverse : branches
 
-            corrector.remove(node.loc.else)
-            corrector.remove(range_of_branch_to_remove(node, guard))
+          heredoc = find_heredoc_argument(guard_branch)
+          close_multiline_guard_clause(corrector, range, heredoc, guard) if multiline_replacement
+
+          if heredoc
+            return autocorrect_heredoc_argument(corrector, node, heredoc, leave_branch, guard)
           end
+
+          corrector.remove(node.loc.end)
+          return unless node.else?
+
+          corrector.remove(node.loc.else)
+          corrector.remove(range_of_branch_to_remove(node, guard))
         end
 
         def heredoc?(argument)
@@ -241,6 +238,10 @@ module RuboCop
           find_heredoc_argument(node.receiver)
         end
 
+        def close_multiline_guard_clause(corrector, range, heredoc, guard)
+          corrector.insert_after(guard && heredoc ? heredoc.loc.heredoc_end : range, "\nend")
+        end
+
         def autocorrect_heredoc_argument(corrector, node, heredoc_node, leave_branch, guard)
           remove_whole_lines(corrector, node.loc.end)
           return unless node.else?
@@ -282,7 +283,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)

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

@@ -44,6 +44,10 @@ module RuboCop
         include ConfigurableEnforcedStyle
         extend AutoCorrector
 
+        def self.autocorrect_incompatible_with
+          [Style::TrailingCommaInArrayLiteral]
+        end
+
         def on_hash(node)
           return if node.children.first&.kwsplat_type?
           return unless (array = containing_array(node))

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

@@ -53,6 +53,12 @@ module RuboCop
         # @!method hash_from_array?(node)
         def_node_matcher :hash_from_array?, '(send (const {nil? cbase} :Hash) :[] ...)'
 
+        # A hash literal as the first argument needs the parentheses of the call,
+        # which `Style/MethodCallWithArgsParentheses` removes in the same pass.
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
+
         def on_send(node)
           return if part_of_ignored_node?(node) || !hash_from_array?(node)
 
@@ -95,12 +101,30 @@ module RuboCop
         def register_offense_for_hash(node, hash_argument)
           add_offense(node, message: MSG_LITERAL_HASH_ARG) do |corrector|
             corrector.replace(node, "{#{hash_argument.source}}")
-
-            parent = node.parent
-            add_parentheses(parent, corrector) if parent&.send_type? && !parent.parenthesized?
+            add_parentheses_to_parent_call(node, corrector)
           end
         end
 
+        # Without parentheses, a hash literal at the start of the first argument would be
+        # parsed as a block. That includes an argument like `Hash[a, b].merge(c)`.
+        def add_parentheses_to_parent_call(node, corrector)
+          node = node.parent while starts_parent?(node)
+          parent = node.parent
+          return unless parent&.type?(:call, :super, :yield)
+          return if parent.parenthesized? || operator_syntax?(parent)
+
+          add_parentheses(parent, corrector)
+        end
+
+        def starts_parent?(node)
+          node.parent && node.parent.source_range.begin_pos == node.source_range.begin_pos
+        end
+
+        # `foo[x]`, `foo.bar = x` and `foo == x` take a hash literal as it is.
+        def operator_syntax?(call)
+          call.setter_method? || (call.operator_method? && !call.loc?(:dot))
+        end
+
         def register_offense_for_zip_method(node, zip_method)
           add_offense(node, message: MSG_TO_H) do |corrector|
             if zip_method.parenthesized?
@@ -135,11 +159,7 @@ module RuboCop
         def correct_multi_argument(node)
           add_offense(node, message: MSG_LITERAL_MULTI_ARG) do |corrector|
             corrector.replace(node, args_to_hash(node.arguments))
-
-            parent = node.parent
-            if parent&.send_type? && !parent.method?(:to_h) && !parent.parenthesized?
-              add_parentheses(parent, corrector)
-            end
+            add_parentheses_to_parent_call(node, corrector)
           end
         end
 

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

@@ -34,6 +34,9 @@ module RuboCop
       #   # good - fetch with block is allowed
       #   hash.fetch(key) { default }
       #
+      #   # good - `ENV.fetch` is left to `Style/FetchEnvVar` when it is enabled
+      #   ENV.fetch(key)
+      #
       # @example EnforcedStyle: fetch
       #   # bad
       #   hash[key]
@@ -55,6 +58,9 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[[] fetch].freeze
 
+        # @!method env_const?(node)
+        def_node_matcher :env_const?, '(const {nil? cbase} :ENV)'
+
         def on_send(node)
           return if (receiver = node.receiver) && allowed_receiver?(receiver)
           return if part_of_ignored_node?(node)
@@ -76,28 +82,45 @@ module RuboCop
         private
 
         def offense_for_brackets?(node)
-          style == :brackets && node.receiver && node.method?(:fetch) && node.arguments.one? &&
-            !node.block_literal? && !node.csend_type?
+          return false if style != :brackets || !node.receiver
+          return false if !node.method?(:fetch) || !node.arguments.one?
+          return false if node.block_literal? || node.csend_type?
+
+          !exempt_from_brackets?(node)
+        end
+
+        def exempt_from_brackets?(node)
+          comment_before_dot?(node) || env_fetch_preferred?(node.receiver)
+        end
+
+        def comment_before_dot?(node)
+          processed_source.contains_comment?(node.receiver.source_range.end.join(node.loc.dot))
+        end
+
+        def env_fetch_preferred?(receiver)
+          env_const?(receiver) && processed_source.registry.enabled?(Style::FetchEnvVar, config)
         end
 
         def offense_for_fetch?(node)
-          style == :fetch && node.method?(:[]) && node.arguments.one?
+          style == :fetch && node.method?(:[]) && node.arguments.one? &&
+            !compound_assignment_target?(node)
+        end
+
+        def compound_assignment_target?(node)
+          node.parent&.type?(:op_asgn, :or_asgn, :and_asgn) && node.parent.children.first == node
         end
 
         def correct_fetch_to_brackets(corrector, node)
           key = node.first_argument.source
 
-          corrector.replace(node.loc.dot.join(node.source_range.end), "[#{key}]")
+          corrector.replace(node.receiver.source_range.end.join(node.source_range.end), "[#{key}]")
         end
 
         def correct_brackets_to_fetch(corrector, node)
           key = node.first_argument.source
+          replacement = node.loc.dot ? "fetch(#{key})" : ".fetch(#{key})"
 
-          if node.csend_type?
-            corrector.replace(node.loc.dot.join(node.source_range.end), "&.fetch(#{key})")
-          else
-            corrector.replace(node.loc.selector.join(node.source_range.end), ".fetch(#{key})")
-          end
+          corrector.replace(node.loc.selector.join(node.source_range.end), replacement)
         end
       end
     end

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

@@ -142,6 +142,13 @@ module RuboCop
         MSG_HASH_ROCKETS = 'Use hash rockets syntax.'
         NO_MIXED_KEYS_STYLES = %i[ruby19_no_mixed_keys no_mixed_keys].freeze
 
+        # Omitting the last hash value of a call without parentheses adds the parentheses,
+        # which `Style/MethodCallWithArgsParentheses` and `Style/SuperWithArgsParentheses`
+        # would add again in the same pass.
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses, Style::SuperWithArgsParentheses]
+        end
+
         def on_hash(node)
           pairs = node.pairs
 
@@ -241,6 +248,8 @@ module RuboCop
         def check(pairs, delim, msg)
           pairs.each do |pair|
             if pair.delimiter == delim
+              next if pair.value_omission? && keyword_value?(pair)
+
               location = pair.source_range.begin.join(pair.loc.operator)
               add_offense(location, message: msg) do |corrector|
                 autocorrect(corrector, pair)
@@ -283,12 +292,16 @@ module RuboCop
         end
 
         def autocorrect_hash_rockets(corrector, pair_node)
-          op = pair_node.loc.operator
-
           key_with_hash_rocket = ":#{pair_node.key.source}#{pair_node.inverse_delimiter(true)}"
           key_with_hash_rocket += pair_node.key.source if pair_node.value_omission?
           corrector.replace(pair_node.key, key_with_hash_rocket)
-          corrector.remove(range_with_surrounding_space(op))
+          corrector.remove(operator_range(pair_node))
+        end
+
+        def operator_range(pair_node)
+          op = pair_node.loc.operator
+
+          range_with_surrounding_space(op, newlines: !pair_node.value_omission?)
         end
 
         def autocorrect_no_mixed_keys(corrector, pair_node)

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

@@ -188,7 +188,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def check_expressions(node, expressions, insert_position)
           return if expressions.any?(&:nil?)
 
@@ -198,8 +198,7 @@ module RuboCop
             add_offense(expression) do |corrector|
               next if node.if_type? && (node.ternary? || node.then?)
 
-              range = range_by_whole_lines(expression.source_range, include_final_newline: true)
-              corrector.remove(range)
+              corrector.remove(removal_range(expression))
               next if inserted_expression
 
               if node.parent&.assignment?
@@ -213,6 +212,26 @@ module RuboCop
           end
         end
 
+        def removal_range(expression)
+          range = expression.source_range
+          whole_lines = range_by_whole_lines(range, include_final_newline: true)
+          return whole_lines if whole_lines.source.strip == expression.source
+
+          range_with_separator(range)
+        end
+
+        def range_with_separator(range)
+          source = range.source_buffer.source
+
+          if (following = source[range.end_pos..][/\A[ \t]*;[ \t]*/])
+            range.adjust(end_pos: following.length)
+          elsif (preceding = source[0...range.begin_pos][/[ \t]*;[ \t]*\z/])
+            range.adjust(begin_pos: -preceding.length)
+          else
+            range_with_surrounding_space(range, side: :right, newlines: false)
+          end
+        end
+
         def correct_assignment(corrector, node, expression, insert_position)
           indentation = indentation_of(node.parent)