rubocop 1.71.1 → 1.92.0

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

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     # Common functionality for checking whether an AST node/token is aligned
     # with something on a preceding or following line
-    # rubocop:disable Metrics/ModuleLength
+    # rubocop:disable-next Metrics/ModuleLength
     module PrecedingFollowingAlignment
       # Tokens that end with an `=`, as well as `<<`, that can be aligned together:
       # `=`, `==`, `===`, `!=`, `<=`, `>=`, `<<` and operator assignment (`+=`, etc).
@@ -69,7 +69,15 @@ module RuboCop
           line = processed_source.lines[lineno]
           index = line =~ /\S/
           next unless index
-          next if indent && indent != index
+
+          if indent
+            # When searching for the nearest line with the same indentation,
+            # more deeply indented lines are nested content of the current group
+            # and are skipped, but a less deeply indented line ends the enclosing block:
+            # an alignment anchor beyond it would be coincidental.
+            break if index < indent
+            next if index > indent
+          end
 
           return yield(range, line, lineno + 1)
         end
@@ -166,28 +174,82 @@ module RuboCop
           #                ^
           tokens = remove_equals_in_def(tokens, processed_source)
 
-          # Only attempt to align the first = on each line
-          Set.new(tokens.uniq(&:line))
+          # Only attempt to align the first = on each line. An `=` that comes after a comparison
+          # on its line is left out as well: whether a line is aligned is judged by its first
+          # assignment or comparison operator, so such an `=` could never be found aligned
+          # and `Layout/SpaceAroundOperators` would keep undoing the padding added for it.
+          Set.new(tokens.uniq(&:line).select do |token|
+            first_operator_on_line(token.line).equal?(token)
+          end)
         end
       end
 
       # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
       # rubocop:disable Metrics/PerceivedComplexity, Metrics/MethodLength
       def relevant_assignment_lines(line_range)
+        relevant_lines(line_range, interrupting_operator_lines) do |line_number|
+          assignment_lines.include?(line_number)
+        end
+      end
+
+      def interrupting_operator_lines
+        @interrupting_operator_lines ||=
+          processed_source.tokens.each_with_object(Set.new) do |token, lines|
+            next unless ASSIGNMENT_OR_COMPARISON_TOKENS.include?(token.type)
+
+            lines << token.line unless assignment_lines.include?(token.line)
+          end
+      end
+
+      def alignment_lines(line_number)
+        @alignment_lines_by_line ||= {}
+        return @alignment_lines_by_line[line_number] if @alignment_lines_by_line.key?(line_number)
+
+        lines = alignment_line_ranges(line_number).flatten.uniq.sort.freeze
+
+        lines.each { |line| @alignment_lines_by_line[line] = lines }
+      end
+
+      def alignment_line_ranges(line_number)
+        last_line = processed_source.lines.length
+
+        [
+          relevant_lines(line_number.downto(1), definition_boundary_lines) do |line|
+            !aligned_comment_lines.include?(line)
+          end,
+          relevant_lines(line_number.upto(last_line), definition_boundary_lines) do |line|
+            !aligned_comment_lines.include?(line)
+          end
+        ]
+      end
+
+      def definition_boundary_lines
+        @definition_boundary_lines ||= begin
+          nodes = processed_source.ast&.each_node(:any_def) || []
+
+          nodes.each_with_object(Set.new) do |node, lines|
+            lines << node.first_line << node.last_line
+          end
+        end
+      end
+
+      def relevant_lines(line_range, boundary_lines = [])
         result                        = []
-        original_line_indent          = processed_source.line_indentation(line_range.first)
+        original_line                 = line_range.first
+        original_line_indent          = processed_source.line_indentation(original_line)
         relevant_line_indent_at_level = true
 
         line_range.each do |line_number|
           current_line_indent = processed_source.line_indentation(line_number)
           blank_line          = processed_source.lines[line_number - 1].blank?
 
-          if (current_line_indent < original_line_indent && !blank_line) ||
+          if (line_number != original_line && boundary_lines.include?(line_number)) ||
+             (current_line_indent < original_line_indent && !blank_line) ||
              (relevant_line_indent_at_level && blank_line)
             break
           end
 
-          result << line_number if assignment_lines.include?(line_number) &&
+          result << line_number if yield(line_number) &&
                                    current_line_indent == original_line_indent
 
           unless blank_line
@@ -213,7 +275,16 @@ module RuboCop
 
         asgn_tokens.reject { |t| eqls_to_ignore.include?(t.begin_pos) }
       end
