rubocop 1.88.2 → 1.90.0

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# rubocop:disable Lint/RedundantCopDisableDirective
+# rubocop:disable-next Lint/RedundantCopDisableDirective
 module RuboCop
   module Cop
     module Lint
@@ -55,7 +55,7 @@ module RuboCop
       class MissingCopEnableDirective < Base
         include RangeHelp
 
-        MSG = 'Re-enable %<cop>s %<type>s with `# rubocop:enable` after disabling it.'
+        MSG = 'Re-enable %<cop>s %<type>s with `%<directive>s` after disabling it.'
         MSG_BOUND = 'Re-enable %<cop>s %<type>s within %<max_range>s lines after disabling it.'
 
         def on_new_investigation
@@ -72,7 +72,12 @@ module RuboCop
 
         def each_missing_enable
           processed_source.disabled_line_ranges.each do |cop, line_ranges|
-            line_ranges.each { |line_range| yield cop, line_range }
+            line_ranges.each do |line_range|
+              # A `disable-next` scope closes itself with its statement.
+              next if line_range.respond_to?(:directive) && line_range.directive.disable_next?
+
+              yield cop, line_range
+            end
           end
         end
 
@@ -80,17 +85,22 @@ module RuboCop
           # This has to remain a strict inequality to handle
           # the case when max_range is Float::INFINITY
           return true if line_range.max - line_range.min < max_range + 2
+          # A name that is not registered as written (e.g. a wrongly-namespaced
+          # cop) suppresses nothing; `Lint/RedundantCopDisableDirective` reports
+          # it, so demanding its re-enablement would only add noise.
+          return true unless Registry.global.names.include?(cop)
+
+          expected_open_range?(cop, line_range)
+        end
+
+        def expected_open_range?(cop, line_range)
           # This cop is disabled in the config, it is not expected to be re-enabled
           return true if line_range.min == CommentConfig::CONFIG_DISABLED_LINE_RANGE_MIN
 
-          cop_class = RuboCop::Cop::Registry.global.find_by_cop_name cop
-          if cop_class &&
+          cop_class = RuboCop::Cop::Registry.global.find_by_cop_name(cop)
+          !!(cop_class &&
              !processed_source.registry.enabled?(cop_class, config) &&
-             line_range.max == Float::INFINITY
-            return true
-          end
-
-          false
+             line_range.max == Float::INFINITY)
         end
 
         def max_range
@@ -98,13 +108,17 @@ module RuboCop
         end
 
         def message(cop, comment, type = 'cop')
+          directive = DirectiveComment.new(comment)
           if department_enabled?(cop, comment)
             type = 'department'
             cop = cop.split('/').first
           end
 
           if max_range == Float::INFINITY
-            format(MSG, cop: cop, type: type)
+            # A range opened by `rubocop:push` is closed by `rubocop:pop`,
+            # not by `rubocop:enable`.
+            enabling_directive = directive.push? ? '# rubocop:pop' : '# rubocop:enable'
+            format(MSG, cop: cop, type: type, directive: enabling_directive)
           else
             format(MSG_BOUND, cop: cop, type: type, max_range: max_range)
           end
@@ -117,4 +131,3 @@ module RuboCop
     end
   end
 end
-# rubocop:enable Lint/RedundantCopDisableDirective

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

@@ -21,6 +21,13 @@ module RuboCop
       # `AllowedParentClasses` option to specify which classes should be allowed
       # *in addition to* `Object` and `BasicObject`.
       #
+      # When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is installed,
+      # the constructor check additionally consults the project-wide index: if the
+      # class' entire ancestry is resolvable and no ancestor defines `initialize`,
+      # no offense is registered, since `super` would only reach the no-op
+      # `Object#initialize`. Classes whose ancestry contains an unresolvable
+      # superclass or mixin (e.g. one defined in a gem) are still reported.
+      #
       # @example
       #   # bad
       #   class Employee < Person
@@ -83,6 +90,8 @@ module RuboCop
       #   end
       #
       class MissingSuper < Base
+        include ProjectIndexHelp
+
         CONSTRUCTOR_MSG = 'Call `super` to initialize state of the parent class.'
         CALLBACK_MSG    = 'Call `super` to invoke callback defined in the parent class.'
 
@@ -140,7 +149,8 @@ module RuboCop
 
             !allowed_class?(super_class)
           elsif (class_node = node.each_ancestor(:class).first)
-            class_node.parent_class && !allowed_class?(class_node.parent_class)
+            class_node.parent_class && !allowed_class?(class_node.parent_class) &&
+              !index_verified_stateless_ancestry?(class_node)
           else
             false
           end
