rubocop 1.88.0 → 1.89.0

data/lib/rubocop/cop/mixin/project_index_help.rb

@@ -17,6 +17,14 @@ module RuboCop
       # remains after stripping `file://` from a `file:///C:/...` URI.
       WINDOWS_DRIVE_PREFIX = %r{\A/(?=[A-Za-z]:[/\\])}.freeze
 
+      class << self
+        # The signature is a property of the index, not of the cop, and computing
+        # it stats every indexed file, so all cops sharing an index share one
+        # computation. A single-entry cache (instead of a hash keyed by index)
+        # avoids retaining stale graphs in long-lived processes.
+        attr_accessor :cached_index_signature
+      end
+
       def external_dependency_checksum
         return nil unless project_index
 
@@ -27,7 +35,139 @@ module RuboCop
 
       private
 
+      # Returns the definitions among `definitions` that live in a file other than the
+      # one being inspected, ordered by path and line. Definitions without a `file://`
+      # URI (e.g. Rubydex's built-in declarations) are ignored.
+      def definitions_in_other_files(definitions)
+        current = processed_source.file_path
+
+        definitions
+          .select { |definition| definition.location.uri.start_with?(FILE_URI_PREFIX) }
+          .reject { |definition| File.identical?(definition.location.to_file_path, current) }
+          .sort_by do |definition|
+          [definition.location.to_file_path,
+           definition.location.start_line]
+        end
+      end
+
+      def prior_definition_in_other_file(definitions)
+        definitions_in_other_files(definitions).first
+      end
+
+      # Resolves a constant node the way Ruby does: the first segment through
+      # the lexical nesting and every following segment inside the previous
+      # one. (Qualified names cannot be passed to `resolve_constant` as a
+      # whole, since it only applies the nesting to the full name. Later
+      # segments use `find_member` — the namespace and its ancestors — since
+      # `resolve_constant` cannot take an already-resolved namespace as the
+      # scope, only names as they appear in source.)
+      def resolve_constant_in_index(const_node)
+        segments = const_node.const_name.split('::')
+        nesting = const_node.absolute? ? [] : lexical_nesting_of(const_node)
+
+        declaration = project_index.resolve_constant(segments.first, nesting)
+        segments.drop(1).each do |segment|
+          return nil unless declaration.is_a?(Rubydex::Namespace)
+
+          declaration = declaration.find_member(segment)
+        end
+
+        declaration
+      end
+
+      # The lexical nesting the node's constants resolve through, outermost
+      # first. Only scopes whose *body* contains the node count: a class or
+      # module's identifier and superclass expression are evaluated before its
+      # scope exists, so ancestors reached through them are excluded.
+      def lexical_nesting_of(node)
+        nesting = []
+        child = node
+
+        node.each_ancestor do |ancestor|
+          if ancestor.type?(:class, :module) && child.equal?(ancestor.body)
+            nesting << ancestor.identifier.const_name
+          end
+          child = ancestor
+        end
+
+        nesting.reverse
+      end
+
+      # The declaration of `declaration`'s singleton class, or nil when no
+      # singleton method is defined on it anywhere in the project.
+      def indexed_singleton_of(declaration)
+        project_index["#{declaration.name}::<#{declaration.name.split('::').last}>"]
+      end
+
+      # A namespace without any singleton method has no singleton-class
+      # declaration of its own, so the lookup starts from the first ancestor
+      # that has one; its `find_member` covers the rest of the chain.
+      def indexed_singleton_member(namespace, member_name)
+        namespace.ancestors.each do |ancestor|
+          singleton = indexed_singleton_of(ancestor)
+          return singleton.find_member(member_name) if singleton
+        end
+
+        nil
+      end
+
+      # Whether an ancestor of `scope` other than `scope` itself defines
+      # `member_name`.
+      def inherited_index_member?(scope, member_name)
+        scope.ancestors.any? do |ancestor|
+          ancestor.name != scope.name && ancestor.member(member_name)
+        end
+      end
+
+      # Whether every link of the declaration's ancestry is resolved in the
+      # index: no definition of any ancestor has an unresolved superclass or
+      # mixin reference. Unresolved links silently vanish from `ancestors`,
+      # so this is the completeness check that must pass before reasoning
+      # about what an ancestry does or does not define. `extend` mixins only
+      # affect the singleton class; pass `ignore_extend: true` when reasoning
+      # about instance-side ancestry only.
+      def fully_resolved_index_ancestry?(declaration, ignore_extend: false)
+        declaration.ancestors.all? do |ancestor|
+          ancestor.definitions.all? do |definition|
+            resolved_superclass_reference?(definition) &&
+              resolved_mixin_references?(definition, ignore_extend: ignore_extend)
+          end
+        end
+      end
+
+      def resolved_superclass_reference?(definition)
+        return true unless definition.is_a?(Rubydex::ClassDefinition)
+
+        !definition.superclass.is_a?(Rubydex::UnresolvedConstantReference)
+      end
+
+      def resolved_mixin_references?(definition, ignore_extend: false)
+        return true unless definition.respond_to?(:mixins)
+
+        definition.mixins.none? do |mixin|
+          next false if ignore_extend && mixin.is_a?(Rubydex::Extend)
+
+          mixin.constant_reference.is_a?(Rubydex::UnresolvedConstantReference)
+        end
+      end
+
+      def same_file?(path, other)
+        return true if File.identical?(path, other)
+
+        normalized = [path, other].map { |p| File.expand_path(p).tr('\\', '/') }
+        normalized.uniq.one? || (Platform.windows? && normalized[0].casecmp?(normalized[1]))
+      end
+
       def project_index_signature
