rubocop 1.89.0 → 1.91.0

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

@@ -2,7 +2,7 @@
 
 # The Lint/RedundantCopDisableDirective cop needs to be disabled so as
 # to be able to provide a (bad) example of a redundant disable.
-# rubocop:disable Lint/RedundantCopDisableDirective
+# rubocop:disable-next Lint/RedundantCopDisableDirective -- the examples below read as real directives
 module RuboCop
   module Cop
     module Lint
@@ -104,17 +104,35 @@ module RuboCop
         end
 
         def each_redundant_disable(&block)
+          each_detached_next_directive(&block)
+
           cop_disabled_line_ranges.each do |cop, line_ranges|
+            # A pending cop that is not enabled in this run produces no
+            # offenses, so its directives cannot be judged - they typically
+            # prepare the code for the moment the cop gets enabled.
+            next if pending_cop_not_run?(cop)
+
             each_already_disabled(cop, line_ranges, &block)
             each_line_range(cop, line_ranges, &block)
           end
         end
 
+        def pending_cop_not_run?(cop)
+          # `Config#for_cop` corrects wrongly-namespaced names, but a name that
+          # is not registered as written never suppresses anything, so it is
+          # reported as unknown rather than exempted via the corrected cop.
+          return false unless all_cop_names.include?(cop)
+
+          cop_cfg = config.for_cop(cop)
+          cop_cfg['Enabled'] == 'pending' &&
+            !processed_source.registry.enabled_pending_cop?(cop_cfg, config, cop)
+        end
+
         def each_line_range(cop, line_ranges)
           line_ranges.each_with_index do |line_range, line_range_index|
             next if should_skip_line_range?(cop, line_range)
 
-            comment = processed_source.comment_at_line(line_range.begin)
+            comment = directive_comment(line_range)
             next if skip_directive?(comment)
 
             next_range = line_ranges[line_range_index + 1]
@@ -127,9 +145,39 @@ module RuboCop
           ignore_offense?(line_range) || expected_final_disable?(cop, line_range)
         end
 
+        # A range opened by a `disable-next` directive starts at the statement,
+        # not at the directive comment above it, so ask the range itself.
+        def directive_comment(line_range)
+          if line_range.respond_to?(:directive)
+            line_range.directive.comment
+          else
+            processed_source.comment_at_line(line_range.begin)
+          end
+        end
+
+        # A next-statement directive with no statement attached (or misplaced
+        # at the end of a code line) affects nothing, so it is redundant by
+        # definition.
+        def each_detached_next_directive
+          processed_source.comment_config.detached_next_directives.each do |directive|
+            names = if directive.next?
+                      directive.signed_args.values.flatten
+                    else
+                      directive.raw_cop_names
+                    end
+            names.each { |cop| yield directive.comment, cop }
+          end
+        end
+
         def skip_directive?(comment)
+          # A cop disabled in the configuration is represented by a synthetic directive that
+          # has no comment in the source, so there is nothing to report or to remove.
+          # Its range starts at `CONFIG_DISABLED_LINE_RANGE_MIN` and runs to the end of the file,
+          # but a `pop` splits it, and the pieces in between are bounded on both sides.
+          return true if comment.is_a?(CommentConfig::ConfigDisabledCopDirectiveComment)
+
           directive = DirectiveComment.new(comment)
-          directive.push? || directive.pop?
+          directive.push? || directive.pop? || directive.next?
         end
 
         def find_redundant_directive(cop, comment, line_range, next_range)
@@ -142,7 +190,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def each_already_disabled(cop, line_ranges)
           line_ranges.each_cons(2) do |previous_range, range|
             next if ignore_offense?(range)
@@ -152,13 +200,13 @@ module RuboCop
             # whether there are offenses or not.
             next unless followed_ranges?(previous_range, range)
 
-            comment = processed_source.comment_at_line(range.begin)
+            comment = directive_comment(range)
 
-            next unless comment
-            # Comments disabling all cops don't count since it's reasonable
-            # to disable a few select cops first and then all cops further
-            # down in the code.
-            next if all_disabled?(comment)
+            # `push`/`next` signed arguments are not analyzed for redundancy
+            # (yet), and comments disabling all cops don't count since it's
+            # reasonable to disable a few select cops first and then all cops
+            # further down in the code.
+            next if comment.nil? || skip_directive?(comment) || all_disabled?(comment)
 
             redundant =
               if department_disabled?(cop, comment)
