rubocop 1.86.2 → 1.88.0

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

@@ -13,12 +13,12 @@ module RuboCop
       #
       # Large projects will over time end up with one or two constant names that
       # are problematic because of a conflict with a library or just internally
-      # using the same name a namespace and a class. To avoid too many unnecessary
-      # offenses, Enable this cop with `Only: [The, Constant, Names, Causing, Issues]`
+      # using the same name for a namespace and a class. To avoid too many unnecessary
+      # offenses, enable this cop with `Only: [The, Constant, Names, Causing, Issues]`
       #
-      # NOTE: `Style/RedundantConstantBase` cop is disabled if this cop is enabled to prevent
-      # conflicting rules. Because it respects user configurations that want to enable
-      # this cop which is disabled by default.
+      # NOTE: `Style/RedundantConstantBase` cop is disabled if this cop is enabled,
+      # to prevent conflicting rules. This is because it respects user configurations
+      # that want to enable this cop which is disabled by default.
       #
       # @example
       #   # By default checks every constant

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

@@ -73,7 +73,6 @@ module RuboCop
       #   require 'my_debugger/start'
       class Debugger < Base
         MSG = 'Remove debugger entry point `%<source>s`.'
-        BLOCK_TYPES = %i[block numblock itblock kwbegin].freeze
 
         def on_send(node)
           return if assumed_usage_context?(node)

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

@@ -14,7 +14,7 @@ module RuboCop
       #       Alternative: 'alternative_value'
       #       DeprecatedVersion: 'deprecated_version'
       #
-      # By default, `NIL`, `TRUE`, `FALSE`, `Net::HTTPServerException, `Random::DEFAULT`,
+      # By default, `NIL`, `TRUE`, `FALSE`, `Net::HTTPServerException`, `Random::DEFAULT`,
       # `Struct::Group`, and `Struct::Passwd` are configured.
       #
       # @example
@@ -49,7 +49,7 @@ module RuboCop
           #        Maybe further investigation of RuboCop AST will lead to an essential solution.
           return unless node.loc
 
-          constant = node.absolute? ? constant_name(node, node.short_name) : node.source
+          constant = node.source.delete_prefix('::')
           return unless (deprecated_constant = deprecated_constants[constant])
 
           alternative = deprecated_constant['Alternative']
@@ -63,12 +63,6 @@ module RuboCop
 
         private
 
-        def constant_name(node, nested_constant_name)
-          return nested_constant_name.to_s unless node.namespace.const_type?
-
-          constant_name(node.namespace, "#{node.namespace.short_name}::#{nested_constant_name}")
-        end
-
         def message(good, bad, deprecated_version)
           deprecated_message = ", deprecated since Ruby #{deprecated_version}" if deprecated_version
 

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

@@ -77,7 +77,7 @@ module RuboCop
           return false unless processed_source.contains_comment?(node.source_range)
 
           line_comment = processed_source.comment_at_line(node.source_range.line)
-          !line_comment || !comment_disables_cop?(line_comment.source)
+          !line_comment || !comment_disables_cop?(line_comment)
         end
 
         def allow_empty_lambdas?
@@ -85,8 +85,8 @@ module RuboCop
         end
 
         def comment_disables_cop?(comment)
-          regexp_pattern = "# rubocop : (disable|todo) ([^,],)* (all|#{cop_name})"
-          Regexp.new(regexp_pattern.gsub(' ', '\s*')).match?(comment)
+          directive = DirectiveComment.new(comment)
+          directive.disabled? && directive.cop_names.include?(cop_name)
         end
       end
     end

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

@@ -43,7 +43,25 @@ module RuboCop
         MSG = 'Do not return from an `ensure` block.'
 
         def on_ensure(node)
-          node.branch&.each_node(:return) { |return_node| add_offense(return_node) }
+          node.branch&.each_node(:return) do |return_node|
+            next if return_from_inner_scope?(return_node, node)
+
+            add_offense(return_node)
+          end
+        end
+
+        private
+
+        # A `return` inside a nested method definition or lambda within the
+        # `ensure` returns from that inner scope, not from the method whose
+        # `ensure` this is, so it is not an offense. A `return` inside a plain
+        # block (or `proc`) does propagate out, so it remains an offense.
+        def return_from_inner_scope?(return_node, ensure_node)
+          return_node.each_ancestor do |ancestor|
+            break if ancestor == ensure_node
+            return true if ancestor.any_def_type? || (ancestor.any_block_type? && ancestor.lambda?)
+          end
+          false
         end
       end
     end

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

@@ -23,7 +23,7 @@ module RuboCop
       # `ERB.new` with non-keyword arguments is deprecated since ERB 2.2.0.
       # Use `:trim_mode` and `:eoutvar` keyword arguments to `ERB.new`.
       # This cop identifies places where `ERB.new(str, trim_mode, eoutvar)` can
