rubocop 1.71.1 → 1.92.1

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

@@ -0,0 +1,181 @@
+# 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
+          else
+            verified_subset(scope, group)
+          end
+        end
+      end
+
+      # Verifies a group with a single reparse and bisects it when that fails,
+      # so a few significant items among many cost a logarithmic number of
+      # reparses rather than one each.
+      def verified_subset(scope, group)
+        return group if corrections_verify?(scope, group)
+        return [] if group.one?
+
+        half = group.size / 2
+        verified_subset(scope, group.take(half)) + verified_subset(scope, group.drop(half))
+      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/space_after_punctuation.rb

@@ -8,8 +8,8 @@ module RuboCop
       MSG = 'Space missing after %<token>s.'
 
       def on_new_investigation
-        each_missing_space(processed_source.tokens) do |token|
-          add_offense(token.pos, message: format(MSG, token: kind(token))) do |corrector|
+        each_missing_space(processed_source.tokens) do |token, kind|
+          add_offense(token.pos, message: format(MSG, token: kind)) do |corrector|
             PunctuationCorrector.add_space(corrector, token)
           end
         end
@@ -19,11 +19,12 @@ module RuboCop
 
       def each_missing_space(tokens)
         tokens.each_cons(2) do |token1, token2|
-          next unless kind(token1)
+          kind = kind(token1, token2)
+          next unless kind
           next unless space_missing?(token1, token2)
           next unless space_required_before?(token2)
 
-          yield token1
+          yield token1, kind
         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
 
@@ -34,17 +35,58 @@ module RuboCop
         condition.each_node.any?(&:lvasgn_type?)
       end
 
+      # The rendered modifier form is compared against the bare maximum, not
+      # `acceptable_line_length?`: `Layout/LineLength`'s exemptions describe
+      # long lines the user tolerates, not permission to manufacture new ones,
+      # so collapsing to modifier form must never push a line past the maximum.
       def modifier_fits_on_single_line?(node)
         return true unless max_line_length
 
-        length_in_modifier_form(node) <= max_line_length
+        line_length(line_in_modifier_form(node)) <= max_line_length
       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
+
+      # Whether an existing line is acceptable to `Layout/LineLength`,
+      # exemptions (the cop disabled at that line, an allowed pattern, an
+      # allowed cop directive, an allowed URI) included. Only for judging
+      # lines already in the source as too long - see
+      # `modifier_fits_on_single_line?` for why the exemptions must not apply
+      # when deciding whether a modifier line may be created.
+      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)
@@ -54,15 +96,22 @@ module RuboCop
         [parenthesized, first_line_comment(node)].compact.join(' ')
       end
 
+      # rubocop:disable-next Metrics/AbcSize
       def if_body_source(if_body)
-        if if_body.call_type? && !if_body.method?(:[]=) && omitted_value_in_last_hash_arg?(if_body)
+        if unparenthesized_call_with_omitted_value?(if_body)
           "#{method_source(if_body)}(#{if_body.arguments.map(&:source).join(', ')})"
+        elsif (value = wrapped_value(if_body))
+          prefix = if_body.source_range.begin.join(value.source_range.begin).source
+          suffix = value.source_range.end.join(if_body.source_range.end).source
+
+          "#{prefix}#{if_body_source(value)}#{suffix}"
         else
           if_body.source
         end
       end
 
-      def omitted_value_in_last_hash_arg?(if_body)
+      def unparenthesized_call_with_omitted_value?(if_body)
+        return false if !if_body.call_type? || if_body.method?(:[]=) || if_body.parenthesized?
         return false unless (last_argument = if_body.last_argument)
 
         last_argument.hash_type? && last_argument.pairs.last&.value_omission?
@@ -74,8 +123,16 @@ module RuboCop
         if_body.source_range.begin.join(end_range).source
       end
 
+      def wrapped_value(if_body)
+        if if_body.type?(:return, :next, :break)
+          if_body.first_argument if if_body.arguments.one?
+        elsif if_body.type?(:lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn)
+          if_body.expression
+        end
+      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
@@ -95,15 +152,15 @@ module RuboCop
         parent = node.parent
         return false if parent.nil?
         return true if parent.assignment? || parent.operator_keyword?