@@ -170,7 +218,6 @@ module RuboCop
             yield comment, redundant if redundant
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def find_redundant_cop(cop, range)
           cop_offenses = offenses_to_check.select { |offense| offense.cop_name == cop }
@@ -198,7 +245,11 @@ module RuboCop
         end
 
         def range_with_offense?(range, offenses = offenses_to_check)
-          offenses.none? { |offense| range.cover?(offense.line) }
+          # An offense is covered when the disabled range overlaps any line of
+          # its span, mirroring how offenses are suppressed.
+          offenses.none? do |offense|
+            offense.line <= range.end && offense.location.last_line >= range.begin
+          end
         end
 
         def all_disabled?(comment)
@@ -241,17 +292,33 @@ module RuboCop
         end
 
         def add_offense_for_entire_comment(comment, cops)
-          location = DirectiveComment.new(comment).range
+          directive = DirectiveComment.new(comment)
+          location = directive.range
           cop_names = cops.sort.map { |c| describe(c) }.join(', ')
 
-          add_offense(location, message: message(cop_names)) do |corrector|
-            range = comment_range_with_surrounding_space(location, comment.source_range)
+          # An unknown cop may just not be loaded in this run (e.g. a custom
+          # cop whose configuration failed to load) - removing its directive
+          # would destroy something that cannot be restored, so only report.
+          # A misplaced EOL `disable-next` should be moved, not deleted.
+          message = message(cop_names, enabling: directive.enable_next?)
+          if any_unknown_cop?(cops) || misplaced_next_directive?(comment)
+            return add_offense(location, message: message)
+          end
 
-            if leave_free_comment?(comment, range)
-              corrector.replace(range, ' # ')
-            else
-              corrector.remove(range)
-            end
+          add_offense(location, message: message) do |corrector|
+            remove_entire_comment(corrector, comment)
+          end
+        end
+
+        def remove_entire_comment(corrector, comment)
+          # Take the `--` reason with the directive; `leave_free_comment?` keeps anything else.
+          directive_range = DirectiveComment.new(comment).range_with_reason
+          range = comment_range_with_surrounding_space(directive_range, comment.source_range)
+
+          if leave_free_comment?(comment, range)
+            corrector.replace(range, ' # ')
+          else
+            corrector.remove(range)
           end
         end
 
@@ -261,14 +328,35 @@ module RuboCop
           ranges = cop_ranges.map { |_, r| r }
 
           cop_ranges.each do |cop, range|
-            cop_name = describe(cop)
-            add_offense(range, message: message(cop_name)) do |corrector|
-              range = directive_range_in_list(range, ranges)
-              corrector.remove(range)
-            end
+            add_offense_for_cop_in_list(cop, range, ranges)
+          end
+        end
+
+        def add_offense_for_cop_in_list(cop, range, ranges)
+          cop_name = describe(cop)
+          return add_offense(range, message: message(cop_name)) if unknown_cop?(cop)
+
+          add_offense(range, message: message(cop_name)) do |corrector|
+            corrector.remove(directive_range_in_list(range, ranges))
           end
         end
 
+        def any_unknown_cop?(cops)
+          cops.any? { |cop| unknown_cop?(cop) }
+        end
+
+        def misplaced_next_directive?(comment)
+          directive = DirectiveComment.new(comment)
+          (directive.disable_next? || directive.next? || directive.enable_next?) &&
+            !processed_source.comment_config.comment_only_line?(directive.line_number)
+        end
+
+        def unknown_cop?(cop)
+          return false if cop == 'all' || department_marker?(cop)
+
+          !all_cop_names.include?(cop)
+        end
+
         def leave_free_comment?(comment, range)
           free_comment = comment.text.gsub(range.source.strip, '')
 
@@ -303,7 +391,13 @@ module RuboCop
 
         SIMILAR_COP_NAMES_CACHE = Hash.new do |hash, cop_name|
           hash[:all_cop_names] = Registry.global.names unless hash.key?(:all_cop_names)
-          hash[cop_name] = NameSimilarity.find_similar_name(cop_name, hash[:all_cop_names])
+          # A registered cop with the same base name is a better suggestion
+          # than anything spelling similarity can find - the most common
+          # mistake is qualifying a cop with the wrong department.
+          basename = "/#{cop_name.split('/').last}"
+          same_basename = hash[:all_cop_names].find { |name| name.end_with?(basename) }
+          hash[cop_name] =
+            same_basename || NameSimilarity.find_similar_name(cop_name, hash[:all_cop_names])
         end
         private_constant :SIMILAR_COP_NAMES_CACHE
 