@@ -153,6 +163,26 @@ module RuboCop
         def allowed_classes
           @allowed_classes ||= STATELESS_CLASSES + cop_config.fetch('AllowedParentClasses', [])
         end
+
+        # With the project index, the offense is skipped when the class' whole ancestry
+        # is resolvable and none of the inherited ancestors defines `initialize` —
+        # `super` would only reach the no-op `Object#initialize`. An unresolvable
+        # superclass or mixin anywhere in the chain (e.g. a class from a gem) means
+        # the ancestry cannot be verified and the offense is kept.
+        def index_verified_stateless_ancestry?(class_node)
+          return false unless project_index
+
+          declaration = resolve_constant_in_index(class_node.identifier)
+          return false unless declaration.is_a?(Rubydex::Class)
+
+          ancestors = declaration.ancestors.to_a
+          inherited = ancestors.reject { |ancestor| ancestor.name == declaration.name }
+          return false if inherited.any? { |ancestor| ancestor.member('initialize()') }
+
+          # `extend` affects the singleton class and cannot introduce an
+          # inherited `initialize`, so unresolved extends are tolerated.
+          fully_resolved_index_ancestry?(declaration, ignore_extend: true)
+        end
       end
     end
   end

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

@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+
+begin
+  require 'did_you_mean'
+rescue LoadError
+  nil
+end
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for probable typos in constant and method names: a name that
+      # does not resolve anywhere in the project, used in a namespace the
+      # project does define, with a close-named sibling to suggest instead.
+      #
+      # 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.
+      #
+      # Constants are checked only in qualified references (`Foo::Bar`) whose
+      # namespace resolves in the index; bare names cannot be distinguished
+      # from constants provided by gems or the standard library. Methods are
+      # checked only in calls on constant receivers (`Foo.bar`) whose entire
+      # indexed ancestry is resolved, so methods gained through gem classes or
+      # dynamic definitions never produce offenses. In both cases an offense
+      # requires a similarly named alternative to exist — an unknown name
+      # alone is not reported, since the index does not see gems or the
+      # standard library.
+      #
+      # For the same reason, a namespace whose root segment names a gem in the
+      # bundle (`Flipper` for the `flipper` gem) is left alone: a project that
+      # reopens it (`module Flipper; module Adapters; ...`) makes it resolve in
+      # the index, while the members the gem itself defines stay invisible and
+      # would look like typos. Enabling `AllCops/ProjectIndexIncludesGems`
+      # indexes those sources and restores the check.
+      #
+      # Names that appear as symbols or inside string literals in the same
+      # file are never reported, since they usually belong to runtime
+      # definitions the index cannot see (`stub_const`, `const_set`,
+      # `define_method`, and the like).
+      #
+      # @example
+      #   # bad - Services::UserCraetor is not defined, Services::UserCreator is
+      #   Services::UserCraetor.new
+      #
+      #   # good
+      #   Services::UserCreator.new
+      #
+      #   # bad - Report.generate_sumary is not defined, Report.generate_summary is
+      #   Report.generate_sumary
+      #
+      #   # good
+      #   Report.generate_summary
+      #
+      # @example CheckConstants: false
+      #   # good - constant references are not checked
+      #   Services::UserCraetor.new
+      #
+      # @example CheckMethods: false
+      #   # good - method calls are not checked
+      #   Report.generate_sumary
+      #
+      # @example AllowedNames: ['generate_sumary']
+      #   # good - the name is explicitly allowed
+      #   Report.generate_sumary
+      #
+      class NameTypo < Base
+        include ProjectIndexHelp
+
+        CONSTANT_MSG = 'Possible typo: `%<name>s` is not defined in `%<namespace>s`. ' \
+                       'Did you mean `%<suggestion>s`?'
+        METHOD_MSG = 'Possible typo: `%<receiver>s` does not respond to `%<name>s`. ' \
+                     'Did you mean `%<suggestion>s`?'
+
+        METHOD_MEMBER_REGEXP = /#([a-zA-Z_]\w*[?!]?)\(\)\z/.freeze
+        LITERAL_IDENTIFIER_PATTERN = /[a-zA-Z_]\w*[?!]?/.freeze
+
+        def on_const(node)
+          return unless check?('CheckConstants') && checkable_constant?(node)
+
+          suggestion = constant_typo_suggestion(node)
+          return unless suggestion
+
+          message = format(CONSTANT_MSG, name: node.short_name,
+                                         namespace: node.namespace.const_name,
+                                         suggestion: suggestion)
+          add_offense(node.loc.name, message: message)
+        end
+
+        def on_send(node)
+          return unless check?('CheckMethods')
+          return unless node.receiver&.const_type?
+          return if allowed_name?(node.method_name) || defined_check?(node)
+
+          suggestion = method_typo_suggestion(node)
+          return unless suggestion
+
+          message = format(METHOD_MSG, receiver: node.receiver.const_name,
+                                       name: node.method_name,
+                                       suggestion: suggestion)
+          add_offense(node.loc.selector, message: message)
+        end
+        alias on_csend on_send
+
+        def on_new_investigation
+          @literal_names = nil
+          super
+        end
+
+        private
+
+        def check?(key)
+          project_index && defined?(DidYouMean::SpellChecker) && cop_config.fetch(key, true)
+        end
+
+        def checkable_constant?(node)
+          node.namespace&.const_type? &&
+            !allowed_name?(node.short_name) &&
+            !definition_identifier?(node) && !defined_check?(node)
+        end
+
+        def allowed_name?(name)
+          cop_config.fetch('AllowedNames', []).include?(name.to_s)
+        end
+
+        # The last segment of a class, module or constant definition is being
+        # defined, not referenced.
+        def definition_identifier?(node)
+          node.parent&.defined_module
+        end
+
+        # `defined?(Foo::Bar)` probes whether a name exists; unknown names
+        # there are deliberate.
+        def defined_check?(node)
+          node.each_ancestor(:defined?).any?
+        end
+
+        def constant_typo_suggestion(node)
+          namespace = resolve_constant_in_index(node.namespace)
+          return nil unless namespace.is_a?(Rubydex::Namespace)
+          return nil if namespace.find_member(node.short_name.to_s)
+          return nil unless complete_index_members?(namespace)
+          return nil if literal_names.include?(node.short_name.to_s)
+
+          spell_check(node.short_name, constant_member_names(namespace))
+        rescue StandardError
+          nil
+        end
+
+        # Whether the index can be trusted to list everything the namespace
+        # defines. A name missing from an incomplete member list is not
+        # evidence of a typo, so both gaps have to be ruled out first:
+        # an ancestor that does not resolve may contribute the name, and so
+        # may a gem that reopens the namespace.
+        def complete_index_members?(declaration)
+          fully_resolved_index_ancestry?(declaration) && !gem_owned_namespace?(declaration)
+        end
+
+        # Whether the namespace's root segment names a gem in the bundle,
+        # which is then free to define members the index never sees: gem
+        # sources are only indexed when `AllCops/ProjectIndexIncludesGems`
+        # is enabled. A project that reopens such a namespace to add its own
+        # members (`module Flipper; module Adapters; ...`) makes it resolve
+        # in the index while most of what it holds stays invisible.
+        def gem_owned_namespace?(declaration)
+          return false if config.for_all_cops['ProjectIndexIncludesGems']
+
+          root = declaration.name.to_s.split('::').first.to_s
+          bundled_gem_namespaces.include?(root.downcase)
+        end
+
+        # Gem names normalized towards the constant they conventionally
+        # provide: `flipper` for `Flipper`, `activerecord` for `ActiveRecord`.
+        def bundled_gem_namespaces
+          @bundled_gem_namespaces ||= bundled_gem_names.to_set { |name| name.delete('-_').downcase }
+        end
+
+        # The bundle's gems except those sourced from a local path, whose code
+        # lives in the project and is indexed like the rest of it — among them
+        # the project's own gem, which its lockfile lists in the `PATH` section.
+        def bundled_gem_names
+          (config.gem_versions_in_target || {}).keys - (config.path_sourced_gems_in_target || [])
+        end
+
+        # Writers are indexed under the reader's name, so setter calls are
+        # verified and spell-checked through the base name.
+        def method_typo_suggestion(node)
+          setter = setter_call?(node)
+          base = setter ? node.method_name.to_s.delete_suffix('=') : node.method_name.to_s
+
+          declaration = unknown_method_owner(node, base)
+          return nil unless declaration
+          return nil if literal_names.include?(base)
+
+          suggestion = spell_check(base, method_member_names(declaration))
+          suggestion && setter ? "#{suggestion}=" : suggestion
+        rescue StandardError
+          nil
+        end
+
+        # The receiver's declaration when it resolves in the index, everything
+        # it can inherit or be reopened with is visible there, and the method
+        # is not found — nil otherwise.
+        def unknown_method_owner(node, base)
+          declaration = resolve_constant_in_index(node.receiver)
+          return nil unless declaration.is_a?(Rubydex::Namespace)
+          return nil if responds_in_index?(declaration, node.method_name.to_s, base)
+          return nil unless fully_resolved_index_ancestry?(declaration)
+          return nil if gem_owned_namespace?(declaration)
+
+          declaration
+        end
+
+        def setter_call?(node)
+          node.assignment_method? && !node.operator_method?
+        end
+
+        def responds_in_index?(declaration, name, base)
+          # Instance methods of a module are also callable on the module
+          # itself when exposed with `module_function`.
+          [name, base].uniq.any? do |candidate|
+            member_name = "#{candidate}()"
+            indexed_singleton_member(declaration, member_name) ||
+              declaration.find_member(member_name)
+          end
+        end
+
+        # Names mentioned as symbols or inside string literals in the current
+        # file belong to runtime definitions (`stub_const`, `const_set`,
+        # `define_method`) that the index cannot see.
+        def literal_names
+          @literal_names ||=
+            processed_source.ast.each_descendant(:sym, :str)
+                            .with_object(Set.new) do |literal, names|
+              if literal.sym_type?
+                names << literal.value.to_s
+              else
+                # `scan` raises on binary string literals with invalid byte sequences.
+                value = literal.value
+                value = value.scrub unless value.valid_encoding?
+                value.scan(LITERAL_IDENTIFIER_PATTERN) { |token| names << token }
+              end
+            end
+        end
+
+        def constant_member_names(namespace)
+          namespace.members.filter_map do |member|
+            name = member.name
+            name.split('::').last unless name.include?('#') || name.include?('<')
+          end
+        end
+
+        def method_member_names(declaration)
+          scopes = declaration.ancestors.filter_map { |ancestor| indexed_singleton_of(ancestor) }
+          scopes << declaration
+
+          scopes.flat_map do |scope|
+            scope.members.filter_map { |member| member.name[METHOD_MEMBER_REGEXP, 1] }
+          end
+        end
+
+        def spell_check(name, dictionary)
+          return nil if dictionary.empty?
+
+          DidYouMean::SpellChecker.new(dictionary: dictionary.uniq).correct(name.to_s).first
+        end
+      end
+    end
+  end
+end

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

