rubocop 1.84.2 → 1.88.0

data/lib/rubocop/cop/lint/number_conversion.rb

@@ -3,9 +3,9 @@
 module RuboCop
   module Cop
     module Lint
-      # Warns the usage of unsafe number conversions. Unsafe
-      # number conversion can cause unexpected error if auto type conversion
-      # fails. Cop prefer parsing with number class instead.
+      # Warns against the usage of unsafe number conversions. Unsafe
+      # number conversion can cause an unexpected error if auto type conversion
+      # fails. The cop prefers parsing with a number class instead.
       #
       # Conversion with `Integer`, `Float`, etc. will raise an `ArgumentError`
       # if given input that is not numeric (eg. an empty string), whereas
@@ -14,10 +14,10 @@ module RuboCop
       # always correct to raise if a value is not numeric.
       #
       # NOTE: Some values cannot be converted properly using one of the `Kernel`
-      # method (for instance, `Time` and `DateTime` values are allowed by this
+      # methods (for instance, `Time` and `DateTime` values are allowed by this
       # cop by default). Similarly, Rails' duration methods do not work well
       # with `Integer()` and can be allowed with `AllowedMethods`. By default,
-      # there are no methods to allowed.
+      # there are no allowed methods.
       #
       # @safety
       #   Autocorrection is unsafe because it is not guaranteed that the
@@ -66,7 +66,7 @@ module RuboCop
       #   # good
       #   10.minutes.to_i
       #
-      # @example IgnoredClasses: [Time, DateTime] (default)
+      # @example AllowedClasses: [Time, DateTime] (default)
       #
       #   # good
       #   Time.now.to_datetime.to_i
@@ -117,11 +117,11 @@ module RuboCop
 
             message = format(
               MSG,
-              current: "#{receiver.source}.#{to_method}",
+              current: current_method(node, receiver, to_method),
               corrected_method: correct_method(node, receiver)
             )
             add_offense(node, message: message) do |corrector|
-              next if part_of_ignored_node?(node)
+              next if safe_navigation?(node) || part_of_ignored_node?(node)
 
               corrector.replace(node, correct_method(node, node.receiver))
 
@@ -156,13 +156,22 @@ module RuboCop
           "{ |i| #{body} }"
         end
 
+        def current_method(node, receiver, to_method)
+          operator = node.csend_type? ? '&.' : '.'
+          "#{receiver.source}#{operator}#{to_method}"
+        end
+
         def remove_parentheses(corrector, node)
           corrector.replace(node.loc.begin, ' ')
           corrector.remove(node.loc.end)
         end
 
+        def safe_navigation?(node)
+          node.csend_type? || node.each_descendant(:csend).any?
+        end
+
         def allow_receiver?(receiver)