+        index, signature = ProjectIndexHelp.cached_index_signature
+        return signature if index.equal?(project_index)
+
+        compute_project_index_signature.tap do |computed|
+          ProjectIndexHelp.cached_index_signature = [project_index, computed]
+        end
+      end
+
+      def compute_project_index_signature
         project_index.documents.filter_map do |doc|
           uri = doc.uri
           next if uri == BUILTIN_DOCUMENT_URI

data/lib/rubocop/cop/mixin/reparsed_equivalence.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Verifies that a candidate correction of the inspected source is a
+    # syntactic no-op: the corrected source must parse successfully and produce
+    # the same AST as the original.
+    #
+    # This turns "is this piece of syntax redundant?" questions into a
+    # parser-backed check instead of a hand-maintained enumeration of grammar
+    # rules: instead of modeling which constructs make (for example) a line
+    # continuation or a pair of parentheses significant, a cop can apply the
+    # correction and let the parser answer.
+    #
+    # Cops implement `#apply_reparse_correction(corrector, item)` and call
+    # `verified_by_reparse(items)`, which returns the items whose corrections
+    # are verified. Items sharing a reparse scope (the innermost method
+    # definition or class/module body, which parse standalone and cannot
+    # capture outer local variables) are verified together with a single
+    # reparse, falling back to per-item verification when the batch does not
+    # hold. Scope groups are keyed by node identity, since structurally
+    # identical definitions in different places must not share a group.
+    #
+    # Two hooks customize the comparison:
+    #
+    # * `normalize_reparsed_ast(node)` - loosen strict tree equality where a
+    #   cop's correction is equivalence-preserving beyond parse identity (such
+    #   laws must be justified per cop; the default compares trees as-is).
+    # * `preprocess_reparsed_source(source)` - rewrite both sides before
+    #   parsing (e.g. to neutralize `__LINE__` when a correction legitimately
+    #   shifts line numbers).
+    #
+    # `__FILE__` is handled by parsing with the original path, and fragments
+    # containing `__LINE__` are verified by reparsing both sides so that
+    # fragment line offsets cancel out.
+    #
+    # Note that comments are invisible to the AST, so corrections that may
+    # touch comment text must be guarded separately by the caller.
+    module ReparsedEquivalence
+      # Above this size, verification does not reparse. What happens to such
+      # items depends on `oversized`; in practice only machine-generated files
+      # come near the limit.
+      MAX_VERIFICATION_FRAGMENT_SIZE = 64 * 1024
+
+      private
+
+      # Returns the items whose corrections are verified. `oversized` controls
+      # items whose reparse scope exceeds `MAX_VERIFICATION_FRAGMENT_SIZE`:
+      # `:report` accepts them unverified (for cops whose offense logic stands
+      # on its own and uses verification as a safety gate), `:verify` reparses
+      # regardless of size (for cops where verification is the offense logic).
+      def verified_by_reparse(items, oversized: :report)
+        scope_groups(items).flat_map do |scope, group|
+          if (oversized == :report && verification_too_large?(scope)) ||
+             (group.size > 1 && corrections_verify?(scope, group))
+            group
+          else
+            group.select { |item| corrections_verify?(scope, [item]) }
+          end
+        end
+      end
+
+      # Whether the exact correction for `item` produces source that still
+      # parses, without requiring an equivalent AST. For corrections that
+      # intentionally change the tree.
+      def correction_parses?(item)
+        corrector = Corrector.new(processed_source)
+        apply_reparse_correction(corrector, item)
+
+        parse(corrector.process, processed_source.path).valid_syntax?
+      rescue ::Parser::ClobberingError
+        false
+      end
+
+      # Hook: loosen strict tree equality for corrections that are
+      # equivalence-preserving beyond parse identity.
+      def normalize_reparsed_ast(node)
+        node
+      end
+
+      # Hook: rewrite both sides before parsing.
+      def preprocess_reparsed_source(source)
+        source
+      end
+
+      def scope_groups(items)
+        groups = {}.compare_by_identity
+        items.each { |item| (groups[reparse_scope(item_range(item))] ||= []) << item }
+
+        groups
+      end
+
+      def item_range(item)
+        item.respond_to?(:source_range) ? item.source_range : item
+      end
+
+      # The innermost scope that both contains `range` and parses standalone.
+      # Method definitions and class/module bodies neither capture outer local
+      # variables nor continue an outer expression; blocks and single
+      # statements do not qualify, since an outer local would reparse as a
+      # method call.
+      def reparse_scope(range)
+        node = processed_source.ast
+        scope = nil
+
+        while node.is_a?(::Parser::AST::Node)
+          scope = node if node.type?(:any_def, :class, :module, :sclass)
+          node = node.children.find do |child|
+            child.is_a?(::Parser::AST::Node) && child.source_range&.contains?(range)
+          end
+        end
+
+        scope
+      end
+
+      def verification_too_large?(scope)
+        (scope ? scope.source_range.size : processed_source.raw_source.size) >
+          MAX_VERIFICATION_FRAGMENT_SIZE
+      end
+
+      def corrections_verify?(scope, items)
+        corrector = Corrector.new(processed_source)
+        items.each { |item| apply_reparse_correction(corrector, item) }
+        corrected = corrector.process
+
+        if scope
+          fragment = corrected_scope_fragment(scope, corrected)
+          parses_equivalently?(scope.source, scope, fragment)
+        else
+          parses_equivalently?(processed_source.raw_source, processed_source.ast, corrected)
+        end
+      rescue ::Parser::ClobberingError
+        false
+      end
+
+      # The corrections' edits are all contained within the scope, so the
+      # corrected fragment can be cut out of the corrected source by adjusting
+      # for the edits' length delta.
+      def corrected_scope_fragment(scope, corrected)
+        delta = corrected.length - processed_source.raw_source.length
+        scope_range = scope.source_range
+
+        corrected[scope_range.begin_pos...(scope_range.end_pos + delta)]
+      end
+
+      # Both sides are parsed with the original path so that `__FILE__`
+      # resolves identically. The original side is reparsed (instead of using
+      # the already parsed node) when preprocessing altered it or it contains
+      # `__LINE__`, whose values would otherwise differ from a fragment parsed
+      # at a different line offset.
+      def parses_equivalently?(original_source, original_ast, corrected_source)
+        original_normalized = normalized_original(original_source, original_ast)
+        return false unless original_normalized
+
+        rewritten = parse(preprocess_reparsed_source(corrected_source), processed_source.path)
+        rewritten.valid_syntax? && normalize_reparsed_ast(rewritten.ast) == original_normalized
+      end
+
+      def normalized_original(original_source, original_ast)
+        original = preprocess_reparsed_source(original_source)
+        if original != original_source || original_source.include?('__LINE__')
+          reparsed = parse(original, processed_source.path).ast
+          reparsed && normalize_reparsed_ast(reparsed)
+        else
+          @normalized_originals ||= {}.compare_by_identity
+          @normalized_originals[original_ast] ||= normalize_reparsed_ast(original_ast)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/statement_modifier.rb

