rubocop 1.81.7 → 1.82.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8acfafa4ed4b94c367e6ef95c84d2d02f01222a1e8a813790948977476f34456
-  data.tar.gz: 0d2ad56c4a81da58046a098351606bfb8314f09f9e5f946ad1dd825aa70fe0f7
+  metadata.gz: 395ade8767ec51e33acbc9c14c0b11300df6100806f9e2c9bd23241f22f7f206
+  data.tar.gz: ed5bf8c5e1f3f7adc724fd900ec7d8b0cda4c91892276349177e7eb7c06d87a7
 SHA512:
-  metadata.gz: ae4edea22ca7511df39ec99591df3d537bfd3fa8974d5bb461d2b1c674b48f15296f22c81b1cd9329719a68b0d3f8d36442eaa5742cbf8e0974c6e3e2e56e29c
-  data.tar.gz: ffce467cec50d2ed0ef7b312a15dd17e9b7fd1622b70528d12f0cfe16056ae3b5111f2d360b4e855ea5811befd092a306ff56ad091b89a6050f3354f3db205a4
+  metadata.gz: 53fd7c4276518804677378c9c958c96c5512d9b3cfa89c0a5a8597a676a54efb18077a45e30d47f15c15a08448c9ad8c6b5c931cc0e244bb34abef88b5d30238
+  data.tar.gz: e7298eed68c7cb9d9d7c294bc7ca031b538ea1a3205bb34ab854ef76bf1230a4e664c178088f1489030f51dd1ad4f9e1bfd1dc4397a5a240904b27bc55965428

data/README.md