-          if receiver.numeric_type? || (receiver.send_type? &&
+          if receiver.numeric_type? || (receiver.call_type? &&
             (conversion_method?(receiver.method_name) ||
             allowed_method_name?(receiver.method_name)))
             true
@@ -188,7 +197,7 @@ module RuboCop
         end
 
         def ignored_classes
-          cop_config.fetch('IgnoredClasses', [])
+          cop_config.fetch('AllowedClasses', [])
         end
 
         def ignored_class?(name)

data/lib/rubocop/cop/lint/numbered_parameter_assignment.rb

@@ -16,7 +16,7 @@ module RuboCop
       #   ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-darwin19]
       #   -e:1: _1 is reserved for numbered parameter
       #
-      # NOTE: The parametered parameters are from `_1` to `_9`. This cop checks `_0`, and over `_10`
+      # NOTE: The numbered parameters are from `_1` to `_9`. This cop checks `_0`, and over `_10`
       # as well to prevent confusion.
       #
       # @example

data/lib/rubocop/cop/lint/numeric_operation_with_constant_result.rb

@@ -58,6 +58,9 @@ module RuboCop
                          '(op-asgn (lvasgn $_lhs) $_operation ({int lvar} $_rhs))'
 
         def on_send(node)
+          # Safe navigation short-circuits to `nil` when the receiver is `nil`, so the
+          # result is not constant and replacing it with `0`/`1` would change behavior.
+          return if node.csend_type?
           return unless (lhs, operation, rhs = operation_with_constant_result?(node))
           return unless (result = constant_result?(lhs, operation, rhs))
 

data/lib/rubocop/cop/lint/ordered_magic_comments.rb

@@ -38,23 +38,23 @@ module RuboCop
         def on_new_investigation
           return if processed_source.buffer.source.empty?
 
-          encoding_line, frozen_string_literal_line = magic_comment_lines
+          encoding_line, other_magic_comment_line = magic_comment_lines
 
-          return unless encoding_line && frozen_string_literal_line
-          return if encoding_line < frozen_string_literal_line
+          return unless encoding_line && other_magic_comment_line
+          return if encoding_line < other_magic_comment_line
 
           range = processed_source.buffer.line_range(encoding_line + 1)
 
           add_offense(range) do |corrector|
-            autocorrect(corrector, encoding_line, frozen_string_literal_line)
+            autocorrect(corrector, encoding_line, other_magic_comment_line)
           end
         end
 
         private
 
-        def autocorrect(corrector, encoding_line, frozen_string_literal_line)
+        def autocorrect(corrector, encoding_line, other_magic_comment_line)
           range1 = processed_source.buffer.line_range(encoding_line + 1)
-          range2 = processed_source.buffer.line_range(frozen_string_literal_line + 1)
+          range2 = processed_source.buffer.line_range(other_magic_comment_line + 1)
 
           corrector.replace(range1, range2.source)
           corrector.replace(range2, range1.source)
@@ -66,7 +66,7 @@ module RuboCop
           leading_magic_comments.each.with_index do |comment, index|
             if comment.encoding_specified?
               lines[0] = index
-            elsif comment.frozen_string_literal_specified?
+            elsif comment.valid?
               lines[1] = index
             end
 

data/lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb

@@ -63,19 +63,9 @@ module RuboCop
         end
 
         def spaces_before_left_parenthesis(node)
-          receiver = node.receiver
-          receiver_length = if receiver
-                              receiver.source.length
-                            else
-                              0
-                            end
-          without_receiver = node.source[receiver_length..]
-
-          # Escape question mark if any.
-          method_regexp = Regexp.escape(node.method_name)
-
-          match = without_receiver.match(/^\s*&?\.?\s*#{method_regexp}(\s+)\(/)
-          match ? match.captures[0].length : 0
+          return 0 if node.parenthesized? || !node.first_argument.source.start_with?('(')
+
+          node.first_argument.source_range.begin_pos - node.loc.selector.end_pos
         end
 
         def space_range(expr, space_length)

data/lib/rubocop/cop/lint/raise_exception.rb

@@ -95,7 +95,7 @@ module RuboCop
           if parent.module_type?
             namespace = parent.identifier.source
 
-            return allow_implicit_namespaces.include?(namespace)
+            return true if allow_implicit_namespaces.include?(namespace)
           end
 
           implicit_namespace?(parent)

data/lib/rubocop/cop/lint/rand_one.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Lint
       # Checks for `rand(1)` calls.
-      # Such calls always return `0`.
+      # Such calls always return `0`, and so do `rand(-1)`, `rand(1.0)`, and `rand(-1.0)`.
       #
       # @example
       #

data/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb

@@ -283,7 +283,10 @@ module RuboCop
         end
 
         def matching_range(haystack, needle)
-          offset = haystack.source.index(needle)
+          # Match the cop name as a whole token so a shorter name is not found inside a
+          # longer one that shares its prefix (e.g. `Lint/AmbiguousOperator` in
+          # `Lint/AmbiguousOperatorPrecedence`).
+          offset = haystack.source.index(/#{Regexp.escape(needle)}(?!\w)/)
           return unless offset
 
           offset += haystack.begin_pos

data/lib/rubocop/cop/lint/redundant_cop_enable_directive.rb

@@ -1,19 +1,13 @@
 # frozen_string_literal: true
 
-# The Lint/RedundantCopEnableDirective and Lint/RedundantCopDisableDirective
-# cops need to be disabled so as to be able to provide a (bad) example of an
-# unneeded enable.
-
-# rubocop:disable Lint/RedundantCopEnableDirective
-# rubocop:disable Lint/RedundantCopDisableDirective
 module RuboCop
   module Cop
     module Lint
       # Detects instances of rubocop:enable comments that can be
       # removed.
       #
-      # When comment enables all cops at once `rubocop:enable all`
-      # that cop checks whether any cop was actually enabled.
+      # When a comment enables all cops at once `rubocop:enable all`
+      # the cop checks whether any cop was actually enabled.
       #
       # @example
       #
@@ -80,7 +74,10 @@ module RuboCop
         end
 
         def cop_name_indention(comment, name)
-          comment.text.index(name)
+          # Match the cop name as a whole token so a shorter name is not found inside a
+          # longer one that shares its prefix (e.g. `Layout/EmptyLines` in
+          # `Layout/EmptyLinesAfterModuleInclusion`).
+          comment.text.index(/#{Regexp.escape(name)}(?!\w)/)
         end
 
         def range_with_comma(comment, name)
@@ -130,6 +127,3 @@ module RuboCop
     end
   end
 end
-
-# rubocop:enable Lint/RedundantCopDisableDirective
-# rubocop:enable Lint/RedundantCopEnableDirective

data/lib/rubocop/cop/lint/redundant_dir_glob_sort.rb

@@ -38,10 +38,10 @@ module RuboCop
         GLOB_METHODS = %i[glob []].freeze
 
         def on_send(node)
-          return unless (receiver = node.receiver)
-          return unless receiver.receiver&.const_type? && receiver.receiver.short_name == :Dir
-          return unless GLOB_METHODS.include?(receiver.method_name)
-          return if multiple_argument?(receiver)
+          return unless dir_glob?(node.receiver)
+          # `sort` with a comparator block or block-pass changes the order, so it is
+          # not redundant with the default sorting performed by `Dir.glob`/`Dir[]`.
+          return if sort_with_comparator?(node) || multiple_argument?(node.receiver)
 
           selector = node.loc.selector
 
@@ -53,9 +53,20 @@ module RuboCop
 
         private
 
+        def dir_glob?(receiver)
+          return false unless receiver&.receiver&.const_type?
+          return false unless receiver.receiver.short_name == :Dir
+
+          GLOB_METHODS.include?(receiver.method_name)
+        end
+
         def multiple_argument?(glob_method)
           glob_method.arguments.count >= 2 || glob_method.first_argument&.splat_type?
         end
+
+        def sort_with_comparator?(node)
+          node.parent&.any_block_type? || node.last_argument&.block_pass_type?
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/redundant_safe_navigation.rb

@@ -62,6 +62,22 @@ module RuboCop
       #   do_something if attrs.respond_to?(:[])
       #
       #   # bad
+      #   foo&.bar ? foo&.bar.baz : qux
+      #
+      #   # good
+      #   foo&.bar ? foo.bar.baz : qux
+      #
+      #   # bad
+      #   if foo&.bar
+      #     foo&.bar.baz
+      #   end
+      #
+      #   # good
+      #   if foo&.bar
+      #     foo.bar.baz
+      #   end
+      #
+      #   # bad
       #   while node&.is_a?(BeginNode)
       #     node = node.parent
       #   end
@@ -71,8 +87,9 @@ module RuboCop
       #     node = node.parent
       #   end
       #
-      #   # good - without `&.` this will always return `true`
+      #   # good - without `&.` this changes the return value for `nil`
       #   foo&.respond_to?(:to_a)
+      #   foo&.respond_to?(:class)
       #
       #   # bad - for `nil`s conversion methods return default values for the type
       #   foo&.to_h || {}
@@ -151,22 +168,22 @@ module RuboCop
         MSG_NON_NIL = 'Redundant safe navigation on non-nil receiver (detected by analyzing ' \
                       'previous code/method invocations).'
 
-        NIL_SPECIFIC_METHODS = (nil.methods - Object.new.methods).to_set.freeze
+        NIL_METHODS = nil.methods.to_set.freeze
 
         SNAKE_CASE = /\A[[:digit:][:upper:]_]+\z/.freeze
 
         GUARANTEED_INSTANCE_METHODS = %i[to_s to_i to_f to_a to_h].freeze
 
-        # @!method respond_to_nil_specific_method?(node)
-        def_node_matcher :respond_to_nil_specific_method?, <<~PATTERN
-          (csend _ :respond_to? (sym %NIL_SPECIFIC_METHODS))
+        # @!method respond_to_nil_method?(node)
+        def_node_matcher :respond_to_nil_method?, <<~PATTERN
+          (csend _ :respond_to? (sym %NIL_METHODS))
         PATTERN
 
         # @!method conversion_with_default?(node)
         def_node_matcher :conversion_with_default?, <<~PATTERN
           {
             (or $(csend _ :to_h) (hash))
-            (or (block $(csend _ :to_h) ...) (hash))
+            (or (any_block $(csend _ :to_h) ...) (hash))
             (or $(csend _ :to_a) (array))
             (or $(csend _ :to_i) (int 0))
             (or $(csend _ :to_f) (float 0.0))
@@ -174,7 +191,6 @@ module RuboCop
           }
         PATTERN
 
-        # rubocop:disable Metrics/AbcSize
         def on_csend(node)
           range = node.loc.dot
 
@@ -187,14 +203,10 @@ module RuboCop
             end
           end
 
-          unless assume_receiver_instance_exists?(node.receiver)
-            return if !guaranteed_instance?(node.receiver) && !check?(node)
-            return if respond_to_nil_specific_method?(node)
-          end
+          return if guarded_by_nil_receiver?(node)
 
           add_offense(range) { |corrector| corrector.replace(range, '.') }
         end
-        # rubocop:enable Metrics/AbcSize
 
         # rubocop:disable Metrics/AbcSize
         def on_or(node)
@@ -213,6 +225,18 @@ module RuboCop
 
         private
 
+        # Returns true when the `&.` is meaningful because the receiver may actually be nil.
+        def guarded_by_nil_receiver?(node)
+          return false if assume_receiver_instance_exists?(node.receiver)
+
+          guaranteed_instance = guaranteed_instance?(node.receiver)
+          return true if !guaranteed_instance && !check?(node)
+
+          # `nil.respond_to?(<nil method>)` is `true`, so `&.` is meaningful when the receiver
+          # may be nil. A guaranteed instance can never be nil, so `&.` is still redundant there.
+          respond_to_nil_method?(node) && !guaranteed_instance
+        end
+
         def assume_receiver_instance_exists?(receiver)
           return true if receiver.const_type? && !receiver.short_name.match?(SNAKE_CASE)
 

data/lib/rubocop/cop/lint/redundant_splat_expansion.rb

@@ -122,6 +122,10 @@ module RuboCop
 
               grandparent = node.parent.parent
               return if grandparent && !ASSIGNMENT_TYPES.include?(grandparent.type)
+            # An empty array/percent literal (`*[]`, `*%w()`, ...) expands to nothing, so
+            # removing the splat would produce invalid or semantically different code.
+            elsif expanded_item.array_type? && expanded_item.children.empty?
+              return
             end
 
             yield

data/lib/rubocop/cop/lint/redundant_type_conversion.rb

@@ -17,14 +17,15 @@ module RuboCop
       #   or with `String.new` or `String()`.
       # * `to_sym` when called on a symbol literal or interpolated symbol.
       # * `to_i` when called on an integer literal or with `Integer()`.
-      # * `to_f` when called on a float literal of with `Float()`.
+      # * `to_f` when called on a float literal or with `Float()`.
+      # * `to_d` when called with `BigDecimal()`.
       # * `to_r` when called on a rational literal or with `Rational()`.
-      # * `to_c` when called on a complex literal of with `Complex()`.
+      # * `to_c` when called on a complex literal or with `Complex()`.
       # * `to_a` when called on an array literal, or with `Array.new`, `Array()` or `Array[]`.
       # * `to_h` when called on a hash literal, or with `Hash.new`, `Hash()` or `Hash[]`.
       # * `to_set` when called on `Set.new` or `Set[]`.
       #
-      # In all cases, chaining one same `to_*` conversion methods listed above is redundant.
+      # In all cases, chaining one of the same `to_*` conversion methods listed above is redundant.
       #
       # The cop can also register an offense for chaining conversion methods on methods that are
       # expected to return a specific type regardless of receiver (eg. `foo.inspect.to_s` and
@@ -63,6 +64,12 @@ module RuboCop
       #   # in this case, `Integer()` could return `nil`
       #   Integer(var, exception: false).to_i
       #
+      #   # bad
+      #   BigDecimal(var).to_d
+      #
+      #   # good
+      #   BigDecimal(var)
+      #
       #   # bad - chaining the same conversion
       #   foo.to_s.to_s
       #

data/lib/rubocop/cop/lint/redundant_with_index.rb

@@ -62,7 +62,7 @@ module RuboCop
           {
             (block
               $(call _ {:each_with_index :with_index} ...)
-              (args (arg _)) ...)
+              {(args (arg _)) (args)} ...)
             (numblock
               $(call _ {:each_with_index :with_index} ...) 1 ...)
             (itblock

data/lib/rubocop/cop/lint/redundant_with_object.rb

@@ -5,6 +5,11 @@ module RuboCop
     module Lint
       # Checks for redundant `with_object`.
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because the return value changes:
+      #   `each_with_object` returns the memo object, while the corrected `each` returns
+      #   the receiver. This matters when the result of the expression is used.
+      #
       # @example
       #   # bad
       #   ary.each_with_object([]) do |v|

data/lib/rubocop/cop/lint/refinement_import_methods.rb

@@ -32,9 +32,12 @@ module RuboCop
       #   end
       #
       class RefinementImportMethods < Base
+        extend AutoCorrector
         extend TargetRubyVersion
 
         MSG = 'Use `import_methods` instead of `%<current>s` because it is deprecated in Ruby 3.1.'
+        MSG_REMOVED = 'Use `import_methods` instead of `%<current>s` ' \
+                      'because it was removed in Ruby 3.2.'
         RESTRICT_ON_SEND = %i[include prepend].freeze
 
         minimum_target_ruby_version 3.1
@@ -44,7 +47,11 @@ module RuboCop
           return unless (parent = node.parent)
           return unless parent.block_type? && parent.method?(:refine)
 
-          add_offense(node.loc.selector, message: format(MSG, current: node.method_name))
+          template = target_ruby_version >= 3.2 ? MSG_REMOVED : MSG
+          message = format(template, current: node.method_name)
+          add_offense(node.loc.selector, message: message) do |corrector|
+            corrector.replace(node.loc.selector, 'import_methods')
+          end
         end
       end
     end

data/lib/rubocop/cop/lint/regexp_as_condition.rb

@@ -26,7 +26,15 @@ module RuboCop
           return if node.ancestors.none?(&:conditional?)
           return if part_of_ignored_node?(node)
 
-          add_offense(node) { |corrector| corrector.replace(node, "#{node.source} =~ $_") }
+          add_offense(node) do |corrector|
+            # `!` binds tighter than `=~`, so `!/foo/ =~ $_` would parse as
+            # `(!/foo/) =~ $_`. Wrap the match in parentheses to preserve the meaning.
+            if node.parent&.send_type? && node.parent.method?(:!)
+              corrector.replace(node.parent, "!(#{node.source} =~ $_)")
+            else
+              corrector.replace(node, "#{node.source} =~ $_")
+            end
+          end
 
           ignore_node(node)
         end

data/lib/rubocop/cop/lint/require_parentheses.rb

@@ -3,10 +3,13 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for expressions where there is a call to a predicate
-      # method with at least one argument, where no parentheses are used around
-      # the parameter list, and a boolean operator, && or ||, is used in the
-      # last argument.
+      # Checks for method calls with at least one argument where no parentheses
+      # are used around the parameter list, and the call could be misread as an
+      # operand of a boolean operator (`&&` or `||`). Two forms are flagged:
+      #
+      # * a predicate method whose last argument is a `&&`/`||` expression, and
+      # * any method whose first argument is a ternary expression with a
+      #   `&&`/`||` condition.
       #
       # The idea behind warning for these constructs is that the user might
       # be under the impression that the return value from the method call is
@@ -23,6 +26,12 @@ module RuboCop
       #   if day.is?(:tuesday) && month == :jan
       #     # ...
       #   end
+      #
+      #   # bad
+      #   foo a && b ? c : d
+      #
+      #   # good
+      #   foo(a && b ? c : d)
       class RequireParentheses < Base
         include RangeHelp
 

data/lib/rubocop/cop/lint/require_range_parentheses.rb

@@ -38,7 +38,8 @@ module RuboCop
       #   42)
       #
       class RequireRangeParentheses < Base
-        MSG = 'Wrap the endless range literal `%<range>s` to avoid precedence ambiguity.'
+        MSG = 'Wrap the range literal `%<range>s` in parentheses ' \
+              'to avoid confusion with an endless range.'
 
         def on_irange(node)
           return if node.parent&.begin_type?

data/lib/rubocop/cop/lint/require_relative_self_path.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for uses a file requiring itself with `require_relative`.
+      # Checks for a file requiring itself with `require_relative`.
       #
       # @example
       #
@@ -38,11 +38,13 @@ module RuboCop
         private
 
         def same_file?(file_path, required_feature)
-          file_path == required_feature || remove_ext(file_path) == required_feature
-        end
+          return false unless File.extname(file_path) == '.rb'
 
-        def remove_ext(file_path)
-          File.basename(file_path, File.extname(file_path))
+          # `require_relative` is resolved relative to the current file's directory, so a
+          # bare `foo`/`foo.rb` (no path separator) requires the current file itself. Compare
+          # against the basename so this works whether `file_path` is relative or absolute.
+          basename = File.basename(file_path, '.rb')
+          required_feature == basename || required_feature == "#{basename}.rb"
         end
       end
     end

data/lib/rubocop/cop/lint/rescue_type.rb

@@ -39,7 +39,7 @@ module RuboCop
 
         MSG = 'Rescuing from `%<invalid_exceptions>s` will raise a ' \
               '`TypeError` instead of catching the actual exception.'
-        INVALID_TYPES = %i[array dstr float hash nil int str sym].freeze
+        INVALID_TYPES = %i[array complex dstr false float hash nil int rational str sym true].freeze
 
         def on_resbody(node)
           invalid_exceptions = invalid_exceptions(node.exceptions)

data/lib/rubocop/cop/lint/safe_navigation_chain.rb

@@ -34,23 +34,29 @@ module RuboCop
           {
             (send $(csend ...) $_ ...)
             (send $(any_block (csend ...) ...) $_ ...)
+            (send $(begin (csend ...)) $_ ...)
           }
         PATTERN
 
+        # rubocop:disable Metrics/AbcSize
         def on_send(node)
           return unless require_safe_navigation?(node)
 
           bad_method?(node) do |safe_nav, method|
             return if nil_methods.include?(method) || PLUS_MINUS_METHODS.include?(node.method_name)
+            return if ternary_safe_navigation?(node, safe_nav)
 
             begin_range = node.loc.dot || safe_nav.source_range.end
             location = begin_range.join(node.source_range.end)
 
             add_offense(location) do |corrector|
+              next if ternary_else_branch?(node, safe_nav)
+
               autocorrect(corrector, offense_range: location, send_node: node)
             end
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         private
 
@@ -61,6 +67,18 @@ module RuboCop
           parent.rhs != node || parent.lhs.receiver != parent.rhs.receiver
         end
 
+        def ternary_safe_navigation?(node, safe_nav)
+          return false unless (parent = node.parent)
+
+          parent.if_type? && node.equal?(parent.if_branch) && parent.condition == safe_nav
+        end
+
+        def ternary_else_branch?(node, safe_nav)
+          return false unless (parent = node.parent)
+
+          parent.if_type? && node.equal?(parent.else_branch) && parent.condition == safe_nav
+        end
+
         # @param [Parser::Source::Range] offense_range
         # @param [RuboCop::AST::SendNode] send_node
         # @return [String]

data/lib/rubocop/cop/lint/safe_navigation_consistency.rb

@@ -3,10 +3,16 @@
 module RuboCop
   module Cop
     module Lint
-      # Check to make sure that if safe navigation is used in an `&&` or `||` condition,
+      # Checks that if safe navigation is used in an `&&` or `||` condition,
       # consistent and appropriate safe navigation, without excess or deficiency,
       # is used for all method calls on the same object.
       #
+      # @safety
+      #   Autocorrection is unsafe because if the receiver is not a local variable
+      #   but a method call, it may not be idempotent. For example, replacing
+      #   `foo&.bar` with `foo.bar` could raise `NoMethodError` if `foo` returns
+      #   `nil` on a subsequent call.
+      #
       # @example
       #   # bad
       #   foo&.bar && foo&.baz

data/lib/rubocop/cop/lint/safe_navigation_with_empty.rb

@@ -26,7 +26,7 @@ module RuboCop
 
         # @!method safe_navigation_empty_in_conditional?(node)
         def_node_matcher :safe_navigation_empty_in_conditional?, <<~PATTERN
-          (if (csend (send ...) :empty?) ...)
+          (if (csend !csend :empty?) ...)
         PATTERN
 
         def on_if(node)