rubocop 1.66.1 → 1.67.0

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

@@ -180,7 +180,8 @@ module RuboCop
         end
 
         def only_forwards_all?(send_classifications)
-          send_classifications.all? { |_, c, _, _| c == :all }
+          all_classifications = %i[all all_anonymous].freeze
+          send_classifications.all? { |_, c, _, _| all_classifications.include?(c) }
         end
 
         # rubocop:disable Metrics/MethodLength
@@ -188,8 +189,8 @@ module RuboCop
           _rest_arg, _kwrest_arg, block_arg = *forwardable_args
           registered_block_arg_offense = false
 
-          send_classifications.each do |send_node, _c, forward_rest, forward_kwrest, forward_block_arg| # rubocop:disable Layout/LineLength
-            if !forward_rest && !forward_kwrest
+          send_classifications.each do |send_node, c, forward_rest, forward_kwrest, forward_block_arg| # rubocop:disable Layout/LineLength
+            if !forward_rest && !forward_kwrest && c != :all_anonymous
               # Prevents `anonymous block parameter is also used within block (SyntaxError)` occurs
               # in Ruby 3.3.0.
               if outside_block?(forward_block_arg)
@@ -213,6 +214,7 @@ module RuboCop
         # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         def add_post_ruby_32_offenses(def_node, send_classifications, forwardable_args)
           return unless use_anonymous_forwarding?
+          return if send_inside_block?(send_classifications)
 
           rest_arg, kwrest_arg, block_arg = *forwardable_args
 
@@ -355,8 +357,15 @@ module RuboCop
           cop_config.fetch('UseAnonymousForwarding', false)
         end
 
+        def send_inside_block?(send_classifications)
+          send_classifications.any? do |send_node, *|
+            send_node.each_ancestor(:block, :numblock).any?
+          end
+        end
+
         def add_parens_if_missing(node, corrector)
           return if parentheses?(node)
+          return if node.send_type? && node.method?(:[])
 
           add_parentheses(node, corrector)
         end
@@ -374,6 +383,23 @@ module RuboCop
           # @!method forwarded_block_arg?(node, block_name)
           def_node_matcher :forwarded_block_arg?, '(block_pass {(lvar %1) nil?})'
 
+          # @!method def_all_anonymous_args?(node)
+          def_node_matcher :def_all_anonymous_args?, <<~PATTERN
+            (
+              def _
+              (args ... (restarg) (kwrestarg) (blockarg nil?))
+              _
+            )
+          PATTERN
+
+          # @!method send_all_anonymous_args?(node)
+          def_node_matcher :send_all_anonymous_args?, <<~PATTERN
+            (
+              send _ _
+              ... (forwarded_restarg) (hash (forwarded_kwrestarg)) (block_pass nil?)
+            )
+          PATTERN
+
           def initialize(def_node, send_node, referenced_lvars, forwardable_args, **config)
             @def_node = def_node
             @send_node = send_node
@@ -405,7 +431,9 @@ module RuboCop
           def classification
             return nil unless forwarded_rest_arg || forwarded_kwrest_arg || forwarded_block_arg
 
-            if can_forward_all?
+            if ruby_32_only_anonymous_forwarding?
+              :all_anonymous
+            elsif can_forward_all?
               :all
             else
               :rest_or_kwrest
@@ -414,16 +442,28 @@ module RuboCop
 
           private
 
+          # rubocop:disable Metrics/CyclomaticComplexity
           def can_forward_all?
             return false if any_arg_referenced?
-            return false if ruby_32_missing_rest_or_kwest?
+            return false if ruby_30_or_lower_optarg?
+            return false if ruby_32_or_higher_missing_rest_or_kwest?
             return false unless offensive_block_forwarding?
             return false if additional_kwargs_or_forwarded_kwargs?
 
             no_additional_args? || (target_ruby_version >= 3.0 && no_post_splat_args?)
           end