-      # be replaced by `ERB.new(str, :trim_mode: trim_mode, eoutvar: eoutvar)`.
+      # be replaced by `ERB.new(str, trim_mode: trim_mode, eoutvar: eoutvar)`.
       #
       # @example
       #   # Target codes supports Ruby 2.6 and higher only
@@ -148,7 +148,9 @@ module RuboCop
           arguments = node.arguments
           overridden_kwargs = kwargs.dup
 
-          overridden_kwargs[0] = "trim_mode: #{arguments[2].source}" if arguments[2]
+          if arguments[2] && !arguments[2].hash_type?
+            overridden_kwargs[0] = "trim_mode: #{arguments[2].source}"
+          end
 
           if arguments[3] && !arguments[3].hash_type?
             overridden_kwargs[1] = "eoutvar: #{arguments[3].source}"

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

@@ -104,6 +104,7 @@ module RuboCop
 
         def literal_safe?(node)
           return false unless node
+          return literal_safe?(node.children.first) if node.begin_type?
 
           (node.numeric_type? && node.value.zero?) || node.nil_type?
         end

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

@@ -61,11 +61,15 @@ module RuboCop
         private
 
         def scheduler_compatible?(io1, io2)
-          return false unless io1&.array_type? && io1.values.size == 1
+          return false unless single_io_array?(io1)
 
           io2&.array_type? ? io2.values.empty? : (io2.nil? || io2.nil_type?)
         end
 
+        def single_io_array?(node)
+          node&.array_type? && node.values.size == 1 && !node.values.first.splat_type?
+        end
+
         def preferred_method(read, write, timeout)
           timeout_argument = timeout.nil? ? '' : "(#{timeout.source})"
 

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

@@ -24,8 +24,25 @@ module RuboCop
         MSG = 'Interpolation in single quoted string detected. ' \
               'Use double quoted strings if you need interpolation.'
 
-        # rubocop:disable Metrics/CyclomaticComplexity
         def on_str(node)
+          check(node)
+        end
+
+        # A multiline single-quoted string is parsed as a `dstr` of `str` segments, so it
+        # is not covered by `on_str`. Inspect single-quoted `dstr`s here; double-quoted
+        # interpolation is also a `dstr`, hence the delimiter check.
+        def on_dstr(node)
+          # A heredoc is also a `dstr`, but its `loc` is a `Parser::Source::Map::Heredoc`
+          # with no `begin`, so bail before touching it.
+          return if heredoc?(node)
+
+          check(node) if node.loc.begin&.source == "'"
+        end
+
+        private
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def check(node)
           return if node.parent&.regexp_type?
           return unless /(?<!\\)#\{.*\}/.match?(node.source)
           return if heredoc?(node)
@@ -36,8 +53,6 @@ module RuboCop
         end
         # rubocop:enable Metrics/CyclomaticComplexity
 
-        private
-
         def autocorrect(corrector, node)
           starting_token, ending_token = if node.source.include?('"')
                                            ['%{', '}']

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

@@ -42,7 +42,7 @@ module RuboCop
           end
 
           add_offense(node) do |corrector|
-            corrector.replace(node, node.first_argument.source.delete('&'))
+            corrector.replace(node, node.first_argument.source.delete_prefix('&'))
           end
         end
       end

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

@@ -56,7 +56,17 @@ module RuboCop
         def traverse_node(node, &block)
           yield node if node.equals_asgn?
 
-          node.each_child_node { |child| traverse_node(child, &block) }
+          node.each_child_node do |child|
+            next if scope_body?(node, child)
+
+            traverse_node(child, &block)
+          end
+        end
+
+        # An assignment inside a block or method body within the condition belongs to
+        # that inner scope rather than the condition itself, so it is not inspected.
+        def scope_body?(node, child)
+          node.type?(:any_block, :any_def) && child == node.body
         end
 
         def all_literals?(node)

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

@@ -119,11 +119,13 @@ module RuboCop
         end
 
         def autocorrected_value_for_string(node)
