rubocop 1.44.1 → 1.78.0

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

@@ -4,10 +4,13 @@ module RuboCop
   module Cop
     module Style
       # Checks for numeric comparisons that can be replaced
-      # by a predicate method, such as receiver.length == 0,
-      # receiver.length > 0, receiver.length != 0,
-      # receiver.length < 1 and receiver.size == 0 that can be
-      # replaced by receiver.empty? and !receiver.empty?.
+      # by a predicate method, such as `receiver.length == 0`,
+      # `receiver.length > 0`, and `receiver.length != 0`,
+      # `receiver.length < 1` and `receiver.size == 0` that can be
+      # replaced by `receiver.empty?` and `!receiver.empty?`.
+      #
+      # NOTE: `File`, `Tempfile`, and `StringIO` do not have `empty?`
+      # so allow `size == 0` and `size.zero?`.
       #
       # @safety
       #   This cop is unsafe because it cannot be guaranteed that the receiver
@@ -45,13 +48,19 @@ module RuboCop
           check_nonzero_length_comparison(node)
         end
 
+        def on_csend(node)
+          check_zero_length_predicate(node)
+          check_zero_length_comparison(node)
+        end
+
         private
 
         def check_zero_length_predicate(node)
-          return unless (length_method = zero_length_predicate(node.parent))
+          return unless zero_length_predicate?(node.parent)
+          return if non_polymorphic_collection?(node.parent)
 
           offense = node.loc.selector.join(node.parent.source_range.end)
-          message = format(ZERO_MSG, current: "#{length_method}.zero?")
+          message = format(ZERO_MSG, current: offense.source)
 
           add_offense(offense, message: message) do |corrector|
             corrector.replace(offense, 'empty?')
@@ -88,44 +97,47 @@ module RuboCop
           end
         end
 
-        # @!method zero_length_predicate(node)
-        def_node_matcher :zero_length_predicate, <<~PATTERN
-          (send (send (...) ${:length :size}) :zero?)
+        # @!method zero_length_predicate?(node)
+        def_node_matcher :zero_length_predicate?, <<~PATTERN
+          (call (call (...) {:length :size}) :zero?)
         PATTERN
 
         # @!method zero_length_comparison(node)
         def_node_matcher :zero_length_comparison, <<~PATTERN
-          {(send (send (...) ${:length :size}) $:== (int $0))
-           (send (int $0) $:== (send (...) ${:length :size}))
-           (send (send (...) ${:length :size}) $:<  (int $1))
-           (send (int $1) $:> (send (...) ${:length :size}))}
+          {(call (call (...) ${:length :size}) $:== (int $0))
+           (call (int $0) $:== (call (...) ${:length :size}))
+           (call (call (...) ${:length :size}) $:<  (int $1))
+           (call (int $1) $:> (call (...) ${:length :size}))}
         PATTERN
 
         # @!method nonzero_length_comparison(node)
         def_node_matcher :nonzero_length_comparison, <<~PATTERN
-          {(send (send (...) ${:length :size}) ${:> :!=} (int $0))
-           (send (int $0) ${:< :!=} (send (...) ${:length :size}))}
+          {(call (call (...) ${:length :size}) ${:> :!=} (int $0))
+           (call (int $0) ${:< :!=} (call (...) ${:length :size}))}
         PATTERN
 
         def replacement(node)
-          receiver = zero_length_receiver(node)
-          return "#{receiver.source}.empty?" if receiver
+          length_node = zero_length_node(node)
+          if length_node&.receiver
+            return "#{length_node.receiver.source}#{length_node.loc.dot.source}empty?"
+          end
 
-          "!#{other_receiver(node).source}.empty?"
+          other_length_node = other_length_node(node)
+          "!#{other_length_node.receiver.source}#{other_length_node.loc.dot.source}empty?"
         end
 
-        # @!method zero_length_receiver(node)
-        def_node_matcher :zero_length_receiver, <<~PATTERN
-          {(send (send $_ _) :== (int 0))
-           (send (int 0) :== (send $_ _))
-           (send (send $_ _) :<  (int 1))
-           (send (int 1) :> (send $_ _))}
+        # @!method zero_length_node(node)
+        def_node_matcher :zero_length_node, <<~PATTERN
+          {(send $(call _ _) :== (int 0))
+           (send (int 0) :== $(call _ _))
+           (send $(call _ _) :<  (int 1))
+           (send (int 1) :> $(call _ _))}
         PATTERN
 