+
+      def first_operator_on_line(line)
+        @first_operator_by_line ||= processed_source.tokens.each_with_object({}) do |token, by_line|
+          next unless ASSIGNMENT_OR_COMPARISON_TOKENS.include?(token.type)
+
+          by_line[token.line] ||= token
+        end
+
+        @first_operator_by_line[line]
+      end
     end
-    # rubocop:enable Metrics/ModuleLength
   end
 end

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

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common helpers for cops that consult the project-wide static-analysis index
+    # via `Cop::Base#project_index`.
+    #
+    # Mixed-in cops gain the `external_dependency_checksum` override that invalidates
+    # the `ResultCache` whenever the indexed project files change on disk.
+    # To run index-backed analysis, cops should simply check whether `project_index` is non-nil;
+    # the runner only exposes a non-nil index when the user opted in via `AllCops/UseProjectIndex`
+    # and the underlying gem is available.
+    module ProjectIndexHelp
+      BUILTIN_DOCUMENT_URI = 'rubydex:built-in'
+      FILE_URI_PREFIX = 'file://'
+      # Matches the spurious leading slash before a Windows drive letter that
+      # 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
+
+        @external_dependency_checksum ||= Digest::SHA1.hexdigest(
+          project_index_signature.join("\n")
+        )
+      end
+
+      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 the `def`/`defs` node overrides a method defined by an ancestor
+      # of its enclosing class or module elsewhere in the project.
+      def overrides_inherited_method?(def_node)
+        return false unless project_index
+        return false unless (namespace_node = def_node.each_ancestor(:class, :module).first)
+
+        declaration = resolve_constant_in_index(namespace_node.identifier)
+        return false unless declaration.is_a?(Rubydex::Namespace)
+
+        scope = def_node.defs_type? ? indexed_singleton_of(declaration) : declaration
+        !scope.nil? && inherited_index_member?(scope, "#{def_node.method_name}()")
+      rescue StandardError
+        false
+      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
+
+          path = uri.delete_prefix(FILE_URI_PREFIX).sub(WINDOWS_DRIVE_PREFIX, '')
+          mtime, size = begin
+            stat = File.stat(path)
+            [stat.mtime.to_f, stat.size]
+          rescue StandardError
+            [0, 0]
+          end
+
+          "#{path}:#{mtime}:#{size}"
+        end.sort
+      end
+    end
+  end
+end

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

@@ -4,9 +4,10 @@ module RuboCop
   module Cop
     # Methods that calculate and return Parser::Source::Ranges
     module RangeHelp
-      private
-
       BYTE_ORDER_MARK = 0xfeff # The Unicode codepoint
+      NOT_GIVEN = Module.new
+
+      private
 
       def source_range(source_buffer, line_number, column, length = 1)
         if column.is_a?(Range)
@@ -33,6 +34,18 @@ module RuboCop
         range_between(node.loc.begin.end_pos, node.loc.end.begin_pos)
       end
 
+      # A range containing the first to the last argument
+      # of a method call or method definition.
+      # def foo(a, b:)
+      #         ^^^^^
+      # bar(1, 2, 3, &blk)
+      #     ^^^^^^^^^^^^^
+      # baz { |x, y:, z:| }
+      #        ^^^^^^^^^
+      def arguments_range(node)
+        node.first_argument.source_range.join(node.last_argument.source_range)
+      end
+
       def range_between(start_pos, end_pos)
         Parser::Source::Range.new(processed_source.buffer, start_pos, end_pos)
       end
@@ -51,7 +64,6 @@ module RuboCop
         Parser::Source::Range.new(buffer, begin_pos, end_pos)
       end
 
-      NOT_GIVEN = Module.new
       def range_with_surrounding_space(range_positional = NOT_GIVEN, # rubocop:disable Metrics/ParameterLists
                                        range: NOT_GIVEN, side: :both, newlines: true,
                                        whitespace: false, continuations: false,
@@ -104,14 +116,13 @@ module RuboCop
         end
       end
 
-      # rubocop:disable Metrics/ParameterLists
+      # rubocop:disable-next Metrics/ParameterLists
       def final_pos(src, pos, increment, continuations, newlines, whitespace)
         pos = move_pos(src, pos, increment, true, /[ \t]/)
         pos = move_pos_str(src, pos, increment, continuations, "\\\n")
         pos = move_pos(src, pos, increment, newlines, /\n/)
         move_pos(src, pos, increment, whitespace, /\s/)
       end
-      # rubocop:enable Metrics/ParameterLists
 
       def move_pos(src, pos, step, condition, regexp)
         offset = step == -1 ? -1 : 0

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