rubocop 1.88.2 → 1.89.0

data/lib/rubocop/cop/registry.rb

@@ -50,21 +50,37 @@ module RuboCop
 
       def initialize(cops = [], options = {})
         @departments = Set.new
+        # Maps each badge to its cop class, or to the fully qualified constant name (a `String`)
+        # when the cop is registered for lazy loading and its file is not loaded yet.
+        # A single insertion-ordered map keeps the registration order stable no matter when
+        # a lazy-loaded cop's file gets loaded, because reassigning an existing key preserves
+        # its position; the cop execution order depends on this order.
         @cops_by_badge = {}
-        @lazy_loaded_cops_by_badge = {}
 
         @enrollment_queue = cops
         @options = options
 
         @enabled_cache = {}.compare_by_identity
         @disabled_cache = {}.compare_by_identity
+        @disabled_names_cache = {}.compare_by_identity
         @warnings = {}
       end
 
-      def lazy_load(cop_name, constant_name)
-        badge = Badge.parse(cop_name)
+      # Registers a cop by its badge and constant name without loading the class.
+      # The constant is resolved (loading the cop's file through `autoload`) only
+      # when the cop class itself is needed.
+      #
+      # @param badge [Badge, String] the badge, or the qualified cop name
+      # @param constant_name [String] the fully qualified constant name
+      def lazy_load(badge, constant_name)
+        badge = Badge.parse(badge) if badge.is_a?(String)
+
+        # File any cops enlisted earlier first, so that the registration
+        # order follows the call order.
+        clear_enrollment_queue
+
         @departments << badge.department
-        @lazy_loaded_cops_by_badge[badge] = constant_name
+        @cops_by_badge[badge] = constant_name unless @cops_by_badge[badge].is_a?(Class)
       end
 
       def enlist(cop)
@@ -72,7 +88,16 @@ module RuboCop
       end
 
       def dismiss(cop)
-        raise "Cop #{cop} could not be dismissed" unless @enrollment_queue.delete(cop)
+        dismissed = !@enrollment_queue.delete(cop).nil?
+
+        # A lazy-loaded cop that was not enlisted yet is dismissed by removing its registration.
+        # Anonymous cop classes cannot have a badge.
+        if !cop.name.nil? && @cops_by_badge[cop.badge].is_a?(String)
+          @cops_by_badge.delete(cop.badge)
+          dismissed = true
+        end
+
+        raise "Cop #{cop} could not be dismissed" unless dismissed
       end
 
       # @return [Array<Symbol>] list of departments for current cops.
@@ -83,12 +108,26 @@ module RuboCop
 
       # @return [Registry] Cops for that specific department.
       def with_department(department)
-        with(cops.select { |cop| cop.department == department })
+        filter_by_badge { |badge| badge.department == department }
       end
 
       # @return [Registry] Cops not for a specific department.
       def without_department(department)
-        with(cops.reject { |cop| cop.department == department })
+        filter_by_badge { |badge| badge.department != department }
+      end
+
+      # Returns a new registry containing the cops whose badge satisfies the given block,
+      # keeping lazy-loaded cops unloaded.
+      #
+      # @api private
+      # @return [Registry]
+      def filter_by_badge(options = {})
+        clear_enrollment_queue
+        copy = self.class.new([], options)
+        @cops_by_badge.each do |badge, cop_or_name|
+          copy.add_entry(badge, cop_or_name) if yield(badge)
+        end
+        copy
       end
 
       # @return [Boolean] Checks if given name is department
@@ -97,7 +136,7 @@ module RuboCop
       end
 
       def contains_cop_matching?(names)
-        cops.any? { |cop| cop.match?(names) }
+        registered_badges.any? { |badge| badge.match_name?(names) }
       end
 
       # Convert a user provided cop name into a properly namespaced name
@@ -160,9 +199,10 @@ module RuboCop
 
       def unqualified_cop_names
         clear_enrollment_queue
-        @unqualified_cop_names ||=
-          (@cops_by_badge.keys | @lazy_loaded_cops_by_badge.keys)
-          .to_set { |badge| File.basename(badge.to_s) } << 'RedundantCopDisableDirective'
+
+        @unqualified_cop_names ||= @cops_by_badge.keys.to_set do |badge|
+          File.basename(badge.to_s)
+        end << 'RedundantCopDisableDirective'
       end
 
       def qualify_badge(badge)