-        # @!method other_receiver(node)
-        def_node_matcher :other_receiver, <<~PATTERN
-          {(send (send $_ _) _ _)
-           (send _ _ (send $_ _))}
+        # @!method other_length_node(node)
+        def_node_matcher :other_length_node, <<~PATTERN
+          {(call $(call _ _) _ _)
+           (call _ _ $(call _ _))}
         PATTERN
 
         # Some collection like objects in the Ruby standard library
@@ -134,7 +146,7 @@ module RuboCop
         # @!method non_polymorphic_collection?(node)
         def_node_matcher :non_polymorphic_collection?, <<~PATTERN
           {(send (send (send (const {nil? cbase} :File) :stat _) ...) ...)
-           (send (send (send (const {nil? cbase} {:Tempfile :StringIO}) {:new :open} ...) ...) ...)}
+           (send (send (send (const {nil? cbase} {:File :Tempfile :StringIO}) {:new :open} ...) ...) ...)}
         PATTERN
       end
     end

data/lib/rubocop/cop/team.rb

@@ -9,11 +9,17 @@ module RuboCop
     # For performance reasons, Team will first dispatch cops & forces in two groups,
     # first the ones needed for autocorrection (if any), then the rest
     # (unless autocorrections happened).
+    # rubocop:disable Metrics/ClassLength
     class Team
       # @return [Team]
       def self.new(cop_or_classes, config, options = {})
         # Support v0 api:
-        return mobilize(cop_or_classes, config, options) if cop_or_classes.first.is_a?(Class)
+        if cop_or_classes.first.is_a?(Class)
+          warn Rainbow(<<~WARNING).yellow, uplevel: 1
+            `Team.new` with cop classes is deprecated. Use `Team.mobilize` instead.
+          WARNING
+          return mobilize(cop_or_classes, config, options)
+        end
 
         super
       end
@@ -28,7 +34,7 @@ module RuboCop
       def self.mobilize_cops(cop_classes, config, options = {})
         cop_classes = Registry.new(cop_classes.to_a, options) unless cop_classes.is_a?(Registry)
 
-        cop_classes.enabled(config).map do |cop_class|
+        cop_classes.map do |cop_class|
           cop_class.new(config, options)
         end
       end
@@ -58,6 +64,7 @@ module RuboCop
         @options = options
         reset
         @ready = true
+        @registry = Registry.new(cops, options.dup)
 
         validate_config
       end
@@ -73,28 +80,33 @@ module RuboCop
       # @deprecated. Use investigate
       # @return Array<offenses>
       def inspect_file(processed_source)
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `inspect_file` is deprecated. Use `investigate` instead.
+        WARNING
+
         investigate(processed_source).offenses
       end
 
       # @return [Commissioner::InvestigationReport]
-      def investigate(processed_source)
+      def investigate(processed_source, offset: 0, original: processed_source)
         be_ready
 
         # The autocorrection process may have to be repeated multiple times
         # until there are no corrections left to perform
         # To speed things up, run autocorrecting cops by themselves, and only
         # run the other cops when no corrections are left
-        on_duty = roundup_relevant_cops(processed_source.file_path)
+        on_duty = roundup_relevant_cops(processed_source)
 
         autocorrect_cops, other_cops = on_duty.partition(&:autocorrect?)
+        report = investigate_partial(autocorrect_cops, processed_source,
+                                     offset: offset, original: original)
 
-        report = investigate_partial(autocorrect_cops, processed_source)
-
-        unless autocorrect(processed_source, report)
+        unless autocorrect(processed_source, report, offset: offset, original: original)
           # If we corrected some errors, another round of inspection will be
           # done, and any other offenses will be caught then, so only need
           # to check other_cops if no correction was done
-          report = report.merge(investigate_partial(other_cops, processed_source))
+          report = report.merge(investigate_partial(other_cops, processed_source,
+                                                    offset: offset, original: original))
         end
 
         process_errors(processed_source.path, report.errors)