@@ -5,6 +5,7 @@ module RuboCop
     # Common functionality for modifier cops.
     module StatementModifier
       include LineLengthHelp
+      include AllowedPattern
 
       private
 
@@ -35,16 +36,51 @@ module RuboCop
       end
 
       def modifier_fits_on_single_line?(node)
-        return true unless max_line_length
-
-        length_in_modifier_form(node) <= max_line_length
+        acceptable_line_length?(line_in_modifier_form(node), node.first_line)
       end
 
-      def length_in_modifier_form(node)
+      def line_in_modifier_form(node)
         keyword_element = node.loc.keyword
         code_before = keyword_element.source_line[0...keyword_element.column]
-        expression = to_modifier_form(node)
-        line_length("#{code_before}#{expression}#{code_after(node)}")
+
+        "#{code_before}#{to_modifier_form(node)}#{code_after(node)}"
+      end
+
+      # Rather than comparing the rendered modifier form against the bare
+      # maximum, ask the question `Layout/LineLength` would: a line the user's
+      # configuration exempts (`Layout/LineLength` disabled at that line, an
+      # allowed pattern, an allowed cop directive, an allowed URI) fits by
+      # definition. This keeps every modifier cop consistent with
+      # `Layout/LineLength` instead of each reimplementing part of its policy.
+      def acceptable_line_length?(line, line_number)
+        return true unless max_line_length
+        return true if line_length(line) <= max_line_length
+        return true unless line_length_enabled_at_line?(line_number)
+        return true if matches_allowed_pattern?(line)
+
+        if allow_cop_directives? && directive_on_source_line?(line_number - 1)
+          return line_length_without_directive(line) <= max_line_length
+        end
+
+        allowed_by_uri?(line)
+      end
+
+      def allowed_by_uri?(line)
+        return false unless allow_uri?
+
+        uri_range = find_excessive_range(line, :uri)
+        !uri_range.nil? && allowed_position?(line, uri_range)
+      end
+
+      def line_length_enabled_at_line?(line)
+        processed_source.comment_config.cop_enabled_at_line?('Layout/LineLength', line)
+      end
+
+      # `Layout/LineLength`'s allowed patterns, so a modifier line that the
+      # user has configured that cop to accept is not flagged for length here.
+      def allowed_patterns
+        line_length_config = config.for_cop('Layout/LineLength')
+        line_length_config['AllowedPatterns'] || line_length_config['IgnoredPatterns'] || []
       end
 
       def to_modifier_form(node)