@@ -51,7 +51,7 @@ To prevent an unwanted RuboCop update you might want to use a conservative versi
 in your `Gemfile`:
 
 ```rb
-gem 'rubocop', '~> 1.81', require: false
+gem 'rubocop', '~> 1.82', require: false
 ```
 
 See [our versioning policy](https://docs.rubocop.org/rubocop/versioning.html) for further details.

data/config/default.yml

@@ -1102,7 +1102,7 @@ Layout/LineLength:
   StyleGuide: '#max-line-length'
   Enabled: true
   VersionAdded: '0.25'
-  VersionChanged: '1.69'
+  VersionChanged: '1.82'
   Max: 120
   AllowHeredoc: true
   # To make it possible to copy or click on URIs in the code, we allow lines
@@ -1112,9 +1112,12 @@ Layout/LineLength:
   URISchemes:
     - http
     - https
-  # The IgnoreCopDirectives option causes the LineLength rule to ignore cop
+  # The AllowRBSInlineAnnotation option makes LineLength allow RBS::Inline annotations
+  # such as `#: (?date: Date) -> Foo` when calculating line length.
+  AllowRBSInlineAnnotation: false
+  # The AllowCopDirectives option causes the LineLength rule to ignore cop
   # directives like '# rubocop: enable ...' when calculating a line's length.
-  IgnoreCopDirectives: true
+  AllowCopDirectives: true
   # The AllowedPatterns option is a list of !ruby/regexp and/or string
   # elements. Strings will be converted to Regexp objects. A line that matches
   # any regular expression listed in this option will be ignored by LineLength.
@@ -2669,7 +2672,10 @@ Lint/UselessNumericOperation:
 Lint/UselessOr:
   Description: 'Checks for useless OR expressions.'
   Enabled: pending
+  SafeAutoCorrect: false
+  AutoCorrect: contextual
   VersionAdded: '1.76'
+  VersionChanged: '1.82'
 
 Lint/UselessRescue:
   Description: 'Checks for useless `rescue`s.'
@@ -3281,7 +3287,7 @@ Style/Alias:
 
 Style/AmbiguousEndlessMethodDefinition:
   Description: 'Checks for endless methods inside operators of lower precedence.'
-  StyleGuide: '#ambiguous-endless-method-defintions'
+  StyleGuide: '#ambiguous-endless-method-definitions'
   Enabled: pending
   VersionAdded: '1.68'
 
@@ -3525,9 +3531,11 @@ Style/BlockDelimiters:
   BracesRequiredMethods: []
 
 Style/CaseEquality:
-  Description: 'Avoid explicit use of the case equality operator(===).'
+  Description: 'Avoid explicit use of the case equality operator (`===`).'
   StyleGuide: '#no-case-equality'
   Enabled: true
+  References:
+    - 'https://docs.rubocop.org/rubocop-performance/cops_performance.html#performanceregexpmatch'
   VersionAdded: '0.9'
   VersionChanged: '0.89'
   # If `AllowOnConstant` option is enabled, the cop will ignore violations when the receiver of
@@ -4625,6 +4633,7 @@ Style/MethodCallWithArgsParentheses:
   AllowedMethods: []
   AllowedPatterns: []
   IncludedMacros: []
+  IncludedMacroPatterns: []
   AllowParenthesesInMultilineCall: false
   AllowParenthesesInChaining: false
   AllowParenthesesInCamelCaseMethod: false
@@ -4735,6 +4744,11 @@ Style/ModuleFunction:
   Autocorrect: false
   SafeAutoCorrect: false
 
+Style/ModuleMemberExistenceCheck:
+  Description: 'Checks for usage of `Module` methods returning arrays that can be replaced with equivalent predicates.'
+  Enabled: pending
+  VersionAdded: '1.82'
+
 Style/MultilineBlockChain:
   Description: 'Avoid multi-line chains of blocks.'
   StyleGuide: '#single-line-blocks'
@@ -5222,6 +5236,8 @@ Style/RedundantArgument:
     exit: true
     # Kernel.#exit!
     exit!: false
+    # String#to_i
+    to_i: 10
     # String#split
     split: ' '
     # String#chomp

data/config/obsoletion.yml

@@ -145,6 +145,10 @@ changed_parameters:
   - cops: Layout/CaseIndentation
     parameters: IndentWhenRelativeTo
     alternative: EnforcedStyle
+  - cops: Layout/LineLength
+    parameters: IgnoreCopDirectives
+    alternative: AllowCopDirectives
+    severity: warning
   - cops:
       - Lint/BlockAlignment
       - Layout/BlockAlignment

data/lib/rubocop/cli.rb

@@ -66,7 +66,7 @@ module RuboCop
       STATUS_INTERRUPTED
     rescue Finished
       STATUS_SUCCESS
-    rescue OptionParser::InvalidOption => e
+    rescue OptionParser::ParseError => e
       warn e.message
       warn 'For usage information, use --help'
       STATUS_ERROR
@@ -183,6 +183,7 @@ module RuboCop
       ConfigLoader.enable_pending_cops = @options[:enable_pending_cops]
       ConfigLoader.ignore_parent_exclusion = @options[:ignore_parent_exclusion]
       ConfigLoader.ignore_unrecognized_cops = @options[:ignore_unrecognized_cops]
+      ConfigLoader.cache_root = ResultCache.cache_root(@config_store, @options[:cache_root])
     end
 
     def set_options_to_pending_cops_reporter

data/lib/rubocop/comment_config.rb

@@ -34,6 +34,7 @@ module RuboCop
     def initialize(processed_source)
       @processed_source = processed_source
       @no_directives = !processed_source.raw_source.include?('rubocop')
+      @stack = []
     end
 
     def cop_enabled_at_line?(cop, line_number)
@@ -93,16 +94,23 @@ module RuboCop
       end
     end
 
-    def analyze # rubocop:todo Metrics/AbcSize
+    def analyze # rubocop:todo Metrics/AbcSize, Metrics/MethodLength
       return {} if @no_directives
 
       analyses = Hash.new { |hash, key| hash[key] = CopAnalysis.new([], nil) }
       inject_disabled_cops_directives(analyses)
 
       each_directive do |directive|
-        directive.cop_names.each do |cop_name|
-          cop_name = qualified_cop_name(cop_name)
-          analyses[cop_name] = analyze_cop(analyses[cop_name], directive)
+        if directive.push?
+          @stack.push(snapshot_analyses(analyses))
+          apply_push_args(analyses, directive)
+        elsif directive.pop?
+          pop_state(analyses, directive.line_number) if @stack.any?
+        else
+          directive.cop_names.each do |cop_name|
+            cop_name = qualified_cop_name(cop_name)
+            analyses[cop_name] = analyze_cop(analyses[cop_name], directive)
+          end
         end
       end
 
@@ -112,6 +120,51 @@ module RuboCop
       end
     end
 
+    def snapshot_analyses(analyses)
+      analyses.transform_values { |a| CopAnalysis.new(a.line_ranges.dup, a.start_line_number) }
+    end
+
+    def pop_state(analyses, pop_line)
+      analyses.each do |cop_name, analysis|
+        next unless analysis.start_line_number
+
+        analyses[cop_name] = CopAnalysis.new(
+          analysis.line_ranges + [analysis.start_line_number...pop_line], nil
+        )
+      end
+
+      @stack.pop.each do |cop_name, saved_analysis|
+        current = analyses[cop_name]
+        new_start = saved_analysis.start_line_number ? pop_line : nil
+        analyses[cop_name] = CopAnalysis.new(current.line_ranges, new_start)
+      end
+    end
+
+    def apply_push_args(analyses, directive)
+      directive.push_args.each do |operation, cop_names|
+        cop_names.each do |cop_name|
+          apply_cop_operation(analyses, operation, qualified_cop_name(cop_name),
+                              directive.line_number)
+        end
+      end
+    end
+
+    def apply_cop_operation(analyses, operation, cop_name, line)
+      analysis = analyses[cop_name]
+      start_line = analysis.start_line_number
+
+      case operation
+      when '+' # Enable cop
+        return unless start_line
+
+        analyses[cop_name] = CopAnalysis.new(analysis.line_ranges + [start_line..line], nil)
+      when '-' # Disable cop
+        return if start_line
+
+        analyses[cop_name] = CopAnalysis.new(analysis.line_ranges, line)
+      end
+    end
+
     def inject_disabled_cops_directives(analyses)
       registry.disabled(config).each do |cop|
         analyses[cop.cop_name] = analyze_cop(
@@ -136,29 +189,21 @@ module RuboCop
       return analysis unless directive.disabled?
 
       line = directive.line_number
-      start_line = analysis.start_line_number
-
-      CopAnalysis.new(analysis.line_ranges + [(line..line)], start_line)
+      CopAnalysis.new(analysis.line_ranges + [(line..line)], analysis.start_line_number)
     end
 
     def analyze_disabled(analysis, directive)
       line = directive.line_number
       start_line = analysis.start_line_number
-
-      # Cop already disabled on this line, so we end the current disabled
-      # range before we start a new range.
-      return CopAnalysis.new(analysis.line_ranges + [start_line..line], line) if start_line
-
-      CopAnalysis.new(analysis.line_ranges, line)
+      new_ranges = start_line ? analysis.line_ranges + [start_line..line] : analysis.line_ranges
+      CopAnalysis.new(new_ranges, line)
     end
 
     def analyze_rest(analysis, directive)
       line = directive.line_number
       start_line = analysis.start_line_number
-
-      return CopAnalysis.new(analysis.line_ranges + [start_line..line], nil) if start_line
-
-      CopAnalysis.new(analysis.line_ranges, nil)
+      new_ranges = start_line ? analysis.line_ranges + [start_line..line] : analysis.line_ranges
+      CopAnalysis.new(new_ranges, nil)
     end
 
     def cop_line_ranges(analysis)

data/lib/rubocop/config_loader.rb

@@ -23,7 +23,7 @@ module RuboCop
       include FileFinder
 
       attr_accessor :debug, :ignore_parent_exclusion, :disable_pending_cops, :enable_pending_cops,
-                    :ignore_unrecognized_cops
+                    :ignore_unrecognized_cops, :cache_root
       attr_writer :default_configuration
       attr_reader :loaded_plugins, :loaded_features
 
@@ -38,6 +38,7 @@ module RuboCop
         @enable_pending_cops = nil
         @ignore_parent_exclusion = nil
         @ignore_unrecognized_cops = nil
+        @cache_root = nil
         FileFinder.root_level = nil
       end
 

data/lib/rubocop/config_loader_resolver.rb

@@ -246,7 +246,7 @@ module RuboCop
     def inherited_file(path, inherit_from, file)
       if PathUtil.remote_file?(inherit_from)
         # A remote configuration, e.g. `inherit_from: http://example.com/rubocop.yml`.
-        RemoteConfig.new(inherit_from, File.dirname(path))
+        RemoteConfig.new(inherit_from, ConfigLoader.cache_root)
       elsif Pathname.new(inherit_from).absolute?
         # An absolute path to a config, e.g. `inherit_from: /Users/me/rubocop.yml`.
         # The path may come from `inherit_gem` option, where a gem name is expanded
@@ -256,7 +256,7 @@ module RuboCop
       elsif file.is_a?(RemoteConfig)
         # A path relative to a URL, e.g. `inherit_from: configs/default.yml`
         # in a config included with `inherit_from: http://example.com/rubocop.yml`
-        file.inherit_from_remote(inherit_from, path)
+        file.inherit_from_remote(inherit_from)
       else
         # A local relative path, e.g. `inherit_from: default.yml`
         print 'Inheriting ' if ConfigLoader.debug?

data/lib/rubocop/cop/autocorrect_logic.rb

@@ -133,6 +133,8 @@ module RuboCop
       end
 
       def max_line_length
+        return unless config.cop_enabled?('Layout/LineLength')
+
         config.for_cop('Layout/LineLength')['Max'] || 120
       end
 

data/lib/rubocop/cop/correctors/alignment_corrector.rb

@@ -76,9 +76,7 @@ module RuboCop
         #   nil.
         # - The source map of `__FILE__` responds to neither :begin nor :end.
         def delimited_string_literal?(node)
-          loc = node.location
-
-          loc.respond_to?(:begin) && loc.begin && loc.respond_to?(:end) && loc.end
+          node.loc?(:begin) && node.loc?(:end)
         end
 
         def block_comment_within?(expr)

data/lib/rubocop/cop/gemspec/ruby_version_globals_usage.rb

@@ -3,8 +3,8 @@
 module RuboCop
   module Cop
     module Gemspec
-      # Checks that `RUBY_VERSION` constant is not used in gemspec.
-      # Using `RUBY_VERSION` is dangerous because value of the
+      # Checks that `RUBY_VERSION` and `Ruby::VERSION` constants are not used in gemspec.
+      # Using `RUBY_VERSION` and `Ruby::VERSION` are dangerous because value of the
       # constant is determined by `rake release`.
       # It's possible to have dependency based on ruby version used
       # to execute `rake release` and not user's ruby version.
@@ -28,15 +28,20 @@ module RuboCop
       class RubyVersionGlobalsUsage < Base
         include GemspecHelp
 
-        MSG = 'Do not use `RUBY_VERSION` in gemspec file.'
+        MSG = 'Do not use `%<ruby_version>s` in gemspec file.'
 
         # @!method ruby_version?(node)
-        def_node_matcher :ruby_version?, '(const {cbase nil?} :RUBY_VERSION)'
+        def_node_matcher :ruby_version?, <<~PATTERN
+          {
+            (const {cbase nil?} :RUBY_VERSION)
+            (const (const {cbase nil?} :Ruby) :VERSION)
+          }
+        PATTERN
 
         def on_const(node)
           return unless gem_spec_with_ruby_version?(node)
 
-          add_offense(node)
+          add_offense(node, message: format(MSG, ruby_version: node.source))
         end
 
         private

data/lib/rubocop/cop/internal_affairs/location_exists.rb

@@ -9,6 +9,12 @@ module RuboCop
       #
       # @example
       #   # bad
+      #   node.loc.respond_to?(:begin)
+      #
+      #   # good
+      #   node.loc?(:begin)
+      #
+      #   # bad
       #   node.loc.respond_to?(:begin) && node.loc.begin
       #
       #   # good
@@ -29,7 +35,16 @@ module RuboCop
       class LocationExists < Base
         extend AutoCorrector
 
-        MSG = 'Use `%<replacement>s` instead of `%<source>s`.'
+        MSG = 'Use `node.loc?` instead of `loc.respond_to?`.'
+        MSG_CORRECTABLE = 'Use `%<replacement>s` instead of `%<source>s`.'
+        RESTRICT_ON_SEND = %i[respond_to?].freeze
+
+        # @!method loc_respond_to?(node)
+        def_node_matcher :loc_respond_to?, <<~PATTERN
+          (call
+            (call $_receiver :loc) :respond_to?
+            $(sym _location))
+        PATTERN
 
         # @!method replaceable_with_loc_is(node)
         def_node_matcher :replaceable_with_loc_is, <<~PATTERN
@@ -64,6 +79,15 @@ module RuboCop
           replace_with_loc(node) || replace_with_loc_is(node)
         end
 
+        def on_send(node)
+          return if ignored_node?(node.parent)
+
+          loc_respond_to?(node) do |receiver, location|
+            register_offense(node, replacement(receiver, "loc?(#{location.source})"))
+          end
+        end
+        alias on_csend on_send
+
         private
 
         def replace_with_loc(node)
@@ -84,11 +108,13 @@ module RuboCop
         end
 
         def register_offense(node, replacement)
-          message = format(MSG, replacement: replacement, source: node.source)
+          message = format(MSG_CORRECTABLE, replacement: replacement, source: node.source)
 
           add_offense(node, message: message) do |corrector|
             corrector.replace(node, replacement)
           end
+
+          ignore_node(node)
         end
 
         def replacement(receiver, rest)

data/lib/rubocop/cop/internal_affairs/node_pattern_groups/ast_processor.rb

@@ -7,7 +7,7 @@ module RuboCop
         # AST Processor for NodePattern ASTs, for use with `InternalAffairs/NodePatternGroups`.
         #
         # Looks for sequences and subsequences where the first item is a `node_type` node,
-        # and converts them to `node_sequence` nodes (not a true `Rubocop::AST::NodePattern`
+        # and converts them to `node_sequence` nodes (not a true `RuboCop::AST::NodePattern`
         # node type).
         #
         # The resulting AST will be walked by `InternalAffairs::NodePatternGroups::ASTWalker`

data/lib/rubocop/cop/layout/empty_line_after_guard_clause.rb

@@ -145,8 +145,10 @@ module RuboCop
           next_sibling.if_type? && contains_guard_clause?(next_sibling)
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def last_heredoc_argument(node)
           n = last_heredoc_argument_node(node)
+          n = n.children.first while n.respond_to?(:begin_type?) && n.begin_type?
 
           return n if heredoc?(n)
           return unless n.respond_to?(:arguments)
@@ -158,6 +160,7 @@ module RuboCop
 
           last_heredoc_argument(n.receiver) if n.respond_to?(:receiver)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def last_heredoc_argument_node(node)
           return node unless node.respond_to?(:if_branch)

data/lib/rubocop/cop/layout/end_alignment.rb

@@ -128,6 +128,10 @@ module RuboCop
           # assignment, we let rhs be the receiver of those method calls before
           # we check if it's an if/unless/while/until.
           return unless (rhs = first_part_of_call_chain(rhs))
+
+          # If `rhs` is a `begin` node, find the first non-`begin` child.
+          rhs = rhs.child_nodes.first while rhs.begin_type?
+
           return unless rhs.conditional?
           return if rhs.if_type? && rhs.ternary?
 

data/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb

@@ -168,7 +168,7 @@ module RuboCop
 
         def subsequent_closing_parentheses_in_same_line?(outermost_send)
           last_arg_of_outer_send = outermost_send.last_argument
-          return false unless last_arg_of_outer_send&.loc.respond_to?(:end) &&
+          return false unless last_arg_of_outer_send&.loc?(:end) &&
                               (end_of_last_arg_of_outer_send = last_arg_of_outer_send.loc.end)
 
           end_of_outer_send = outermost_send.loc.end
@@ -230,7 +230,7 @@ module RuboCop
 
         def find_most_bottom_of_heredoc_end(arguments)
           arguments.filter_map do |argument|
-            argument.loc.heredoc_end.end_pos if argument.loc.respond_to?(:heredoc_end)
+            argument.loc.heredoc_end.end_pos if argument.loc?(:heredoc_end)
           end.max
         end
 

data/lib/rubocop/cop/layout/heredoc_indentation.rb

@@ -108,10 +108,6 @@ module RuboCop
           config.for_cop('Layout/LineLength')['AllowHeredoc']
         end
 
-        def max_line_length
-          config.for_cop('Layout/LineLength')['Max']
-        end
-
         def adjust_squiggly(corrector, node)
           corrector.replace(node.loc.heredoc_body, indented_body(node))
           corrector.replace(node.loc.heredoc_end, indented_end(node))

data/lib/rubocop/cop/layout/indentation_style.rb

@@ -99,7 +99,7 @@ module RuboCop
 
             if str.heredoc?
               ranges << loc.heredoc_body
-            elsif loc.respond_to?(:begin) && loc.begin
+            elsif str.loc?(:begin)
               ranges << loc.expression
             end
           end

data/lib/rubocop/cop/layout/line_continuation_spacing.rb

@@ -101,7 +101,7 @@ module RuboCop
               ranges << loc.expression
             elsif literal.heredoc?
               ranges << loc.heredoc_body
-            elsif (loc.respond_to?(:begin) && loc.begin) || ignored_parent?(literal)
+            elsif literal.loc?(:begin) || ignored_parent?(literal)
               ranges << loc.expression
             end
           end

data/lib/rubocop/cop/layout/line_length.rb

@@ -252,17 +252,22 @@ module RuboCop
           [max - indentation_difference(line), 0].max
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def check_line(line, line_index)
           return if line_length(line) <= max
           return if allowed_line?(line, line_index)
+          if allow_rbs_inline_annotation? && rbs_inline_annotation_on_source_line?(line_index)
+            return
+          end
 
-          if ignore_cop_directives? && directive_on_source_line?(line_index)
+          if allow_cop_directives? && directive_on_source_line?(line_index)
             return check_directive_line(line, line_index)
           end
           return check_line_for_exemptions(line, line_index) if allow_uri? || allow_qualified_name?
 
           register_offense(excess_range(nil, line, line_index), line, line_index)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def allowed_line?(line, line_index)
           matches_allowed_pattern?(line) ||
@@ -401,9 +406,7 @@ module RuboCop
 
         def string_delimiter(node)
           delimiter = node.loc.begin
-          if node.parent&.dstr_type? && node.parent.loc.respond_to?(:begin)
-            delimiter ||= node.parent.loc.begin
-          end
+          delimiter ||= node.parent.loc.begin if node.parent&.dstr_type? && node.parent.loc?(:begin)
           delimiter = delimiter&.source
 
           delimiter if %w[' "].include?(delimiter)

data/lib/rubocop/cop/layout/rescue_ensure_alignment.rb

@@ -29,7 +29,7 @@ module RuboCop
         MSG = '`%<kw_loc>s` at %<kw_loc_line>d, %<kw_loc_column>d is not ' \
               'aligned with `%<beginning>s` at ' \
               '%<begin_loc_line>d, %<begin_loc_column>d.'
-        ANCESTOR_TYPES = %i[kwbegin any_def class module any_block].freeze
+        ANCESTOR_TYPES = %i[kwbegin any_def class module sclass any_block].freeze
         ALTERNATIVE_ACCESS_MODIFIERS = %i[public_class_method private_class_method].freeze
 
         def on_resbody(node)
@@ -91,7 +91,7 @@ module RuboCop
           )
         end
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         def alignment_source(node, starting_loc)
           ending_loc =
             case node.type
@@ -100,6 +100,8 @@ module RuboCop
             when :def, :defs, :class, :module,
                  :lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn
               node.loc.name
+            when :sclass
+              node.identifier.source_range
             when :masgn
               node.lhs.source_range
             else
@@ -109,7 +111,7 @@ module RuboCop
 
           range_between(starting_loc.begin_pos, ending_loc.end_pos).source
         end
-        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
         # We will use ancestor or wrapper with access modifier.
 

data/lib/rubocop/cop/layout/space_around_keyword.rb

@@ -167,7 +167,7 @@ module RuboCop
 
         def check(node, locations, begin_keyword = DO)
           locations.each do |loc|
-            next unless node.loc.respond_to?(loc)
+            next unless node.loc?(loc)
 
             range = node.loc.public_send(loc)
             next unless range

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

@@ -35,6 +35,26 @@ module RuboCop
       #   def cook(dry_ingredients = self.dry_ingredients)
       #     dry_ingredients.combine
       #   end
+      #
+      #   # bad
+      #   def foo(pie = pie = pie)
+      #     pie.heat_up
+      #   end
+      #
+      #   # good
+      #   def foo(pie)
+      #     pie.heat_up
+      #   end
+      #
+      #   # bad
+      #   def foo(pie = cake = pie)
+      #     [pie, cake].each(&:heat_up)
+      #   end
+      #
+      #   # good
+      #   def foo(cake = pie)
+      #     [pie, cake].each(&:heat_up)
+      #   end
       class CircularArgumentReference < Base
         extend TargetRubyVersion
 
@@ -51,11 +71,35 @@ module RuboCop
         private
 
         def check_for_circular_argument_references(arg_name, arg_value)
-          return unless arg_value.lvar_type?
-          return unless arg_value.to_a == [arg_name]
+          if arg_value.lvar_type? && arg_value.to_a == [arg_name]
+            add_offense(arg_value, message: format(MSG, arg_name: arg_name))
+
+            return
+          end
+
+          check_assignment_chain(arg_name, arg_value)
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def check_assignment_chain(arg_name, node)
+          return unless node.lvasgn_type?
+
+          seen_variables = Set[]
+          current_node = node
+
+          while current_node.lvasgn_type?
+            seen_variables << current_node.children.first if current_node.lvasgn_type?
+            current_node = current_node.children.last
+          end
+
+          return unless current_node.lvar_type?
+
+          variable_node = current_node.children.first
+          return unless seen_variables.include?(variable_node) || variable_node == arg_name
 
-          add_offense(arg_value, message: format(MSG, arg_name: arg_name))
+          add_offense(current_node, message: format(MSG, arg_name: arg_name))
         end
+        # rubocop:enable Metrics/AbcSize
       end
     end
   end

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

@@ -46,7 +46,7 @@ module RuboCop
         COMMON_MSG = 'Malformed directive comment detected.'
 
         MISSING_MODE_NAME_MSG = 'The mode name is missing.'
-        INVALID_MODE_NAME_MSG = 'The mode name must be one of `enable`, `disable`, or `todo`.'
+        INVALID_MODE_NAME_MSG = 'The mode name must be one of `enable`, `disable`, `todo`, `push`, or `pop`.' # rubocop:disable Layout/LineLength
         MISSING_COP_NAME_MSG = 'The cop name is missing.'
         MALFORMED_COP_NAMES_MSG = 'Cop names must be separated by commas. ' \
                                   'Comment in the directive must start with `--`.'