@@ -106,22 +118,30 @@ module RuboCop
 
       # @deprecated
       def forces
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `forces` is deprecated.
+        WARNING
+
         @forces ||= self.class.forces_for(cops)
       end
 
       def external_dependency_checksum
-        keys = cops.map(&:external_dependency_checksum).compact
-        Digest::SHA1.hexdigest(keys.join)
+        # The external dependency checksums are cached per RuboCop team so that
+        # the checksums don't need to be recomputed for each file.
+        @external_dependency_checksum ||= begin
+          keys = cops.filter_map(&:external_dependency_checksum)
+          Digest::SHA1.hexdigest(keys.join)
+        end
       end
 
       private
 
-      def autocorrect(processed_source, report)
+      def autocorrect(processed_source, report, original:, offset:)
         @updated_source_file = false
         return unless autocorrect?
         return if report.processed_source.parser_error
 
-        new_source = autocorrect_report(report)
+        new_source = autocorrect_report(report, original: original, offset: offset)
 
         return unless new_source
 
@@ -129,7 +149,7 @@ module RuboCop
           # holds source read in from stdin, when --stdin option is used
           @options[:stdin] = new_source
         else
-          filename = processed_source.buffer.name
+          filename = processed_source.file_path
           File.write(filename, new_source)
         end
         @updated_source_file = true
@@ -149,17 +169,19 @@ module RuboCop
       end
 
       # @return [Commissioner::InvestigationReport]
-      def investigate_partial(cops, processed_source)
+      def investigate_partial(cops, processed_source, offset:, original:)
         commissioner = Commissioner.new(cops, self.class.forces_for(cops), @options)
-        commissioner.investigate(processed_source)
+        commissioner.investigate(processed_source, offset: offset, original: original)
       end
 
       # @return [Array<cop>]
-      def roundup_relevant_cops(filename)
-        cops.reject do |cop|
-          cop.excluded_file?(filename) ||
-            !support_target_ruby_version?(cop) ||
-            !support_target_rails_version?(cop)
+      def roundup_relevant_cops(processed_source)
+        cops.select do |cop|
+          next true if processed_source.comment_config.cop_opted_in?(cop)
+          next false if cop.excluded_file?(processed_source.file_path)
+          next false unless @registry.enabled?(cop, @config)
+
+          support_target_ruby_version?(cop) && support_target_rails_version?(cop)
         end
       end
 
@@ -170,23 +192,30 @@ module RuboCop
       end
 
       def support_target_rails_version?(cop)
+        # In this case, the rails version was already checked by `#excluded_file?`
+        return true if defined?(RuboCop::Rails::TargetRailsVersion::USES_REQUIRES_GEM_API)
+
         return true unless cop.class.respond_to?(:support_target_rails_version?)
 
         cop.class.support_target_rails_version?(cop.target_rails_version)
       end
 
-      def autocorrect_report(report)
-        corrector = collate_corrections(report)
+      def autocorrect_report(report, offset:, original:)
+        corrector = collate_corrections(report, offset: offset, original: original)
 
         corrector.rewrite unless corrector.empty?
       end
 
-      def collate_corrections(report)
-        corrector = Corrector.new(report.processed_source)
+      def collate_corrections(report, offset:, original:)
+        corrector = Corrector.new(original)
 
         each_corrector(report) do |to_merge|
           suppress_clobbering do
-            corrector.merge!(to_merge)
+            if offset.positive?
+              corrector.import!(to_merge, offset: offset)
+            else
+              corrector.merge!(to_merge)
+            end
           end
         end
 
@@ -229,6 +258,8 @@ module RuboCop
 
           if cause.is_a?(Warning)
             handle_warning(cause, location)
+          elsif cause.is_a?(Force::HookError)
+            handle_error(cause.cause, location, cause.joining_cop)
           else
             handle_error(cause, location, error.cop)
           end
@@ -248,11 +279,12 @@ module RuboCop
         @errors << message
         warn message
         if debug?
-          puts error.message, error.backtrace
+          puts error.full_message
         else
           warn 'To see the complete backtrace run rubocop -d.'
         end
       end
     end
+    # rubocop:enable Metrics/ClassLength
   end
 end

data/lib/rubocop/cop/util.rb

@@ -3,6 +3,7 @@
 module RuboCop
   module Cop
     # This module contains a collection of useful utility methods.