@@ -75,7 +111,7 @@ module RuboCop
       end
 
       def first_line_comment(node)
-        comment = processed_source.comments.find { |c| same_line?(c, node) }
+        comment = processed_source.comment_at_line(node.first_line)
         return unless comment
 
         comment_source = comment.source

data/lib/rubocop/cop/mixin.rb

@@ -5,82 +5,83 @@ module RuboCop
     # Autoloads mixin modules included by cops. Mixins are autoloaded to reduce the number of
     # requires because they're used only when the relevant cop class is loaded.
 
-    autoload :ArrayMinSize, 'rubocop/cop/mixin/array_min_size'
-    autoload :ArraySyntax, 'rubocop/cop/mixin/array_syntax'
-    autoload :Alignment, 'rubocop/cop/mixin/alignment'
-    autoload :AllowedIdentifiers, 'rubocop/cop/mixin/allowed_identifiers'
-    autoload :AllowedMethods, 'rubocop/cop/mixin/allowed_methods'
-    autoload :AllowedPattern, 'rubocop/cop/mixin/allowed_pattern'
-    autoload :AllowedReceivers, 'rubocop/cop/mixin/allowed_receivers'
-    autoload :ForbiddenIdentifiers, 'rubocop/cop/mixin/forbidden_identifiers'
-    autoload :ForbiddenPattern, 'rubocop/cop/mixin/forbidden_pattern'
-    autoload :AutoCorrector, 'rubocop/cop/mixin/auto_corrector' # rubocop:todo Naming/InclusiveLanguage
-    autoload :CheckAssignment, 'rubocop/cop/mixin/check_assignment'
-    autoload :CheckLineBreakable, 'rubocop/cop/mixin/check_line_breakable'
-    autoload :CheckSingleLineSuitability, 'rubocop/cop/mixin/check_single_line_suitability'
-    autoload :ConfigurableMax, 'rubocop/cop/mixin/configurable_max'
-    autoload :CodeLength, 'rubocop/cop/mixin/code_length'
-    autoload :ConfigurableEnforcedStyle, 'rubocop/cop/mixin/configurable_enforced_style'
-    autoload :ConfigurableFormatting, 'rubocop/cop/mixin/configurable_formatting'
-    autoload :ConfigurableNaming, 'rubocop/cop/mixin/configurable_naming'
-    autoload :ConfigurableNumbering, 'rubocop/cop/mixin/configurable_numbering'
-    autoload :DigHelp, 'rubocop/cop/mixin/dig_help'
-    autoload :DocumentationComment, 'rubocop/cop/mixin/documentation_comment'
-    autoload :Duplication, 'rubocop/cop/mixin/duplication'
-    autoload :RangeHelp, 'rubocop/cop/mixin/range_help'
-    autoload :ProjectIndexHelp, 'rubocop/cop/mixin/project_index_help'
-    autoload :AnnotationComment, 'rubocop/cop/mixin/annotation_comment'
-    autoload :EmptyParameter, 'rubocop/cop/mixin/empty_parameter'
-    autoload :EndKeywordAlignment, 'rubocop/cop/mixin/end_keyword_alignment'
-    autoload :EndlessMethodRewriter, 'rubocop/cop/mixin/endless_method_rewriter'
-    autoload :EnforceSuperclass, 'rubocop/cop/mixin/enforce_superclass'
-    autoload :FirstElementLineBreak, 'rubocop/cop/mixin/first_element_line_break'
-    autoload :FrozenStringLiteral, 'rubocop/cop/mixin/frozen_string_literal'
-    autoload :GemDeclaration, 'rubocop/cop/mixin/gem_declaration'
-    autoload :GemspecHelp, 'rubocop/cop/mixin/gemspec_help'
-    autoload :HashAlignmentStyles, 'rubocop/cop/mixin/hash_alignment_styles'
-    autoload :HashSubset, 'rubocop/cop/mixin/hash_subset'
-    autoload :HashTransformMethod, 'rubocop/cop/mixin/hash_transform_method'
-    autoload :IntegerNode, 'rubocop/cop/mixin/integer_node'
-    autoload :Interpolation, 'rubocop/cop/mixin/interpolation'
-    autoload :LineLengthHelp, 'rubocop/cop/mixin/line_length_help'
-    autoload :MatchRange, 'rubocop/cop/mixin/match_range'
-    autoload :HashShorthandSyntax, 'rubocop/cop/mixin/hash_shorthand_syntax'
-    autoload :MethodComplexity, 'rubocop/cop/mixin/method_complexity'
-    autoload :MethodPreference, 'rubocop/cop/mixin/method_preference'
-    autoload :MinBodyLength, 'rubocop/cop/mixin/min_body_length'
-    autoload :MinBranchesCount, 'rubocop/cop/mixin/min_branches_count'
-    autoload :MultilineElementIndentation, 'rubocop/cop/mixin/multiline_element_indentation'
-    autoload :MultilineElementLineBreaks, 'rubocop/cop/mixin/multiline_element_line_breaks'
-    autoload :MultilineExpressionIndentation, 'rubocop/cop/mixin/multiline_expression_indentation'
-    autoload :MultilineLiteralBraceLayout, 'rubocop/cop/mixin/multiline_literal_brace_layout'
-    autoload :NegativeConditional, 'rubocop/cop/mixin/negative_conditional'
-    autoload :Heredoc, 'rubocop/cop/mixin/heredoc'
-    autoload :NilMethods, 'rubocop/cop/mixin/nil_methods'
-    autoload :OnNormalIfUnless, 'rubocop/cop/mixin/on_normal_if_unless'
-    autoload :OrderedGemNode, 'rubocop/cop/mixin/ordered_gem_node'
-    autoload :Parentheses, 'rubocop/cop/mixin/parentheses'
-    autoload :PercentArray, 'rubocop/cop/mixin/percent_array'
-    autoload :PercentLiteral, 'rubocop/cop/mixin/percent_literal'
-    autoload :PrecedingFollowingAlignment, 'rubocop/cop/mixin/preceding_following_alignment'
-    autoload :PreferredDelimiters, 'rubocop/cop/mixin/preferred_delimiters'
-    autoload :RationalLiteral, 'rubocop/cop/mixin/rational_literal'
-    autoload :RequireLibrary, 'rubocop/cop/mixin/require_library'
-    autoload :RescueNode, 'rubocop/cop/mixin/rescue_node'
-    autoload :SafeAssignment, 'rubocop/cop/mixin/safe_assignment'
-    autoload :SpaceAfterPunctuation, 'rubocop/cop/mixin/space_after_punctuation'
-    autoload :SpaceBeforePunctuation, 'rubocop/cop/mixin/space_before_punctuation'
-    autoload :SurroundingSpace, 'rubocop/cop/mixin/surrounding_space'
-    autoload :StatementModifier, 'rubocop/cop/mixin/statement_modifier'
-    autoload :StringHelp, 'rubocop/cop/mixin/string_help'
-    autoload :StringLiteralsHelp, 'rubocop/cop/mixin/string_literals_help'
-    autoload :SymbolHelp, 'rubocop/cop/mixin/symbol_help'
-    autoload :TargetRubyVersion, 'rubocop/cop/mixin/target_ruby_version'
-    autoload :TrailingBody, 'rubocop/cop/mixin/trailing_body'
-    autoload :TrailingComma, 'rubocop/cop/mixin/trailing_comma'
-    autoload :UncommunicativeName, 'rubocop/cop/mixin/uncommunicative_name'
-    autoload :VisibilityHelp, 'rubocop/cop/mixin/visibility_help'
-    autoload :CommentsHelp, 'rubocop/cop/mixin/comments_help'
-    autoload :DefNode, 'rubocop/cop/mixin/def_node'
+    autoload :ArrayMinSize, "#{__dir__}/mixin/array_min_size"
+    autoload :ArraySyntax, "#{__dir__}/mixin/array_syntax"
+    autoload :Alignment, "#{__dir__}/mixin/alignment"
+    autoload :AllowedIdentifiers, "#{__dir__}/mixin/allowed_identifiers"
+    autoload :AllowedMethods, "#{__dir__}/mixin/allowed_methods"
+    autoload :AllowedPattern, "#{__dir__}/mixin/allowed_pattern"
+    autoload :AllowedReceivers, "#{__dir__}/mixin/allowed_receivers"
+    autoload :ForbiddenIdentifiers, "#{__dir__}/mixin/forbidden_identifiers"
+    autoload :ForbiddenPattern, "#{__dir__}/mixin/forbidden_pattern"
+    autoload :AutoCorrector, "#{__dir__}/mixin/auto_corrector" # rubocop:todo Naming/InclusiveLanguage
+    autoload :CheckAssignment, "#{__dir__}/mixin/check_assignment"
+    autoload :CheckLineBreakable, "#{__dir__}/mixin/check_line_breakable"
+    autoload :CheckSingleLineSuitability, "#{__dir__}/mixin/check_single_line_suitability"
+    autoload :ConfigurableMax, "#{__dir__}/mixin/configurable_max"
+    autoload :CodeLength, "#{__dir__}/mixin/code_length"
+    autoload :ConfigurableEnforcedStyle, "#{__dir__}/mixin/configurable_enforced_style"
+    autoload :ConfigurableFormatting, "#{__dir__}/mixin/configurable_formatting"
+    autoload :ConfigurableNaming, "#{__dir__}/mixin/configurable_naming"
+    autoload :ConfigurableNumbering, "#{__dir__}/mixin/configurable_numbering"
+    autoload :DigHelp, "#{__dir__}/mixin/dig_help"
+    autoload :DocumentationComment, "#{__dir__}/mixin/documentation_comment"
+    autoload :Duplication, "#{__dir__}/mixin/duplication"
+    autoload :RangeHelp, "#{__dir__}/mixin/range_help"
+    autoload :ProjectIndexHelp, "#{__dir__}/mixin/project_index_help"
+    autoload :AnnotationComment, "#{__dir__}/mixin/annotation_comment"
+    autoload :EmptyParameter, "#{__dir__}/mixin/empty_parameter"
+    autoload :EndKeywordAlignment, "#{__dir__}/mixin/end_keyword_alignment"
+    autoload :EndlessMethodRewriter, "#{__dir__}/mixin/endless_method_rewriter"
+    autoload :EnforceSuperclass, "#{__dir__}/mixin/enforce_superclass"
+    autoload :FirstElementLineBreak, "#{__dir__}/mixin/first_element_line_break"
+    autoload :FrozenStringLiteral, "#{__dir__}/mixin/frozen_string_literal"
+    autoload :GemDeclaration, "#{__dir__}/mixin/gem_declaration"
+    autoload :GemspecHelp, "#{__dir__}/mixin/gemspec_help"
+    autoload :HashAlignmentStyles, "#{__dir__}/mixin/hash_alignment_styles"
+    autoload :HashSubset, "#{__dir__}/mixin/hash_subset"
+    autoload :HashTransformMethod, "#{__dir__}/mixin/hash_transform_method"
+    autoload :IntegerNode, "#{__dir__}/mixin/integer_node"
+    autoload :Interpolation, "#{__dir__}/mixin/interpolation"
+    autoload :LineLengthHelp, "#{__dir__}/mixin/line_length_help"
+    autoload :MatchRange, "#{__dir__}/mixin/match_range"
+    autoload :HashShorthandSyntax, "#{__dir__}/mixin/hash_shorthand_syntax"
+    autoload :MethodComplexity, "#{__dir__}/mixin/method_complexity"
+    autoload :MethodPreference, "#{__dir__}/mixin/method_preference"
+    autoload :MinBodyLength, "#{__dir__}/mixin/min_body_length"
+    autoload :MinBranchesCount, "#{__dir__}/mixin/min_branches_count"
+    autoload :MultilineElementIndentation, "#{__dir__}/mixin/multiline_element_indentation"
+    autoload :MultilineElementLineBreaks, "#{__dir__}/mixin/multiline_element_line_breaks"
+    autoload :MultilineExpressionIndentation, "#{__dir__}/mixin/multiline_expression_indentation"
+    autoload :MultilineLiteralBraceLayout, "#{__dir__}/mixin/multiline_literal_brace_layout"
+    autoload :NegativeConditional, "#{__dir__}/mixin/negative_conditional"
+    autoload :Heredoc, "#{__dir__}/mixin/heredoc"
+    autoload :NilMethods, "#{__dir__}/mixin/nil_methods"
+    autoload :OnNormalIfUnless, "#{__dir__}/mixin/on_normal_if_unless"
+    autoload :OrderedGemNode, "#{__dir__}/mixin/ordered_gem_node"
+    autoload :Parentheses, "#{__dir__}/mixin/parentheses"
+    autoload :PercentArray, "#{__dir__}/mixin/percent_array"
+    autoload :PercentLiteral, "#{__dir__}/mixin/percent_literal"
+    autoload :PrecedingFollowingAlignment, "#{__dir__}/mixin/preceding_following_alignment"
+    autoload :PreferredDelimiters, "#{__dir__}/mixin/preferred_delimiters"
+    autoload :RationalLiteral, "#{__dir__}/mixin/rational_literal"
+    autoload :ReparsedEquivalence, "#{__dir__}/mixin/reparsed_equivalence"
+    autoload :RequireLibrary, "#{__dir__}/mixin/require_library"
+    autoload :RescueNode, "#{__dir__}/mixin/rescue_node"
+    autoload :SafeAssignment, "#{__dir__}/mixin/safe_assignment"
+    autoload :SpaceAfterPunctuation, "#{__dir__}/mixin/space_after_punctuation"
+    autoload :SpaceBeforePunctuation, "#{__dir__}/mixin/space_before_punctuation"
+    autoload :SurroundingSpace, "#{__dir__}/mixin/surrounding_space"
+    autoload :StatementModifier, "#{__dir__}/mixin/statement_modifier"
+    autoload :StringHelp, "#{__dir__}/mixin/string_help"
+    autoload :StringLiteralsHelp, "#{__dir__}/mixin/string_literals_help"
+    autoload :SymbolHelp, "#{__dir__}/mixin/symbol_help"
+    autoload :TargetRubyVersion, "#{__dir__}/mixin/target_ruby_version"
+    autoload :TrailingBody, "#{__dir__}/mixin/trailing_body"
+    autoload :TrailingComma, "#{__dir__}/mixin/trailing_comma"
+    autoload :UncommunicativeName, "#{__dir__}/mixin/uncommunicative_name"
+    autoload :VisibilityHelp, "#{__dir__}/mixin/visibility_help"
+    autoload :CommentsHelp, "#{__dir__}/mixin/comments_help"
+    autoload :DefNode, "#{__dir__}/mixin/def_node"
   end
 end