@@ -187,51 +227,64 @@ module RuboCop
 
       def length
         clear_enrollment_queue
-        @cops_by_badge.size + @lazy_loaded_cops_by_badge.size
+        @cops_by_badge.size
       end
 
+      # Returns the enabled cop classes, loading lazy-loaded cops only when they are enabled.
+      #
+      # @return [Array<Class>]
       def enabled(config)
-        @enabled_cache[config] ||= select { |cop| enabled?(cop, config) }
+        @enabled_cache[config] ||= registered_badges.filter_map do |badge|
+          next unless enabled_cop_name?(badge.to_s, config)
+
+          cop_or_name = @cops_by_badge[badge]
+          cop_or_name.is_a?(String) ? load_lazy_cop(badge) : cop_or_name
+        end
       end
 
       def disabled(config)
         @disabled_cache[config] ||= reject { |cop| enabled?(cop, config) }
       end
 
-      def enabled?(cop, config)
-        return true if options[:only]&.include?(cop.cop_name)
-
-        # We need to use `cop_name` in this case, because `for_cop` uses caching
-        # which expects cop names or cop classes as keys.
-        cfg = config.for_cop(cop.cop_name)
-
-        cop_enabled = cfg.fetch('Enabled') == true || enabled_pending_cop?(cfg, config)
-
-        if options.fetch(:safe, false)
-          cop_enabled && cfg.fetch('Safe', true)
-        else
-          cop_enabled
+      # Returns the names of the disabled cops without loading any of them.
+      #
+      # @api private
+      # @return [Array<String>]
+      def disabled_names(config)
+        @disabled_names_cache[config] ||= registered_badges.filter_map do |badge|
+          name = badge.to_s
+          name unless enabled_cop_name?(name, config)
         end
       end
 
-      def enabled_pending_cop?(cop_cfg, config)
+      def enabled?(cop, config)
+        enabled_cop_name?(cop.cop_name, config)
+      end
+
+      # @param cop [Class, String, nil] the cop class or the qualified cop name
+      def enabled_pending_cop?(cop_cfg, config, cop = nil)
         return false if @options[:disable_pending_cops]
+        return false unless cop_cfg.fetch('Enabled') == 'pending'
+        return true if @options[:enable_pending_cops]
+        return config.enabled_new_cops? unless cop
 
-        cop_cfg.fetch('Enabled') == 'pending' &&
-          (@options[:enable_pending_cops] || config.enabled_new_cops?)
+        cop_name = cop.is_a?(String) ? cop : cop.cop_name
+        config.enabled_new_cop?(cop_name)
       end
 
       def names
         clear_enrollment_queue
-        @cops_by_badge.keys.map(&:to_s) | @lazy_loaded_cops_by_badge.keys.map(&:to_s)
+        @cops_by_badge.keys.map(&:to_s)
       end
 
       def cops_for_department(department)
-        cops.select { |cop| cop.department == department.to_sym }
+        with_department(department.to_sym).cops
       end
 
       def names_for_department(department)
-        cops_for_department(department).map(&:cop_name)
+        department = department.to_sym
+
+        registered_badges.filter_map { |badge| badge.to_s if badge.department == department }
       end
 
       def ==(other)
@@ -259,7 +312,9 @@ module RuboCop
       def find_by_cop_name(cop_name)
         clear_enrollment_queue
         badge = Badge.parse(cop_name)
-        @cops_by_badge[badge] || load_lazy_cop(badge)
+        cop_or_name = @cops_by_badge[badge]
+
+        cop_or_name.is_a?(String) ? load_lazy_cop(badge) : cop_or_name
       end
 
       # When a cop name is given returns a single-element array with the cop class.
@@ -287,35 +342,90 @@ module RuboCop
         @warnings[path]
       end
 
+      protected
+
+      # Adds an already-loaded cop class or a lazy-load constant name under the given badge,
+      # used to build filtered copies.
+      def add_entry(badge, cop_or_name)
+        @departments << badge.department
+        @cops_by_badge[badge] = cop_or_name
+      end
+
       private
 
       def initialize_copy(reg)