+    # rubocop:disable Metrics/ModuleLength
     module Util
       include PathUtil
 
@@ -19,6 +20,10 @@ module RuboCop
 
       # @deprecated Use `ProcessedSource#line_with_comment?`, `contains_comment?` or similar
       def comment_lines?(node)
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `comment_lines?` is deprecated. Use `ProcessedSource#line_with_comment?`, `contains_comment?` or similar instead.
+        WARNING
+
         processed_source[line_range(node)].any? { |line| comment_line?(line) }
       end
 
@@ -27,7 +32,7 @@ module RuboCop
       end
 
       def parentheses?(node)
-        node.loc.respond_to?(:end) && node.loc.end && node.loc.end.is?(')')
+        node.loc_is?(:end, ')')
       end
 
       # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
@@ -69,9 +74,9 @@ module RuboCop
 
       def args_begin(node)
         loc = node.loc
-        selector = if node.super_type? || node.yield_type?
+        selector = if node.type?(:super, :yield)
                      loc.keyword
-                   elsif node.def_type? || node.defs_type?
+                   elsif node.any_def_type?
                      loc.name
                    else
                      loc.selector
@@ -80,7 +85,7 @@ module RuboCop
       end
 
       def args_end(node)
-        node.loc.expression.end
+        node.source_range.end
       end
 
       def on_node(syms, sexp, excludes = [], &block)
@@ -92,13 +97,20 @@ module RuboCop
         sexp.each_child_node { |elem| on_node(syms, elem, excludes, &block) }
       end
 
+      # Arbitrarily chosen value, should be enough to cover
+      # the most nested source code in real world projects.
+      MAX_LINE_BEGINS_REGEX_INDEX = 50
       LINE_BEGINS_REGEX_CACHE = Hash.new do |hash, index|