-          if node.source.start_with?("'", '%q')
-            node.children.last.inspect[1..-2]
-          else
-            node.children.last
-          end
+          return node.source.delete_prefix('"').delete_suffix('"') unless node.value.valid_encoding?
+
+          escape_string_content(node.children.last)
+        end
+
+        def escape_string_content(string)
+          string.gsub(/[\\"]|#(?=[@{$])/, '\\\\\&')
         end
 
         def autocorrected_value_for_symbol(node)
@@ -134,12 +136,7 @@ module RuboCop
         end
 
         def autocorrected_value_in_hash_for_symbol(node)
-          # TODO: We need to detect symbol unacceptable names more correctly
-          if / |"|'/.match?(node.value.to_s)
-            ":\\\"#{node.value.to_s.gsub('"') { '\\\\\"' }}\\\""
-          else
-            ":#{node.value}"
-          end
+          escape_string_content(node.value.inspect)
         end
 
         def autocorrected_value_for_array(node)

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

@@ -6,10 +6,10 @@ module RuboCop
     module Lint
       # Checks that there is an `# rubocop:enable ...` statement
       # after a `# rubocop:disable ...` statement. This will prevent leaving
-      # cop disables on wide ranges of code, that latter contributors to
+      # cop disables on wide ranges of code, that later contributors to
       # a file wouldn't be aware of.
       #
-      # You can set `MaximumRangeSize` to define the maximum number of
+      # You can set `MaxRangeSize` to define the maximum number of
       # consecutive lines a cop can be disabled for.
       #
       # - `.inf` any size (default)
@@ -23,7 +23,7 @@ module RuboCop
       # # rubocop:enable SomeCop
       # ----
       #
-      # @example MaximumRangeSize: .inf (default)
+      # @example MaxRangeSize: .inf (default)
       #
       #   # good
       #   # rubocop:disable Layout/SpaceAroundOperators
@@ -37,7 +37,7 @@ module RuboCop
       #   x= 0
       #   # EOF
       #
-      # @example MaximumRangeSize: 2
+      # @example MaxRangeSize: 2
       #
       #   # good
       #   # rubocop:disable Layout/SpaceAroundOperators
@@ -94,7 +94,7 @@ module RuboCop
         end
 
         def max_range
-          @max_range ||= cop_config['MaximumRangeSize']
+          @max_range ||= cop_config['MaxRangeSize']
         end
 
         def message(cop, comment, type = 'cop')

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

@@ -4,8 +4,8 @@ module RuboCop
   module Cop
     module Lint
       # In math and Python, we can use `x < y < z` style comparison to compare
-      # multiple value. However, we can't use the comparison in Ruby. However,
-      # the comparison is not syntax error. This cop checks the bad usage of
+      # multiple values. However, we can't use the comparison in Ruby. However,
+      # the comparison is not a syntax error. This cop checks the bad usage of
       # comparison operators.
       #
       # @example

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

@@ -41,6 +41,8 @@ module RuboCop
         def on_lvasgn(node)
           node.each_node(:kwbegin) do |kwbegin_node|
             kwbegin_node.each_node(:return) do |return_node|
+              next if return_from_inner_scope?(return_node, kwbegin_node)
+
               add_offense(return_node)
             end
           end
@@ -51,6 +53,20 @@ module RuboCop
         alias on_casgn on_lvasgn
         alias on_or_asgn on_lvasgn
         alias on_op_asgn on_lvasgn
+
+        private
+
+        # A `return` inside a nested method definition or lambda within the
+        # `begin..end` returns from that inner scope rather than the assignment
+        # context, so it is not an offense. A `return` inside a plain block (or
+        # `proc`) does propagate out, so it remains an offense.
+        def return_from_inner_scope?(return_node, kwbegin_node)
+          return_node.each_ancestor do |ancestor|
+            break if ancestor == kwbegin_node
+            return true if ancestor.any_def_type? || (ancestor.any_block_type? && ancestor.lambda?)
+          end
+          false
+        end
       end
     end
   end

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

@@ -12,7 +12,7 @@ module RuboCop
       # always sort the list.
       #
       # `Dir.glob` and `Dir[]` sort globbed results by default in Ruby 3.0.
-      # So all bad cases are acceptable when Ruby 3.0 or higher are used.
+      # So all bad cases are acceptable when Ruby 3.0 or higher is used.
       #
       # NOTE: This cop will be deprecated and removed when supporting only Ruby 3.0 and higher.
       #

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

@@ -74,7 +74,7 @@ module RuboCop
         end
 
         # @!method chained_send?(node)
-        def_node_matcher :chained_send?, '(send !nil? ...)'
+        def_node_matcher :chained_send?, '(call !nil? ...)'
 
         # @!method define_method?(node)
         def_node_matcher :define_method?, <<~PATTERN

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,11 +156,20 @@ 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.call_type? &&
             (conversion_method?(receiver.method_name) ||
@@ -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,7 +63,7 @@ module RuboCop
         end
 
         def spaces_before_left_parenthesis(node)
-          return 0 if node.parenthesized?
+          return 0 if node.parenthesized? || !node.first_argument.source.start_with?('(')
 
           node.first_argument.source_range.begin_pos - node.loc.selector.end_pos
         end

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

@@ -6,8 +6,8 @@ module RuboCop
       # 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
       #
@@ -74,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)

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

@@ -183,7 +183,7 @@ module RuboCop
         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))
@@ -191,7 +191,6 @@ module RuboCop
           }
         PATTERN
 
-        # rubocop:disable Metrics/AbcSize
         def on_csend(node)
           range = node.loc.dot
 
@@ -204,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_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)
@@ -230,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)