@@ -316,8 +410,8 @@ module RuboCop
           similar ? "`#{cop}` (did you mean `#{similar}`?)" : "`#{cop}` (unknown cop)"
         end
 
-        def message(cop_names)
-          "Unnecessary disabling of #{cop_names}."
+        def message(cop_names, enabling: false)
+          "Unnecessary #{enabling ? 'enabling' : 'disabling'} of #{cop_names}."
         end
 
         def all_cop_names
@@ -344,4 +438,3 @@ module RuboCop
     end
   end
 end
-# rubocop:enable Lint/RedundantCopDisableDirective

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

@@ -30,21 +30,55 @@ module RuboCop
       #   foo = "1"
       #   # rubocop:enable all
       #   baz
+      #
+      #   # bad
+      #   foo = 1
+      #   # rubocop:pop
+      #
+      #   # good
+      #   # rubocop:push -Style/StringLiterals
+      #   foo = "1"
+      #   # rubocop:pop
       class RedundantCopEnableDirective < Base
         include RangeHelp
         include SurroundingSpace
         extend AutoCorrector
 
         MSG = 'Unnecessary enabling of %<cop>s.'
+        MSG_ORPHAN_POP = 'Unnecessary `rubocop:pop` without a matching `rubocop:push`.'
 
         def on_new_investigation
-          return if processed_source.blank? || !processed_source.raw_source.include?('enable')
+          return if processed_source.blank?
 
+          source = processed_source.raw_source
+          check_extra_enables if source.include?('enable')
+          check_orphan_pops if source.include?('pop')
+        end
+
+        private
+
+        def check_extra_enables
           offenses = processed_source.comment_config.extra_enabled_comments
           offenses.each { |comment, cop_names| register_offense(comment, cop_names) }
         end
 
-        private
+        def check_orphan_pops
+          push_depth = 0
+          processed_source.comments.each do |comment|
+            directive = DirectiveComment.new(comment)
+            if directive.push?
+              push_depth += 1
+            elsif directive.pop?
+              push_depth.zero? ? register_orphan_pop(directive) : push_depth -= 1
+            end
+          end
+        end
+
+        def register_orphan_pop(directive)
+          add_offense(directive.range, message: MSG_ORPHAN_POP) do |corrector|
+            corrector.remove(range_with_surrounding_space(directive.range, side: :right))
+          end
+        end
 
         def register_offense(comment, cop_names)
           directive = DirectiveComment.new(comment)
@@ -55,15 +89,21 @@ module RuboCop
               range_of_offense(comment, name),
               message: format(MSG, cop: all_or_name(name))
             ) do |corrector|
-              if directive.match?(cop_names)
-                corrector.remove(range_with_surrounding_space(directive.range, side: :right))
-              else
-                corrector.remove(range_with_comma(comment, name))
-              end
+              corrector.remove(removal_range(directive, comment, cop_names, name))
             end
           end
         end
 
+        # When every cop on the directive is redundant the whole comment goes, `--` reason
+        # included; otherwise just the one cop is spliced out of the list.
+        def removal_range(directive, comment, cop_names, name)
+          if directive.match?(cop_names)
+            range_with_surrounding_space(directive.range_with_reason, side: :right)
+          else
+            range_with_comma(comment, name)
+          end
+        end
+
         def range_of_offense(comment, name)
           start_pos = comment_start(comment) + cop_name_indention(comment, name)
           range_between(start_pos, start_pos + name.size)

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

@@ -63,7 +63,7 @@ module RuboCop
 
         private
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def redundant_feature?(feature_name)
           feature_name == 'enumerator' ||
             (target_ruby_version >= 2.1 && feature_name == 'thread') ||
@@ -73,7 +73,6 @@ module RuboCop
             (target_ruby_version >= 3.2 && feature_name == 'set') ||
             (target_ruby_version >= 4.0 && feature_name == 'pathname')
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       end
     end
   end

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

@@ -208,7 +208,7 @@ module RuboCop
           add_offense(range) { |corrector| corrector.replace(range, '.') }
         end
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def on_or(node)
           conversion_with_default?(node) do |send_node|
             range = send_node.loc.dot.begin.join(node.source_range.end)
@@ -221,7 +221,6 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         private
 

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