-        hash[index] = /^\s{#{index}}\S/
+        hash[index] = /^\s{#{index}}\S/ if index <= MAX_LINE_BEGINS_REGEX_INDEX
       end
-      private_constant :LINE_BEGINS_REGEX_CACHE
+      private_constant :MAX_LINE_BEGINS_REGEX_INDEX, :LINE_BEGINS_REGEX_CACHE
 
       def begins_its_line?(range)
-        range.source_line.match?(LINE_BEGINS_REGEX_CACHE[range.column])
+        if (regex = LINE_BEGINS_REGEX_CACHE[range.column])
+          range.source_line.match?(regex)
+        else
+          range.source_line.index(/\S/) == range.column
+        end
       end
 
       # Returns, for example, a bare `if` node if the given node is an `if`
@@ -134,7 +146,7 @@ module RuboCop
       end
 
       def escape_string(string)
-        string.inspect[1..-2].tap { |s| s.gsub!(/\\"/, '"') }
+        string.inspect[1..-2].tap { |s| s.gsub!('\\"', '"') }
       end
 
       def to_string_literal(string)
@@ -165,7 +177,9 @@ module RuboCop
       def same_line?(node1, node2)
         line1 = line(node1)
         line2 = line(node2)
-        line1 && line2 && line1 == line2
+        return false unless line1 && line2
+
+        line1 == line2
       end
 
       def indent(node, offset: 0)
@@ -179,16 +193,24 @@ module RuboCop
           enforced_style.sub(/^Enforced/, 'Supported').sub('Style', 'Styles')
       end
 
+      def parse_regexp(text)
+        Regexp::Parser.parse(text)
+      rescue Regexp::Parser::Error
+        # Upon encountering an invalid regular expression,
+        # we aim to proceed and identify any remaining potential offenses.
+        nil
+      end
+
       private
 
       def compatible_external_encoding_for?(src)
-        src = src.dup if RUBY_ENGINE == 'jruby'
-        src.force_encoding(Encoding.default_external).valid_encoding?
+        src.dup.force_encoding(Encoding.default_external).valid_encoding?
       end
 
       def include_or_equal?(source, target)
         source == target || (source.is_a?(Array) && source.include?(target))
       end
     end
+    # rubocop:enable Metrics/ModuleLength
   end
 end

data/lib/rubocop/cop/utils/format_string.rb

@@ -5,15 +5,19 @@ module RuboCop
     module Utils
       # Parses {Kernel#sprintf} format strings.
       class FormatString
-        DIGIT_DOLLAR  = /(\d+)\$/.freeze
+        # Escaping the `#` in `INTERPOLATION` and `TEMPLATE_NAME` is necessary to
+        # avoid a bug in Ruby 3.2.0
+        # See: https://bugs.ruby-lang.org/issues/19379
+        DIGIT_DOLLAR  = /(?<arg_number>\d+)\$/.freeze
+        INTERPOLATION = /\#\{.*?\}/.freeze
         FLAG          = /[ #0+-]|#{DIGIT_DOLLAR}/.freeze
         NUMBER_ARG    = /\*#{DIGIT_DOLLAR}?/.freeze
-        NUMBER        = /\d+|#{NUMBER_ARG}/.freeze
+        NUMBER        = /\d+|#{NUMBER_ARG}|#{INTERPOLATION}/.freeze
         WIDTH         = /(?<width>#{NUMBER})/.freeze
-        PRECISION     = /\.(?<precision>#{NUMBER})/.freeze
+        PRECISION     = /\.(?<precision>#{NUMBER}?)/.freeze
         TYPE          = /(?<type>[bBdiouxXeEfgGaAcps])/.freeze
         NAME          = /<(?<name>\w+)>/.freeze
-        TEMPLATE_NAME = /\{(?<name>\w+)\}/.freeze
+        TEMPLATE_NAME = /(?<!\#)\{(?<name>\w+)\}/.freeze
 
         SEQUENCE = /
             % (?<type>%)
@@ -41,7 +45,7 @@ module RuboCop
         #
         # @see https://ruby-doc.org/core-2.6.3/Kernel.html#method-i-format
         class FormatSequence
-          attr_reader :begin_pos, :end_pos, :flags, :width, :precision, :name, :type
+          attr_reader :begin_pos, :end_pos, :flags, :width, :precision, :name, :type, :arg_number
 
           def initialize(match)
             @source = match[0]
@@ -52,6 +56,7 @@ module RuboCop
             @precision = match[:precision]
             @name = match[:name]
             @type = match[:type]
+            @arg_number = match[:arg_number]
           end
 
           def percent?

data/lib/rubocop/cop/variable_force/assignment.rb

@@ -9,9 +9,10 @@ module RuboCop
 
         MULTIPLE_LEFT_HAND_SIDE_TYPE = :mlhs
 
-        attr_reader :node, :variable, :referenced, :references
+        attr_reader :node, :variable, :referenced, :references, :reassigned
 
         alias referenced? referenced
+        alias reassigned? reassigned
 
         def initialize(node, variable)
           unless VARIABLE_ASSIGNMENT_TYPES.include?(node.type)
@@ -24,6 +25,7 @@ module RuboCop
           @variable = variable
           @referenced = false
           @references = []
+          @reassigned = false
         end
 
         def name
@@ -39,14 +41,24 @@ module RuboCop
           @referenced = true
         end
 
+        def reassigned!
+          return if referenced?
+
+          @reassigned = true
+        end
+
         def used?
-          @variable.captured_by_block? || @referenced
+          (!reassigned? && @variable.captured_by_block?) || @referenced
         end
 
         def regexp_named_capture?
           @node.type == REGEXP_NAMED_CAPTURE_TYPE
         end
 
+        def exception_assignment?
+          node.parent&.resbody_type? && node.parent.exception_variable == node
+        end
+
         def operator_assignment?
           return false unless meta_assignment_node
 
@@ -59,6 +71,18 @@ module RuboCop
           meta_assignment_node.type == MULTIPLE_ASSIGNMENT_TYPE
         end
 
+        def rest_assignment?
+          return false unless meta_assignment_node
+
+          meta_assignment_node.type == REST_ASSIGNMENT_TYPE
+        end
+
+        def for_assignment?
+          return false unless meta_assignment_node
+
+          meta_assignment_node.for_type?
+        end
+
         def operator
           assignment_node = meta_assignment_node || @node
           assignment_node.loc.operator.source
@@ -66,7 +90,10 @@ module RuboCop
 
         def meta_assignment_node
           unless instance_variable_defined?(:@meta_assignment_node)
-            @meta_assignment_node = operator_assignment_node || multiple_assignment_node
+            @meta_assignment_node = operator_assignment_node ||
+                                    multiple_assignment_node ||
+                                    rest_assignment_node ||
+                                    for_assignment_node
           end
 
           @meta_assignment_node
@@ -83,13 +110,46 @@ module RuboCop
         end
 
         def multiple_assignment_node
-          grandparent_node = node.parent&.parent
-          return nil unless grandparent_node
+          return nil unless (candidate_mlhs_node = node.parent)
+
+          # In `(foo, bar), *baz`, the splat node must be traversed as well.
+          candidate_mlhs_node = candidate_mlhs_node.parent if candidate_mlhs_node.splat_type?
+
+          return nil unless candidate_mlhs_node.mlhs_type?
+          return nil unless (grandparent_node = node.parent.parent)
+          if (node = find_multiple_assignment_node(grandparent_node))
+            return node
+          end
           return nil unless grandparent_node.type == MULTIPLE_ASSIGNMENT_TYPE
-          return nil unless node.parent.type == MULTIPLE_LEFT_HAND_SIDE_TYPE
 
           grandparent_node
         end
+
+        def rest_assignment_node
+          return nil unless node.parent
+          return nil unless node.parent.type == REST_ASSIGNMENT_TYPE
+
+          node.parent
+        end
+
+        def for_assignment_node
+          return unless (parent_node = node.parent)
+          return parent_node if parent_node.for_type?
+
+          grandparent_node = parent_node.parent
+          return grandparent_node if parent_node.mlhs_type? && grandparent_node&.for_type?
+
+          nil
+        end
+
+        def find_multiple_assignment_node(grandparent_node)
+          return unless grandparent_node.type == MULTIPLE_LEFT_HAND_SIDE_TYPE
+
+          parent = grandparent_node.parent
+          return parent if parent.type == MULTIPLE_ASSIGNMENT_TYPE
+
+          find_multiple_assignment_node(parent)
+        end
       end
     end
   end

data/lib/rubocop/cop/variable_force/branch.rb

@@ -74,7 +74,7 @@ module RuboCop
           def parent
             return @parent if instance_variable_defined?(:@parent)
 
-            @branch = Branch.of(control_node, scope: scope)
+            @parent = Branch.of(control_node, scope: scope)
           end
 
           def each_ancestor(include_self: false, &block)

data/lib/rubocop/cop/variable_force/scope.rb

@@ -45,9 +45,9 @@ module RuboCop
             node
           else
             child_index = case node.type
-                          when :module, :sclass     then 1
-                          when :def, :class, :block then 2
-                          when :defs                then 3
+                          when :module, :sclass then 1
+                          when :def, :class, :block, :numblock, :itblock then 2
+                          when :defs then 3
                           end
 
             node.children[child_index]

data/lib/rubocop/cop/variable_force/variable.rb

@@ -29,7 +29,18 @@ module RuboCop
         end
 
         def assign(node)
-          @assignments << Assignment.new(node, self)
+          assignment = Assignment.new(node, self)
+
+          mark_last_as_reassigned!(assignment)
+
+          @assignments << assignment
+        end
+
+        def mark_last_as_reassigned!(assignment)
+          return if captured_by_block?
+          return unless assignment.branch == @assignments.last&.branch
+
+          @assignments.last&.reassigned!
         end
 
         def referenced?
@@ -52,7 +63,7 @@ module RuboCop
             # if/unless keyword. A preceding assignment is needed to put the
             # variable in scope. For this reason we skip to the next assignment
             # here.
-            next if in_modifier_if?(assignment)
+            next if in_modifier_conditional?(assignment)
 
             break if !assignment.branch || assignment.branch == reference.branch
 
@@ -63,10 +74,12 @@ module RuboCop
         end
         # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
-        def in_modifier_if?(assignment)
+        def in_modifier_conditional?(assignment)
           parent = assignment.node.parent
           parent = parent.parent if parent&.begin_type?
-          parent&.if_type? && parent&.modifier_form?
+          return false if parent.nil?
+
+          parent.type?(:if, :while, :until) && parent.modifier_form?
         end
 
         def capture_with_block!
@@ -94,7 +107,7 @@ module RuboCop
         end
 
         def method_argument?
-          argument? && %i[def defs].include?(@scope.node.type)
+          argument? && @scope.node.any_def_type?
         end
 
         def block_argument?