+          # rubocop:enable Metrics/CyclomaticComplexity
+
+          # def foo(a = 41, ...) is a syntax error in 3.0.
+          def ruby_30_or_lower_optarg?
+            target_ruby_version <= 3.0 && @def_node.arguments.any?(&:optarg_type?)
+          end
+
+          def ruby_32_only_anonymous_forwarding?
+            def_all_anonymous_args?(@def_node) && send_all_anonymous_args?(@send_node)
+          end
 
-          def ruby_32_missing_rest_or_kwest?
+          def ruby_32_or_higher_missing_rest_or_kwest?
             target_ruby_version >= 3.2 && !forwarded_rest_and_kwrest_args
           end
 

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

@@ -176,6 +176,10 @@ module RuboCop
 
         BRACES_REQUIRED_MESSAGE = "Brace delimiters `{...}` required for '%<method_name>s' method."
 
+        def self.autocorrect_incompatible_with
+          [Style::RedundantBegin]
+        end
+
         def on_send(node)
           return unless node.arguments?
           return if node.parenthesized?
@@ -341,8 +345,9 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def proper_block_style?(node)
-          return true if require_braces?(node)
+          return true if require_braces?(node) || require_do_end?(node)
           return special_method_proper_block_style?(node) if special_method?(node.method_name)
 
           case style
@@ -352,6 +357,7 @@ module RuboCop
           when :always_braces       then braces_style?(node)
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def require_braces?(node)
           return false unless node.braces?
@@ -361,6 +367,13 @@ module RuboCop
           end
         end
 
+        def require_do_end?(node)
+          return false if node.braces? || node.multiline?
+          return false unless (resbody = node.each_descendant(:resbody).first)
+
+          resbody.children.first&.array_type?
+        end
+
         def special_method?(method_name)
           allowed_method?(method_name) ||
             matches_allowed_pattern?(method_name) ||

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

@@ -21,6 +21,7 @@ module RuboCop
       #   array.reject(&:nil?)
       #   array.reject { |e| e.nil? }
       #   array.select { |e| !e.nil? }
+      #   array.filter { |e| !e.nil? }
       #   array.grep_v(nil)
       #   array.grep_v(NilClass)
       #
@@ -29,10 +30,9 @@ module RuboCop
       #
       #   # bad
       #   hash.reject!(&:nil?)
-      #   array.delete_if(&:nil?)
       #   hash.reject! { |k, v| v.nil? }
-      #   array.delete_if { |e| e.nil? }
       #   hash.select! { |k, v| !v.nil? }
+      #   hash.filter! { |k, v| !v.nil? }
       #
       #   # good
       #   hash.compact!
@@ -48,14 +48,15 @@ module RuboCop
         extend TargetRubyVersion
 
         MSG = 'Use `%<good>s` instead of `%<bad>s`.'
-        RESTRICT_ON_SEND = %i[reject delete_if reject! select select! grep_v].freeze
+        RESTRICT_ON_SEND = %i[reject reject! select select! filter filter! grep_v].freeze
         TO_ENUM_METHODS = %i[to_enum lazy].freeze
+        FILTER_METHODS = %i[filter filter!].freeze
 
         minimum_target_ruby_version 2.4
 
         # @!method reject_method_with_block_pass?(node)
         def_node_matcher :reject_method_with_block_pass?, <<~PATTERN
-          (call !nil? {:reject :delete_if :reject!}
+          (call !nil? {:reject :reject!}
             (block_pass
               (sym :nil?)))
         PATTERN
@@ -64,7 +65,7 @@ module RuboCop
         def_node_matcher :reject_method?, <<~PATTERN
           (block
             (call
-              !nil? {:reject :delete_if :reject!})
+              !nil? {:reject :reject!})
             $(args ...)
             (call
               $(lvar _) :nil?))