@@ -139,7 +139,7 @@ module RuboCop
           grandparent.array_type? && grandparent.children.size > 1
         end
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def replacement_range_and_content(node)
           variable = node.children.first
           expression = node.source_range
@@ -157,7 +157,6 @@ module RuboCop
             [node.loc.operator, '']
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         def array_splat?(node)
           node.children.first.array_type?

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

@@ -192,7 +192,7 @@ module RuboCop
           (hash (pair (sym :exception) false))
         PATTERN
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity
         def on_send(node)
           return if node.arguments.any? || hash_or_set_with_block?(node)
 
@@ -208,7 +208,6 @@ module RuboCop
             corrector.remove(node.loc.dot.join(node.loc.end || node.loc.selector))
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
         alias on_csend on_send
 
         private

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

@@ -33,7 +33,7 @@ module RuboCop
         MSG_EACH_WITH_INDEX = 'Use `each` instead of `each_with_index`.'
         MSG_WITH_INDEX = 'Remove redundant `with_index`.'
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def on_block(node)
           return unless node.receiver
           return if node.method?(:with_index) && !node.receiver.receiver
@@ -50,7 +50,6 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         alias on_numblock on_block
         alias on_itblock on_block

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

@@ -45,7 +45,7 @@ module RuboCop
           }
         PATTERN
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def on_send(node)
           return unless require_safe_navigation?(node)
 
@@ -63,7 +63,6 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         private
 

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

@@ -85,7 +85,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def find_consistent_parts(grouped_operands)
           csend_in_and, csend_in_or, send_in_and, send_in_or = most_left_indices(grouped_operands)
 
@@ -99,7 +99,6 @@ module RuboCop
             ['.', csend_in_or]
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def already_appropriate_call?(operand, dot_op)
           return true if operand.safe_navigation? && dot_op == '&.'
@@ -126,7 +125,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def most_left_indices(grouped_operands)
           indices = { csend_in_and: nil, csend_in_or: nil, send_in_and: nil, send_in_or: nil }
 