-        initialize(reg.cops, reg.options)
+        super
+        @cops_by_badge = @cops_by_badge.dup
+        @enrollment_queue = @enrollment_queue.dup
+        @departments = @departments.dup
+        @enabled_cache = {}.compare_by_identity
+        @disabled_cache = {}.compare_by_identity
+        @disabled_names_cache = {}.compare_by_identity
+        @warnings = {}
+        @unqualified_cop_names = nil
       end
 
       def clear_enrollment_queue
         return if @enrollment_queue.empty?
 
         @enrollment_queue.each do |cop|
+          # Reassigning a badge that was registered for lazy loading keeps
+          # its original position in the insertion-ordered map.
           @cops_by_badge[cop.badge] = cop
           @departments << cop.department
         end
         @enrollment_queue = []
       end
 
-      def load_all_lazy_cops
-        @lazy_loaded_cops_by_badge.each_key { |badge| load_lazy_cop(badge) }
+      def registered_badges
+        clear_enrollment_queue
+        @cops_by_badge.keys
       end
 
-      def load_lazy_cop(badge)
-        constant_name = @lazy_loaded_cops_by_badge.delete(badge)
-        return unless constant_name
+      def enabled_cop_name?(cop_name, config)
+        return true if options[:only]&.include?(cop_name)
 
-        @cops_by_badge[badge] = Kernel.const_get(constant_name)
+        # We need to use the cop name in this case, because `for_cop` uses
+        # caching which expects cop names or cop classes as keys.
+        cfg = config.for_cop(cop_name)
+
+        cop_enabled = cfg.fetch('Enabled') == true || enabled_pending_cop?(cfg, config, cop_name)
+
+        if options.fetch(:safe, false)
+          cop_enabled && cfg.fetch('Safe', true)
+        else
+          cop_enabled
+        end
       end
 
-      def with(cops)
-        self.class.new(cops)
+      def load_all_lazy_cops
+        # Take a snapshot because loading a cop can load (and thereby register)
+        # another lazy-loaded cop, e.g. its superclass.
+        badges = @cops_by_badge.keys
+        badges.each { |badge| load_lazy_cop(badge) if @cops_by_badge[badge].is_a?(String) }
+      end
+
+      # @return [Class, nil] the loaded cop class, or nil if the cop excluded
+      #   itself from the registry while being loaded
+      def load_lazy_cop(badge)
+        constant_name = @cops_by_badge[badge]
+        return constant_name unless constant_name.is_a?(String)
+
+        cop = Kernel.const_get(constant_name)
+        if equal?(self.class.global)
+          # Resolving the constant fires the autoload, which makes
+          # `Base.inherited` enlist the class into the global registry.
+          # Enrolling through the queue keeps `exclude_from_registry` honored:
+          # a cop that dismissed itself leaves a dangling constant name behind
+          # and is removed from the registry.
+          clear_enrollment_queue
+          cop_or_name = @cops_by_badge[badge]
+          @cops_by_badge.delete(badge) if cop_or_name.is_a?(String)
+          cop_or_name.is_a?(Class) ? cop_or_name : nil
+        else
+          # `Base.inherited` enlists into the global registry, not this copy.
+          @cops_by_badge[badge] = cop
+        end
       end
 
       def resolve_badge(given_badge, real_badge, source_path, warn: true)
@@ -335,7 +445,7 @@ module RuboCop
 
       def registered?(badge)
         clear_enrollment_queue
-        @cops_by_badge.key?(badge) || @lazy_loaded_cops_by_badge.key?(badge)
+        @cops_by_badge.key?(badge)
       end
     end
   end

data/lib/rubocop/cop/security.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Cops for the `Security` department. The department's cops are registered for lazy loading
+    # and their files are loaded on demand.
+    module Security
+      extend LazyLoader
+
+      register_cop :CompoundHash, "#{__dir__}/security/compound_hash"
+      register_cop :Eval, "#{__dir__}/security/eval"
+      register_cop :IoMethods, "#{__dir__}/security/io_methods"
+      register_cop :JSONLoad, "#{__dir__}/security/json_load"
+      register_cop :MarshalLoad, "#{__dir__}/security/marshal_load"
+      register_cop :Open, "#{__dir__}/security/open"
+      register_cop :YAMLLoad, "#{__dir__}/security/yaml_load"
+    end
+  end
+end

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