-        return true if %i[array pair].include?(parent.type)
+        return true if parent.type?(:array, :pair, :call, :yield, :super)
 
-        node.parent.send_type?
+        ternary_branch_or_endless_method_body?(parent)
       end
 
-      def max_line_length
-        return unless config.cop_enabled?('Layout/LineLength')
+      def ternary_branch_or_endless_method_body?(parent)
+        return parent.ternary? if parent.if_type?
 
-        config.for_cop('Layout/LineLength')['Max']
+        parent.any_def_type? && parent.endless?
       end
 
       def comment_disables_cop?(comment)

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

@@ -10,7 +10,7 @@ module RuboCop
       def on_str(node)
         # Constants like __FILE__ are handled as strings,
         # but don't respond to begin.
-        return unless node.loc.respond_to?(:begin) && node.loc.begin
+        return unless node.loc?(:begin)
         return if part_of_ignored_node?(node)
 
         if offense?(node)

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

@@ -29,7 +29,7 @@ module RuboCop
         min = required_minimum_ruby_version || 0
         max = required_maximum_ruby_version || Float::INFINITY
 
-        min <= version && max >= version
+        version.between?(min, max)
       end
     end
   end

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

@@ -4,6 +4,7 @@ module RuboCop
   module Cop
     # Common methods shared by Style/TrailingCommaInArguments,
     # Style/TrailingCommaInArrayLiteral and Style/TrailingCommaInHashLiteral
+    # rubocop:disable-next Metrics/ModuleLength
     module TrailingComma
       include ConfigurableEnforcedStyle
       include RangeHelp
@@ -57,6 +58,8 @@ module RuboCop
           ', unless each item is on its own line'
         when :consistent_comma
           ', unless items are split onto multiple lines'
+        when :diff_comma
+          ', unless that item immediately precedes a newline'
         else
           ''
         end
@@ -68,6 +71,8 @@ module RuboCop
           multiline?(node) && no_elements_on_same_line?(node)
         when :consistent_comma
           multiline?(node) && !method_name_and_arguments_on_same_line?(node)
+        when :diff_comma
+          multiline?(node) && last_item_precedes_newline?(node)
         else
           false
         end
@@ -90,19 +95,21 @@ module RuboCop
         node.multiline? && !allowed_multiline_argument?(node)
       end
 
+      # rubocop:disable-next Metrics/AbcSize
       def method_name_and_arguments_on_same_line?(node)
-        return false unless node.call_type?
+        return false if !node.call_type? || node.last_line != node.last_argument.last_line
+        return true if node.last_argument.hash_type? && node.last_argument.braces?
 
-        line = node.loc.selector.nil? ? node.loc.line : node.loc.selector.line
+        line = node.loc.selector&.line || node.loc.line
 
-        line == node.last_argument.last_line && node.last_line == node.last_argument.last_line
+        line == node.last_argument.last_line
       end
 
       # A single argument with the closing bracket on the same line as the end
       # of the argument is not considered multiline, even if the argument
       # itself might span multiple lines.
       def allowed_multiline_argument?(node)
-        elements(node).one? && !Util.begins_its_line?(node.loc.end)
+        elements(node).one? && !Util.begins_its_line?(node_end_location(node))
       end
 
       def elements(node)
@@ -122,14 +129,24 @@ module RuboCop
 
       def no_elements_on_same_line?(node)
         items = elements(node).map(&:source_range)
-        items << node.loc.end
+        items << node_end_location(node)
         items.each_cons(2).none? { |a, b| on_same_line?(a, b) }
       end
 
+      def node_end_location(node)
+        node.loc.end || node.source_range.end.adjust(begin_pos: -1)
+      end
+
       def on_same_line?(range1, range2)
         range1.last_line == range2.line
       end
 