@@ -139,7 +138,6 @@ module RuboCop
 
           indices.values
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def operand_in_and?(node)
           return true if node.parent.and_type?

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

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for `super` calls with explicit arguments that pass the wrong
+      # number of positional arguments to the overridden implementation, using
+      # the project index.
+      #
+      # The check is powered by the project-wide index, so it only runs when
+      # `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is installed.
+      # Without the index the cop does nothing.
+      #
+      # Only `super` inside a plain instance method defined directly in a class
+      # body is considered, and only when the enclosing class resolves in the
+      # index and its entire ancestry is resolved, so a superclass method coming
+      # from a gem, the standard library, or a dynamic definition never produces
+      # an offense. The overridden implementation is the first ancestor after
+      # the enclosing class in the index's method resolution order that defines
+      # the method; when it is not a plain method definition (an `attr_*` or an
+      # alias) or its definitions disagree on arity, the call is not checked.
+      # Calls that forward arguments (`*`, `**`, `...`) are skipped, and bare
+      # `super` (which forwards the current method's parameters) is not checked.
+      # Methods the index attributes to `Object`, `Kernel`, or `BasicObject`
+      # are never used as the overridden implementation, since a `def` inside
+      # a block at the top level (`Struct.new do ... end`) is indexed under
+      # `Object` even though it defines a method somewhere else entirely.
+      #
+      # @example
+      #   # Given the project defines:
+      #   #   class Base
+      #   #     def initialize(name, size); end
+      #   #   end
+      #
+      #   # bad
+      #   class Widget < Base
+      #     def initialize(name)
+      #       super(name)
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Widget < Base
+      #     def initialize(name)
+      #       super(name, 0)
+      #     end
+      #   end
+      #
+      class SuperArgumentMismatch < Base
+        include ProjectIndexHelp
+        include IndexedMethodArity
+
+        MSG = 'Wrong number of arguments to `super` ' \
+              '(given %<given>d, expected %<expected>s for `%<parent>s#%<method>s`).'
+
+        # Blocks that change what method (or scope) `super` refers to, or in
+        # which `super` is not statically resolvable.
+        CONTEXT_CHANGING_BLOCKS = %i[
+          define_method define_singleton_method class_eval class_exec
+          module_eval module_exec instance_eval instance_exec refine
+        ].freeze
+
+        # Methods the index attributes to the root namespaces are not
+        # trustworthy super targets: a `def` inside a block at the top level
+        # (`Struct.new do ... end`, `Class.new do ... end`) is indexed under
+        # `Object` even though it defines a method somewhere else entirely.
+        BUILTIN_ROOTS = %w[Object Kernel BasicObject].freeze
+
+        def on_super(node)
+          return unless project_index
+
+          def_node = enclosing_instance_method(node)
+          return unless def_node
+
+          shape, parent = resolved_super_shape(def_node)
+          return unless shape
+
+          min, max, has_keywords = shape
+          given = positional_argument_count(node, has_keywords)
+          return if given.nil? || arity_satisfied?(given, min, max)
+
+          add_offense(node.loc.keyword,
+                      message: message(def_node.method_name, parent, given, min, max))
+        end
+
+        private
+
+        def message(method_name, parent, given, min, max)
+          format(MSG, given: given, expected: expected_range(min, max),
+                      parent: parent.name, method: method_name)
+        end
+
+        # The `def` node whose method the `super` call re-dispatches, or nil
+        # when the context is not statically known: `super` inside a
+        # singleton method, inside `define_method` or an eval/refine block,
+        # or outside any method.
+        def enclosing_instance_method(node)
+          node.each_ancestor(:any_def, :any_block, :sclass).each do |ancestor|
+            case ancestor.type
+            when :def then return ancestor
+            when :defs, :sclass then return nil
+            else
+              return nil if CONTEXT_CHANGING_BLOCKS.include?(ancestor.method_name)
+            end
+          end
+
+          nil
+        end
+
+        # `[[min, max, has_keywords], parent]` for the implementation `super`
+        # dispatches to, or nil when the enclosing class or the overridden
+        # method is not statically known.
+        def resolved_super_shape(def_node)
+          declaration = enclosing_class_declaration(def_node)
+          return nil unless declaration
+          return nil unless fully_resolved_index_ancestry?(declaration, ignore_extend: true)
+
+          super_method_shape(declaration, def_node.method_name)
+        rescue StandardError
+          nil
+        end
+
+        # The index declaration of the class whose body directly contains
+        # `def_node`, or nil when the method is not defined directly in a
+        # class body (module methods are excluded because their `super`
+        # target depends on where the module is mixed in) or the class does
+        # not resolve in the index.
+        def enclosing_class_declaration(def_node)
+          class_node = def_node.each_ancestor(:class, :module, :sclass, :any_block).first
+          return nil unless class_node&.class_type?
+
+          declaration = project_index[lexical_nesting_of(def_node).join('::')]
+          return nil unless declaration.is_a?(Rubydex::Namespace)
+          return nil unless declared_at?(declaration, class_node)
+
+          declaration
+        end
+
+        # Whether one of the declaration's definitions is the given class
+        # node, anchoring the name-based lookup to the source being
+        # inspected (a qualified identifier like `class Foo::Bar` can
+        # resolve to a namespace other than the joined nesting names).
+        def declared_at?(declaration, class_node)
+          declaration.definitions.any? do |definition|
+            location = definition.location
+            location.uri.start_with?(FILE_URI_PREFIX) &&
+              location.to_display.start_line == class_node.first_line &&
+              same_file?(location.to_file_path, processed_source.file_path)
+          end
+        end
+
+        # The shape of the first implementation of `method_name` after the
+        # enclosing class in the index's method resolution order, or nil
+        # when no indexed ancestor defines it (e.g. it comes from a gem or
+        # the standard library, which are not indexed).
+        def super_method_shape(declaration, method_name)
+          ancestors = declaration.ancestors.to_a
+          position = ancestors.index { |ancestor| ancestor.name == declaration.name }
+          return nil unless position
+
+          ancestors.drop(position + 1).each do |ancestor|
+            return nil if BUILTIN_ROOTS.include?(ancestor.name)
+
+            member = ancestor.member("#{method_name}()")
+            next unless member
+
+            # The first definer along the chain is the receiving
+            # implementation; when its shape is unknown there is nothing
+            # further to check.
+            shape = indexed_member_shape(member)
+            return shape && [shape, ancestor]
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -78,7 +78,7 @@ module RuboCop
 
         minimum_target_ruby_version 2.6
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def on_rescue(node)
           if (method, exception_classes = begin_numeric_constructor_rescue_nil(node.parent))
             return unless expected_exception_classes_only?(exception_classes)
@@ -100,7 +100,6 @@ module RuboCop
             corrector.replace(node, prefer)
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         private