data/lib/rubocop/cop/naming/accessor_method_name.rb

@@ -11,6 +11,11 @@ module RuboCop
       # Getters (`get_attribute`) must have no arguments to be registered,
       # and setters (`set_attribute(value)`) must have exactly one.
       #
+      # When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is
+      # installed, methods that override a method defined by an ancestor
+      # elsewhere in the project are not reported, since renaming an override
+      # breaks the inherited contract.
+      #
       # @example
       #   # bad
       #   def set_attribute(value)
@@ -36,12 +41,15 @@ module RuboCop
       #   def set_value
       #   end
       class AccessorMethodName < Base
+        include ProjectIndexHelp
+
         MSG_READER = 'Do not prefix reader method names with `get_`.'
         MSG_WRITER = 'Do not prefix writer method names with `set_`.'
 
         def on_def(node)
           return unless proper_attribute_name?(node)
           return unless bad_reader_name?(node) || bad_writer_name?(node)
+          return if overrides_inherited_method?(node)
 
           message = message(node)
 
@@ -72,6 +80,22 @@ module RuboCop
             node.arguments.one? &&
             node.first_argument.arg_type?
         end
+
+        # When `AllCops/UseProjectIndex` is enabled, methods that override a
+        # method defined by an ancestor elsewhere in the project are not
+        # reported: renaming an override breaks the inherited contract.
+        def overrides_inherited_method?(node)
+          return false unless project_index
+          return false unless (namespace_node = node.each_ancestor(:class, :module).first)
+
+          declaration = resolve_constant_in_index(namespace_node.identifier)
+          return false unless declaration.is_a?(Rubydex::Namespace)
+
+          scope = node.defs_type? ? indexed_singleton_of(declaration) : declaration
+          !scope.nil? && inherited_index_member?(scope, "#{node.method_name}()")
+        rescue StandardError
+          false
+        end
       end
     end
   end

data/lib/rubocop/cop/naming/file_name.rb

@@ -203,9 +203,10 @@ module RuboCop
 
         def match_acronym?(expected, name)
           expected = expected.to_s
-          name = name.to_s
-
-          allowed_acronyms.any? { |acronym| expected.gsub(acronym.capitalize, acronym) == name }
+          name = allowed_acronyms.reduce(name.to_s) do |result, acronym|
+            result.gsub(acronym, acronym.capitalize)
+          end
+          expected == name
         end
 
         def to_namespace(path) # rubocop:disable Metrics/AbcSize