@@ -74,7 +75,7 @@ module RuboCop
         def_node_matcher :select_method?, <<~PATTERN
           (block
             (call
-              !nil? {:select :select!})
+              !nil? {:select :select! :filter :filter!})
             $(args ...)
             (call
               (call
@@ -87,11 +88,10 @@ module RuboCop
         PATTERN
 
         def on_send(node)
+          return if target_ruby_version < 2.6 && FILTER_METHODS.include?(node.method_name)
           return unless (range = offense_range(node))
           return if allowed_receiver?(node.receiver)
-          if (target_ruby_version <= 3.0 || node.method?(:delete_if)) && to_enum_method?(node)
-            return
-          end
+          return if target_ruby_version <= 3.0 && to_enum_method?(node)
 
           good = good_method_name(node)
           message = format(MSG, good: good, bad: range.source)
@@ -127,7 +127,7 @@ module RuboCop
         end
 
         def good_method_name(node)
-          if node.bang_method? || node.method?(:delete_if)
+          if node.bang_method?
             'compact!'
           else
             'compact'

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

@@ -7,6 +7,9 @@ module RuboCop
       # can be combined into a single loop. It is very likely that combining them
       # will make the code more efficient and more concise.
       #
+      # NOTE: Autocorrection is not applied when the block variable names differ in separate loops,
+      # as it is impossible to determine which variable name should be prioritized.
+      #
       # @safety
       #   The cop is unsafe, because the first loop might modify state that the
       #   second loop depends on; these two aren't combinable.
@@ -61,6 +64,7 @@ module RuboCop
 
         MSG = 'Combine this loop with the previous loop.'
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def on_block(node)
           return unless node.parent&.begin_type?
           return unless collection_looping_method?(node)
@@ -68,9 +72,12 @@ module RuboCop
           return unless node.body && node.left_sibling.body
 
           add_offense(node) do |corrector|
+            next unless node.arguments == node.left_sibling.arguments
+
             combine_with_left_sibling(corrector, node)
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         alias on_numblock on_block
 

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

@@ -10,7 +10,7 @@ module RuboCop
       #
       # Note that some comments
       # (`:nodoc:`, `:yields:`, `rubocop:disable` and `rubocop:todo`)
-      # are allowed.
+      # and RBS::Inline annotation comments are allowed.
       #
       # Autocorrection removes comments from `end` keyword and keeps comments
       # for `class`, `module`, `def` and `begin` above the keyword.
@@ -82,6 +82,8 @@ module RuboCop
 
         def offensive?(comment)
           line = source_line(comment)
+          return false if rbs_inline_annotation?(line, comment)
+
           KEYWORD_REGEXES.any? { |r| r.match?(line) } &&
             ALLOWED_COMMENT_REGEXES.none? { |r| r.match?(line) }
         end
@@ -89,6 +91,10 @@ module RuboCop
         def source_line(comment)
           comment.source_range.source_line
         end
+
+        def rbs_inline_annotation?(line, comment)
+          comment.text.start_with?('#:') && line.start_with?(/\A\s*def\s/)
+        end
       end
     end
   end

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

@@ -73,7 +73,7 @@ module RuboCop
           elsif_branches << node.if_branch
 
           else_branch = node.else_branch
-          if else_branch&.if_type? && else_branch&.elsif?
+          if else_branch&.if_type? && else_branch.elsif?
             expand_elsif(else_branch, elsif_branches)
           else
             elsif_branches << else_branch

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

@@ -36,7 +36,7 @@ module RuboCop
         def on_class(node)
           return unless data_define?(node.parent_class)
 
-          add_offense(node.parent_class.source_range) do |corrector|
+          add_offense(node.parent_class) do |corrector|
             corrector.remove(range_with_surrounding_space(node.loc.keyword, newlines: false))
             corrector.replace(node.loc.operator, '=')
 

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

@@ -136,7 +136,7 @@ module RuboCop
                            actual: line_node.source,
                            expected: expected)
 
-          add_offense(line_node.source_range, message: message) do |corrector|
+          add_offense(line_node, message: message) do |corrector|
             corrector.replace(line_node, expected)
           end
         end

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

@@ -234,11 +234,11 @@ module RuboCop
         end
 
         def autocorrect_heredoc_argument(corrector, node, heredoc_branch, leave_branch, guard)
+          remove_whole_lines(corrector, node.loc.end)
           return unless node.else?
 
           remove_whole_lines(corrector, leave_branch.source_range)
           remove_whole_lines(corrector, node.loc.else)
-          remove_whole_lines(corrector, node.loc.end)
           remove_whole_lines(corrector, range_of_branch_to_remove(node, guard))
           corrector.insert_after(
             heredoc_branch.last_argument.loc.heredoc_end, "\n#{leave_branch.source}"

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

@@ -57,6 +57,11 @@ module RuboCop
           (call $(call _ ${:keys :values}) :each (block_pass (sym _)))
         PATTERN
 
+        # @!method hash_mutated?(node, receiver)
+        def_node_matcher :hash_mutated?, <<~PATTERN
+          `(send %1 :[]= ...)
+        PATTERN
+
         def on_block(node)
           return unless handleable?(node)
 
@@ -103,6 +108,7 @@ module RuboCop
         def handleable?(node)
           return false if use_array_converter_method_as_preceding?(node)
           return false unless (root_receiver = root_receiver(node))
+          return false if hash_mutated?(node, root_receiver)
 
           !root_receiver.literal? || root_receiver.hash_type?
         end

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

@@ -68,7 +68,7 @@ module RuboCop
       #   {a: 1, b: 2}
       #   {:c => 3, 'd' => 4}
       #
-      # @example EnforcedShorthandSyntax: always (default)
+      # @example EnforcedShorthandSyntax: always
       #
       #   # bad
       #   {foo: foo, bar: bar}
@@ -84,7 +84,7 @@ module RuboCop
       #   # good
       #   {foo: foo, bar: bar}
       #
-      # @example EnforcedShorthandSyntax: either
+      # @example EnforcedShorthandSyntax: either (default)
       #
       #   # good
       #   {foo: foo, bar: bar}

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

@@ -71,7 +71,7 @@ module RuboCop
 
           else_branch = node.else_branch
 
-          return unless else_branch&.if_type? && else_branch&.if?
+          return unless else_branch&.if_type? && else_branch.if?
           return if allow_if_modifier_in_else_branch?(else_branch)
 
           add_offense(else_branch.loc.keyword) do |corrector|

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

@@ -81,16 +81,14 @@ module RuboCop
           RUBY
         end
 
-        # rubocop:disable Metrics/AbcSize
         def build_expression(expr)
-          return expr.source if !expr.call_type? || expr.parenthesized? || expr.arguments.empty?
+          return expr.source unless require_argument_parentheses?(expr)
 
           method = expr.source_range.begin.join(expr.loc.selector.end)
           arguments = expr.first_argument.source_range.begin.join(expr.source_range.end)
 
           "#{method.source}(#{arguments.source})"
         end
-        # rubocop:enable Metrics/AbcSize
 
         def build_else_branch(second_condition)
           result = <<~RUBY
@@ -111,6 +109,12 @@ module RuboCop
 
           result
         end
+
+        def require_argument_parentheses?(node)
+          return false unless node.call_type?
+
+          !node.parenthesized? && node.arguments.any? && !node.method?(:[]) && !node.method?(:[]=)
+        end
       end
     end
   end

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

@@ -68,7 +68,7 @@ module RuboCop
 
           return unless offending_selector?(node, selector)
 
-          add_offense(node.send_node.source_range, message: message(node, selector)) do |corrector|
+          add_offense(node.send_node, message: message(node, selector)) do |corrector|
             if node.send_node.lambda_literal?
               LambdaLiteralToMethodCorrector.new(node).call(corrector)
             else

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

@@ -13,8 +13,10 @@ module RuboCop
       # return value of `Enumerable#map` is an `Array`. They are not autocorrected
       # when a return value could be used because these types differ.
       #
-      # NOTE: It only detects when the mapping destination is a local variable
-      # initialized as an empty array and referred to only by the pushing operation.
+      # NOTE: It only detects when the mapping destination is either:
+      # * a local variable initialized as an empty array and referred to only by the
+      # pushing operation;
+      # * or, if it is the single block argument to a `[].tap` block.
       # This is because, if not, it's challenging to statically guarantee that the
       # mapping destination variable remains an empty array:
       #
@@ -42,6 +44,14 @@ module RuboCop
       #   # good
       #   dest = src.map { |e| e * 2 }
       #
+      #   # bad
+      #   [].tap do |dest|
+      #     src.each { |e| dest << e * 2 }
+      #   end
+      #
+      #   # good
+      #   dest = src.map { |e| e * 2 }
+      #
       #   # good - contains another operation
       #   dest = []
       #   src.each { |e| dest << e * 2; puts e }
@@ -56,7 +66,7 @@ module RuboCop
         # @!method each_block_with_push?(node)
         def_node_matcher :each_block_with_push?, <<-PATTERN
           [
-            ^({begin kwbegin} ...)
+            ^({begin kwbegin block} ...)
             ({block numblock} (send !{nil? self} :each) _
               (send (lvar _) {:<< :push :append} {send lvar begin}))
           ]
@@ -74,6 +84,16 @@ module RuboCop
           )
         PATTERN
 
+        # @!method empty_array_tap(node)
+        def_node_matcher :empty_array_tap, <<~PATTERN
+          ^^$(
+            block
+              (send (array) :tap)
+              (args (arg _))
+              ...
+          )
+        PATTERN
+
         # @!method lvar_ref?(node, name)
         def_node_matcher :lvar_ref?, '(lvar %1)'
 
@@ -89,9 +109,14 @@ module RuboCop
           return unless each_block_with_push?(node)
 
           dest_var = find_dest_var(node)
-          return unless (asgn = find_closest_assignment(node, dest_var))
-          return unless empty_array_asgn?(asgn)
-          return unless dest_used_only_for_mapping?(node, dest_var, asgn)
+
+          if offending_empty_array_tap?(node, dest_var)
+            asgn = dest_var.declaration_node
+          else
+            return unless (asgn = find_closest_assignment(node, dest_var))
+            return unless empty_array_asgn?(asgn)
+            return unless dest_used_only_for_mapping?(node, dest_var, asgn)
+          end
 
           register_offense(node, dest_var, asgn)
         end
@@ -108,6 +133,15 @@ module RuboCop
           candidates.find { |v| v.references.any? { |n| n.node.equal?(node) } }
         end
 
+        def offending_empty_array_tap?(node, dest_var)
+          return false unless (tap_block_node = empty_array_tap(dest_var.declaration_node))
+
+          # A `tap` block only offends if the array push is the only thing in it;
+          # otherwise we cannot guarantee that the block variable is still an empty
+          # array when pushed to.
+          tap_block_node.body == node
+        end
+
         def find_closest_assignment(block, dest_var)
           dest_var.assignments.reverse_each.lazy.map(&:node).find do |node|
             node.source_range.end_pos < block.source_range.begin_pos
@@ -127,7 +161,13 @@ module RuboCop
             next if return_value_used?(block)
 
             corrector.replace(block.send_node.selector, new_method_name)
-            remove_assignment(corrector, asgn)
+
+            if (tap_block_node = empty_array_tap(dest_var.declaration_node))
+              remove_tap(corrector, block, tap_block_node)
+            else
+              remove_assignment(corrector, asgn)
+            end
+
             correct_push_node(corrector, block.body)
             correct_return_value_handling(corrector, block, dest_var)
           end
@@ -159,6 +199,12 @@ module RuboCop
           corrector.remove(range)
         end
 
+        def remove_tap(corrector, node, block_node)
+          range = range_between(block_node.source_range.begin_pos, node.source_range.begin_pos)
+          corrector.remove(range)
+          corrector.remove(range_with_surrounding_space(block_node.loc.end, side: :left))
+        end
+
         def correct_push_node(corrector, push_node)
           range = push_node.source_range
           arg_range = push_node.first_argument.source_range

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

@@ -7,6 +7,8 @@ module RuboCop
         # Style omit_parentheses
         # rubocop:disable Metrics/ModuleLength, Metrics/CyclomaticComplexity
         module OmitParentheses
+          include RangeHelp
+
           TRAILING_WHITESPACE_REGEX = /\s+\Z/.freeze
           OMIT_MSG = 'Omit parentheses for method calls with arguments.'
           private_constant :OMIT_MSG
@@ -30,10 +32,13 @@ module RuboCop
           end
 
           def autocorrect(corrector, node)
+            range = args_begin(node)
             if parentheses_at_the_end_of_multiline_call?(node)
-              corrector.replace(args_begin(node), ' \\')
+              # Whitespace after line continuation (`\ `) is a syntax error
+              with_whitespace = range_with_surrounding_space(range, side: :right, newlines: false)
+              corrector.replace(with_whitespace, ' \\')
             else
-              corrector.replace(args_begin(node), ' ')
+              corrector.replace(range, ' ')
             end
             corrector.remove(node.loc.end)
           end
@@ -47,11 +52,11 @@ module RuboCop
             node.each_ancestor(:def, :defs).any?(&:endless?) && node.arguments.any?
           end
 
-          def require_parentheses_for_hash_value_omission?(node)
+          def require_parentheses_for_hash_value_omission?(node) # rubocop:disable Metrics/PerceivedComplexity
             return false unless (last_argument = node.last_argument)
             return false if !last_argument.hash_type? || !last_argument.pairs.last&.value_omission?
 
-            node.parent&.conditional? || !last_expression?(node)
+            node.parent&.conditional? || node.parent&.single_line? || !last_expression?(node)
           end
 
           # Require hash value omission be enclosed in parentheses to prevent the following issue:
@@ -127,7 +132,7 @@ module RuboCop
           end
 
           def call_in_single_line_inheritance?(node)
-            node.parent&.class_type? && node.parent&.single_line?
+            node.parent&.class_type? && node.parent.single_line?
           end
 
           def call_with_ambiguous_arguments?(node) # rubocop:disable Metrics/PerceivedComplexity
@@ -147,7 +152,7 @@ module RuboCop
           end
 
           def call_in_argument_with_block?(node)
-            parent = node.parent&.block_type? && node.parent&.parent
+            parent = node.parent&.block_type? && node.parent.parent
             return false unless parent
 
             parent.call_type? || parent.super_type? || parent.yield_type?
@@ -211,7 +216,7 @@ module RuboCop
 
           def unary_literal?(node)
             (node.numeric_type? && node.sign?) ||
-              (node.parent&.send_type? && node.parent&.unary_operation?)
+              (node.parent&.send_type? && node.parent.unary_operation?)
           end
 
           def assigned_before?(node, target)

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

@@ -43,7 +43,7 @@ module RuboCop
 
           return unless bad_rhs?(rhs)
 
-          add_offense(node.source_range) do |corrector|
+          add_offense(node) do |corrector|
             if style == :keyword
               keyword_autocorrect(rhs, corrector)
             else

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

@@ -36,7 +36,7 @@ module RuboCop
         end
 
         def modifier?(node)
-          node&.basic_conditional? && node&.modifier_form?
+          node&.basic_conditional? && node.modifier_form?
         end
 
         def autocorrect(corrector, node)

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

@@ -39,7 +39,7 @@ module RuboCop
             next if allowed_omission?(nested)
 
             message = format(MSG, source: nested.source)
-            add_offense(nested.source_range, message: message) do |corrector|
+            add_offense(nested, message: message) do |corrector|
               autocorrect(corrector, nested)
             end
           end

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

@@ -46,7 +46,11 @@ module RuboCop
 
           message = message(node)
           add_offense(node, message: message) do |corrector|
+            next if part_of_ignored_node?(node)
+
             autocorrect(corrector, node)
+
+            ignore_node(node)
           end
         end