@@ -30,6 +30,11 @@ module RuboCop
       # only cases where exactly one argument is provided can be replaced with
       # `Array#intersect?` and are handled by this cop.
       #
+      # NOTE: In the block form, `include?` is only detected when its receiver is
+      # an array literal, because `include?` is defined with different semantics
+      # on many non-array classes (e.g. `String#include?` checks for substrings).
+      # `member?` does not have this restriction.
+      #
       # @safety
       #   This cop cannot guarantee that `array1` and `array2` are
       #   actually arrays while method `intersect?` is for arrays only.
@@ -47,7 +52,7 @@ module RuboCop
       #
       #   # bad
       #   array1.any? { |elem| array2.member?(elem) }
-      #   array1.none? { |elem| array2.include?(elem) }
+      #   array1.none? { |elem| [1, 2].include?(elem) }
       #
       #   # good
       #   array1.intersect?(array2)
@@ -121,15 +126,15 @@ module RuboCop
             (block
               (call $_receiver ${:any? :none?})
               (args (arg _key))
-              (send $_argument {:member? :include?} (lvar _key))
+              (send $!nil? ${:member? :include?} (lvar _key))
             )
             (numblock
               (call $_receiver ${:any? :none?}) 1
-              (send $_argument {:member? :include?} (lvar :_1))
+              (send $!nil? ${:member? :include?} (lvar :_1))
             )
             (itblock
               (call $_receiver ${:any? :none?}) :it
-              (send $_argument {:member? :include?} (lvar :it))
+              (send $!nil? ${:member? :include?} (lvar :it))
             )
           }
         PATTERN
@@ -156,7 +161,10 @@ module RuboCop
         alias on_csend on_send
 
         def on_block(node)
-          return unless (receiver, method_name, argument = any_none_block_intersection(node))
+          return unless (captures = any_none_block_intersection(node))
+
+          receiver, method_name, argument, block_method = captures
+          return if uncorrectable_block_intersection?(node, method_name, argument, block_method)
 
           dot = node.send_node.loc.dot.source
           bang = method_name == :any? ? '' : '!'
@@ -186,6 +194,17 @@ module RuboCop
           STRAIGHT_METHODS.include?(method_name.to_sym)
         end
 
+        def uncorrectable_block_intersection?(node, method_name, argument, block_method)
+          # `a&.none? { |elem| b.include?(elem) }` returns `nil` when `a` is `nil`,
+          # but the negated rewrite `!a&.intersect?(b)` returns `true` there, flipping the result.
+          return true if method_name == :none? && node.send_node.safe_navigation?
+
+          # `include?` is defined with different semantics on many non-array classes
+          # (e.g. `String#include?` checks for substrings), so it is only a reliable
+          # signal of an intersection check when the receiver is an array literal.
+          block_method == :include? && !argument.array_type?
+        end
+
         def register_offense(node, replacement)
           message = format(MSG, replacement: replacement, existing: node.source)
 

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

@@ -23,10 +23,15 @@ module RuboCop
       #
       #   Moving from `compact` to `nested` children requires knowledge of whether the
       #   outer parent is a module or a class. Moving from `nested` to `compact` requires
-      #   verification that the outer parent is defined elsewhere. RuboCop does not
-      #   have the knowledge to perform either operation safely and thus requires
+      #   verification that the outer parent is defined elsewhere. By default RuboCop does
+      #   not have the knowledge to perform either operation safely and thus requires
       #   manual oversight.
       #
+      #   When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is installed,
+      #   the project-wide index is consulted to resolve whether the outer parent is a
+      #   class or a module, and compacting is skipped when the outer parent is not
+      #   defined elsewhere.
+      #
       # @example EnforcedStyle: nested (default)
       #   # bad
       #   class Foo::Bar
@@ -53,6 +58,7 @@ module RuboCop
       class ClassAndModuleChildren < Base
         include Alignment
         include ConfigurableEnforcedStyle
+        include ProjectIndexHelp
         include RangeHelp
         extend AutoCorrector
 
@@ -60,7 +66,7 @@ module RuboCop
         COMPACT_MSG = 'Use compact module/class definition instead of nested style.'
 
         def on_class(node)