@@ -53,6 +53,8 @@ module RuboCop
         end
 
         def after_send(node)
+          return if backrefs_unaffected?(node)
+
           @valid_ref = nil
 
           if regexp_first_argument?(node)
@@ -111,6 +113,19 @@ module RuboCop
                        end
         end
 
+        # A call such as `hash[:key]` or `array[0]` cannot involve a regexp match:
+        # a non-string literal cannot act as a pattern (whereas `sub`, `gsub`,
+        # and `match` treat a string one as a pattern and do set backreferences),
+        # and `$~` is frame-local, so a user-defined method cannot change
+        # the caller's backreferences either.
+        def backrefs_unaffected?(send_node)
+          first_argument = send_node.first_argument
+          return false unless first_argument&.basic_literal?
+          return false if first_argument.str_type?
+
+          !regexp_receiver?(send_node)
+        end
+
         def regexp_first_argument?(send_node)
           send_node.first_argument&.regexp_type? \
             && REGEXP_ARGUMENT_METHODS.include?(send_node.method_name)
@@ -119,10 +134,6 @@ module RuboCop
         def regexp_receiver?(send_node)
           send_node.receiver&.regexp_type?
         end
-
-        def nth_ref_receiver?(send_node)
-          send_node.receiver&.nth_ref_type?
-        end
       end
     end
   end

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
 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,6 +145,24 @@ 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 `disable-next` with no statement attached (or misplaced at the end
+        # of a code line) suppresses nothing, so it is redundant by definition.
+        def each_detached_next_directive
+          processed_source.comment_config.detached_next_directives.each do |directive|
+            directive.raw_cop_names.each { |cop| yield directive.comment, cop }
+          end
+        end
+
         def skip_directive?(comment)
           directive = DirectiveComment.new(comment)
           directive.push? || directive.pop?
@@ -142,7 +178,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,7 +188,7 @@ 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
@@ -170,7 +206,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 +233,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)
@@ -244,14 +283,28 @@ module RuboCop
           location = DirectiveComment.new(comment).range
           cop_names = cops.sort.map { |c| describe(c) }.join(', ')
 
+          # 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.
+          if any_unknown_cop?(cops) || misplaced_next_directive?(comment)
+            return add_offense(location, message: message(cop_names))
+          end
+
           add_offense(location, message: message(cop_names)) do |corrector|
-            range = comment_range_with_surrounding_space(location, comment.source_range)
+            remove_entire_comment(corrector, comment)
+          end
+        end
 
-            if leave_free_comment?(comment, range)
-              corrector.replace(range, ' # ')
-            else
-              corrector.remove(range)
-            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 +314,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? &&
+            !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 +377,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
 
@@ -344,4 +424,3 @@ module RuboCop
     end
   end
 end
-# rubocop:enable Lint/RedundantCopDisableDirective