+      def last_item_precedes_newline?(node)
+        after_last_item = node.children.last.source_range.end.join(node.source_range.end)
+
+        after_last_item.source.start_with?(/,?\s*(#.*)?\n/)
+      end
+
       def avoid_comma(kind, comma_begin_pos, extra_info)
         range = range_between(comma_begin_pos, comma_begin_pos + 1)
         article = kind.include?('array') ? 'an' : 'a'
@@ -170,7 +187,7 @@ module RuboCop
 
       def heredoc?(node)
         return false unless node.is_a?(RuboCop::AST::Node)
-        return true if node.loc.respond_to?(:heredoc_body)
+        return true if node.loc?(:heredoc_body)
 
         return heredoc_send?(node) if node.send_type?
 

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

@@ -63,9 +63,10 @@ module RuboCop
         (send nil? VISIBILITY_SCOPES def)
       PATTERN
 
+      # A modifier applies to every symbol it is given, not only to a sole argument.
       # @!method visibility_inline_on_method_name?(node, method_name:)
       def_node_matcher :visibility_inline_on_method_name?, <<~PATTERN
-        (send nil? VISIBILITY_SCOPES (sym %method_name))
+        (send nil? VISIBILITY_SCOPES <(sym %method_name) ...>)
       PATTERN
     end
   end

data/lib/rubocop/cop/mixin.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop # rubocop:disable Style/Documentation -- a namespace that only autoloads the mixins below
+    # 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, "#{__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 -- the file is named `auto_corrector.rb`
+    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 :EndlessMethodBodyHelp, "#{__dir__}/mixin/endless_method_body_help"
+    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"
+    # Deprecated aliases of `AllowedMethods` and `AllowedPattern`, defined in those files.
+    autoload :IgnoredMethods, "#{__dir__}/mixin/allowed_methods"
+    autoload :IgnoredPattern, "#{__dir__}/mixin/allowed_pattern"
+    autoload :IndexedMethodArity, "#{__dir__}/mixin/indexed_method_arity"
+    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 :PatternMatchingHelp, "#{__dir__}/mixin/pattern_matching_help"
+    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)
 

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

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Naming
       # Makes sure that certain binary operator methods have their
-      # sole  parameter named `other`.
+      # sole parameter named `other`.
       #
       # @example
       #
@@ -33,6 +33,7 @@ module RuboCop
               node.each_descendant(:lvar, :lvasgn) do |lvar|
                 lvar_location = lvar.loc.name
                 next unless lvar_location.source == arg.source
+                next if shadowed?(lvar, arg.source, node)
 
                 corrector.replace(lvar_location, 'other')
               end
@@ -47,6 +48,21 @@ module RuboCop
 
           !/\A[[:word:]]/.match?(name) || OP_LIKE_METHODS.include?(name)
         end
+
+        # A reference is shadowed when an enclosing block within the method redeclares the
+        # parameter name (as a block parameter or block-local). Such a reference points to
+        # the block's variable, not the operator's parameter, so it must not be renamed.
+        def shadowed?(node, name, def_node)
+          node.each_ancestor(:block).any? do |block|
+            def_node.source_range.contains?(block.source_range) && redeclares?(block, name)
+          end
+        end
+
+        def redeclares?(block, name)
+          block.arguments.any? do |argument|
+            argument.respond_to?(:name) && argument.name.to_s == name
+          end
+        end
       end
     end
   end

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

@@ -14,10 +14,10 @@ module RuboCop
       # autocorrected.
       #
       # [NOTE]
-      # --
+      # ====
       # Because of a bug in Ruby 3.3.0, when a block is referenced inside of another block,
       # no offense will be registered until Ruby 3.4:
-
+      #
       # [source,ruby]
       # ----
       # def foo(&block)
@@ -25,7 +25,7 @@ module RuboCop
       #   block_method { bar(&block) }
       # end
       # ----
-      # --
+      # ====
       #
       # @example EnforcedStyle: anonymous (default)
       #
@@ -62,7 +62,10 @@ module RuboCop
         MSG = 'Use %<style>s block forwarding.'
 
         def self.autocorrect_incompatible_with
-          [Lint::AmbiguousOperator, Style::ArgumentsForwarding, Style::ExplicitBlockArgument]
+          [
+            Lint::AmbiguousOperator, Style::ArgumentsForwarding, Style::EndlessMethod,
+            Style::ExplicitBlockArgument, Style::MethodDefParentheses
+          ]
         end
 
         def on_def(node)

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

@@ -38,7 +38,7 @@ module RuboCop
       class BlockParameterName < Base
         include UncommunicativeName
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler -- there are no parameter names to check
           return unless node.arguments?
 
           check(node, node.arguments)