-          return if node.parent_class && style != :nested
+          return if node.parent_class && style_for_classes != :nested
 
           check_style(node, node.body, style_for_classes)
         end
@@ -72,7 +78,7 @@ module RuboCop
         private
 
         def nest_or_compact(corrector, node)
-          style = node.class_type? ? style_for_classes : style_for_modules
+          style = style_for_kind(node.type)
 
           if style == :nested
             nest_definition(corrector, node)
@@ -82,21 +88,40 @@ module RuboCop
         end
 
         def nest_definition(corrector, node)
+          keyword = namespace_keyword(node)
+          # A namespace wrapper whose style resolves to `compact` would itself violate
+          # that style, making autocorrection ping-pong between the two forms.
+          return if style_for_kind(keyword.to_sym) == :compact
+
           padding = indentation(node) + leading_spaces(node)
           padding_for_trailing_end = padding.sub(' ' * node.loc.end.column, '')
 
-          replace_namespace_keyword(corrector, node)
+          corrector.replace(node.loc.keyword, keyword)
           split_on_double_colon(corrector, node, padding)
           add_trailing_end(corrector, node, padding_for_trailing_end)
         end
 
-        def replace_namespace_keyword(corrector, node)
+        def namespace_keyword(node)
+          indexed_namespace_keyword(node) || heuristic_namespace_keyword(node)
+        end
+
+        def indexed_namespace_keyword(node)
+          return nil unless project_index
+
+          declaration = resolve_constant_in_index(node.identifier.namespace)
+
+          case declaration
+          when Rubydex::Class then 'class'
+          when Rubydex::Module then 'module'
+          end
+        end
+
+        def heuristic_namespace_keyword(node)
           class_definition = node.left_sibling&.each_node(:class)&.find do |class_node|
             class_node.identifier == node.identifier.namespace
           end
-          namespace_keyword = class_definition ? 'class' : 'module'
 
-          corrector.replace(node.loc.keyword, namespace_keyword)
+          class_definition ? 'class' : 'module'
         end
 
         def split_on_double_colon(corrector, node, padding)
@@ -114,11 +139,41 @@ module RuboCop
         end
 
         def compact_definition(corrector, node)
+          # Compacting produces a definition whose type's style resolves to `nested`,
+          # making autocorrection ping-pong between the two forms.
+          return if style_for_kind(node.body.type) == :nested
+          return unless compactible_namespace?(node)
+
           compact_node(corrector, node)
           remove_end(corrector, node.body)
           unindent(corrector, node)
         end
 
+        # Compacting removes this definition of the namespace, so the result raises
+        # `NameError` at load time unless the namespace is also defined somewhere else.
+        # With the project index this is verified before correcting; without it the
+        # correction is performed regardless (the cop's autocorrection is unsafe).
+        def compactible_namespace?(node)
+          return true unless project_index
+
+          declaration = resolve_constant_in_index(node.identifier)
+          return false unless declaration.is_a?(Rubydex::Namespace)
+
+          declaration.definitions.any? { |definition| definition_elsewhere?(definition, node) }
+        end
+
+        def definition_elsewhere?(definition, node)
+          location = definition.location
+          return true unless location.uri.start_with?(FILE_URI_PREFIX)
+
+          !same_file?(location.to_file_path, processed_source.file_path) ||
+            location.to_display.start_line != node.first_line
+        rescue StandardError
+          # A path that cannot be converted or compared cannot prove the
+          # namespace is defined elsewhere; err on not correcting.
+          false
+        end
+
         def compact_node(corrector, node)
           range = range_between(node.loc.keyword.begin_pos, node.body.loc.name.end_pos)
           corrector.replace(range, compact_replacement(node))
@@ -162,23 +217,24 @@ module RuboCop
           column_delta = configured_indentation_width - spaces_size(last_child_leading_spaces)
           return if column_delta.zero?
 
-          AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
+          AlignmentCorrector.correct(
+            corrector, processed_source, node, column_delta, tab_indentation: true
+          )
         end
 
         def leading_spaces(node)
           node.source_range.source_line[/\A\s*/]
         end
 
+        # A tab counts as `configured_indentation_width` columns, matching the
+        # width `AlignmentCorrector` uses to convert `column_delta` back into
+        # tabs. Using `Layout/IndentationStyle`'s own `IndentationWidth` here
+        # would make the delta and the correction disagree.
         def spaces_size(spaces_string)
-          mapping = { "\t" => tab_indentation_width }
+          mapping = { "\t" => configured_indentation_width }
           spaces_string.chars.sum { |character| mapping.fetch(character, 1) }
         end
 
-        def tab_indentation_width
-          config.for_cop('Layout/IndentationStyle')['IndentationWidth'] ||
-            configured_indentation_width
-        end
-
         def check_style(node, body, style)
           return if node.identifier.namespace&.cbase_type?
           return unless const_namespace?(node.identifier.namespace)
@@ -218,7 +274,7 @@ module RuboCop
         end
 
         def autocorrect(corrector, node)
-          return if node.class_type? && node.parent_class && style != :nested
+          return if node.class_type? && node.parent_class && style_for_classes != :nested
 
           nest_or_compact(corrector, node)
         end
@@ -231,12 +287,16 @@ module RuboCop
           node.identifier.source.include?('::')
         end
 
+        def style_for_kind(kind)
+          kind == :class ? style_for_classes : style_for_modules
+        end
+
         def style_for_classes
-          cop_config['EnforcedStyleForClasses'] || style
+          cop_config['EnforcedStyleForClasses']&.to_sym || style
         end
 
         def style_for_modules
-          cop_config['EnforcedStyleForModules'] || style
+          cop_config['EnforcedStyleForModules']&.to_sym || style
         end
       end
     end

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

@@ -203,6 +203,7 @@ module RuboCop
       class ConditionalAssignment < Base
         include ConditionalAssignmentHelper
         include ConfigurableEnforcedStyle
+        include ReparsedEquivalence
         extend AutoCorrector
 
         MSG = 'Use the return of the conditional for variable assignment and comparison.'
@@ -288,6 +289,7 @@ module RuboCop
           # else slot, but `else_branch` correctly reports there is no `else` clause.
           return unless assignment.else_branch
           return if allowed_single_line?([*branches, else_branch])
+          return unless safe_to_correct?(node)
 
           add_offense(node, message: ASSIGN_TO_CONDITION_MSG) do |corrector|
             autocorrect(corrector, node)
@@ -367,6 +369,7 @@ module RuboCop
           return unless allowed_statements?(branches)
           return if allowed_single_line?(branches)
           return if correction_exceeds_line_limit?(node, branches)
+          return unless safe_to_correct?(node)
 
           add_offense(node) { |corrector| autocorrect(corrector, node) }
         end
@@ -379,6 +382,25 @@ module RuboCop
           end
         end
 
+        # The correction rewrites the conditional structurally, so full AST
+        # equivalence cannot be asserted, but the result must at least reparse
+        # to valid Ruby. Applying the correction to a throwaway buffer here
+        # also exercises the branch-shape handling before an offense is even
+        # reported, so unusual branches that the corrector cannot handle are
+        # left alone instead of crashing or emitting invalid code - the bug
+        # class behind most of this cop's history.
+        def safe_to_correct?(node)
+          correction_parses?(node)
+        rescue StandardError
+          false
+        end
+
+        # `ReparsedEquivalence#correction_parses?` contract: apply the exact
+        # correction this cop would perform.
+        def apply_reparse_correction(corrector, node)
+          autocorrect(corrector, node)
+        end
+
         def allowed_statements?(branches)
           return false unless branches.all?
 

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

@@ -25,20 +25,25 @@ module RuboCop
         MSG = 'Include a copyright notice matching /%<notice>s/ before any code.'
         AUTOCORRECT_EMPTY_WARNING = 'An AutocorrectNotice must be defined in your RuboCop config'
 
+        # rubocop:disable Metrics/AbcSize
         def on_new_investigation
           return if notice.empty? || notice_found?(processed_source)
 
-          verify_autocorrect_notice!
           message = format(MSG, notice: notice)
           if processed_source.blank?
             add_global_offense(message)
           else
             offense_range = source_range(processed_source.buffer, 1, 0)
             add_offense(offense_range, message: message) do |corrector|
+              next unless autocorrect?
+
+              verify_autocorrect_notice!
+
               autocorrect(corrector)
             end
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         private