simplecov 1.1.1 → 1.3.0

data/lib/simplecov/static_coverage_extractor/method_collector.rb

@@ -2,15 +2,11 @@
 
 module SimpleCov
   module StaticCoverageExtractor
-    # Visitor mixin that collects method tuples and tracks the lexical
-    # class / module nesting that names them, in the shape Ruby's
-    # `Coverage` reports methods. Mixed into `Visitor`, it shares that
-    # visitor's `@methods` / `@class_stack` state and keeps the
-    # method-collection concern separate from branch extraction.
+    # Visitor mixin that collects method tuples and tracks the lexical class /
+    # module nesting that names them, in the shape Ruby's `Coverage` reports
+    # methods. Module and Class are both namespaces here, since `Coverage` reports
+    # both as the constant.
     module MethodCollector
-      # Track class/module nesting so method tuples carry the lexical
-      # class name. Module + Class are both treated as namespaces here
-      # since `Coverage` reports both as the constant.
       def visit_class_node(node)
         with_class(constant_name(node.constant_path)) { super }
       end
@@ -19,37 +15,24 @@ module SimpleCov
         with_class(constant_name(node.constant_path)) { super }
       end
 
-      # `def name(...)` and `def self.name(...)` both produce DefNode.
-      # The class context is the surrounding lexical class/module (or
-      # `Object` at the top level, matching `Coverage`'s convention).
-      # Suppression covers 3.2's folded dead arms, where nested branches
-      # stay instrumented but a `def` never registers (see
-      # Visitor#visit_dead_arm).
+      # `def name(...)` and `def self.name(...)` both produce DefNode. The class
+      # context is the surrounding lexical class or module, or `Object` at the top
+      # level, matching `Coverage`'s convention.
       def visit_def_node(node)
-        # simplecov:disable branch — suppression is reachable on 3.2 only
-        return super if @suppress_methods
-
-        # simplecov:enable branch
-        loc = node.location
         class_name = @class_stack.last || "Object"
-        key = [class_name, node.name, loc.start_line, loc.start_column, loc.end_line, loc.end_column]
+        key = [class_name, node.name, node.start_line, node.start_column, node.end_line, node.end_column]
         @methods[key] = 0
         super
       end
 
-    private
+      private
 
-      # Render a constant path (e.g., `Foo::Bar`) as its source-form
-      # string. Defensive nil / to_s fallbacks: ClassNode and ModuleNode
-      # always carry a constant_path in practice.
-      # simplecov:disable
       def constant_name(node)
         return "<anonymous>" if node.nil?
         return node.slice if node.respond_to?(:slice)
 
         node.to_s
       end
-      # simplecov:enable
 
       def with_class(name)
         @class_stack.push(name)

data/lib/simplecov/static_coverage_extractor/prism_compat.rb

@@ -2,51 +2,42 @@
 
 module SimpleCov
   module StaticCoverageExtractor
-    # The Prism 1.3 (Dec 2024) accessor renames for the trailing clause of
-    # conditional nodes, resolved ONCE at load so the per-node hot paths
-    # stay branch-free. Ruby 3.3's stdlib Prism (0.19) predates the
-    # renames; 3.4+ and any installed prism gem post-dates them. Reaching
-    # for the modern name on 0.19 raised NoMethodError inside the
-    # extractor — `call` swallowed it and the whole file silently fell
-    # back to no simulated data (see the 1.0.2 audit).
+    # The Prism 1.3 accessor renames for the trailing clause of conditional
+    # nodes, resolved once at load so the per-node hot paths stay branch-free.
+    # Ruby 3.3's stdlib Prism predates the renames; 3.4+ and any installed prism
+    # gem post-date them, and reaching for the modern name on the old one raised
+    # NoMethodError inside the extractor, which `call` swallowed, silently
+    # falling back to no simulated data.
     #
     # This lives in its own file, required by every consumer, because the
-    # constants are referenced from several extractor files and defining
-    # them after those files were loaded worked only while the references
-    # happened at call time — a load-order trap for the next editor.
+    # constants are referenced from several extractor files and defining them
+    # after those files were loaded worked only while the references happened at
+    # call time: a load-order trap for the next editor.
     module PrismCompat
-    module_function
+      extend self
 
-      # `Prism::IfNode#subsequent` was renamed from `consequent`. The
-      # not-taken arm on whichever Prism version we're on can't be
-      # exercised by our own dogfood (we only run on one Prism at a time).
       # simplecov:disable
       IF_NODE_SUBSEQUENT_METHOD =
-        if ::Prism::IfNode.method_defined?(:subsequent)
+        if Prism::IfNode.method_defined?(:subsequent)
           :subsequent
         else
           :consequent
         end
 
-      # The same rename hit the `else` accessor on `UnlessNode`,
-      # `CaseNode`, and `CaseMatchNode` (all three: `consequent` ->
-      # `else_clause`). All three renamed together, so one constant
-      # (probed off CaseNode) covers them.
       ELSE_CLAUSE_METHOD =
-        if ::Prism::CaseNode.method_defined?(:else_clause)
+        if Prism::CaseNode.method_defined?(:else_clause)
           :else_clause
         else
           :consequent
         end
       # simplecov:enable
 
-      # The `else`/`elsif` clause of an if-like node (an ElseNode, or a
-      # nested IfNode for `elsif`), or the `else` clause of anything else
-      # that has one, under whichever accessor this Prism exposes.
       def subsequent(node)
-        node.is_a?(::Prism::IfNode) ? node.public_send(IF_NODE_SUBSEQUENT_METHOD) : else_clause(node)
+        node.instance_of?(Prism::IfNode) ? node.public_send(IF_NODE_SUBSEQUENT_METHOD) : else_clause(node)
       end
 
+      # The rename hit `UnlessNode`, `CaseNode`, and `CaseMatchNode` together, so
+      # one constant probed off CaseNode covers all three.
       def else_clause(node)
         node.public_send(ELSE_CLAUSE_METHOD)
       end

data/lib/simplecov/static_coverage_extractor/value_position.rb

@@ -5,33 +5,24 @@ require_relative "prism_compat"
 module SimpleCov
   module StaticCoverageExtractor
     # Ruby 3.3 value-position analysis for the extractor's legacy branch
-    # conventions (see LocationConventions and the #1233 audit).
+    # conventions (#1233). On 3.3 the source range Coverage assigns to an empty
+    # branch arm depends on whether its construct is in value position, where its
+    # result is the method's return value, or void position, where the result is
+    # discarded. Value position keeps the whole-construct range; void collapses
+    # the arm to a point at its header's end. Ruby 3.4 dropped the distinction.
     #
-    # On Ruby 3.3, the source range Coverage assigns to an EMPTY branch arm
-    # depends on whether its construct is in value position — its result is
-    # the method's return value — or void position, where the result is
-    # discarded. Value position keeps the whole-construct range; void
-    # collapses the arm to a point at its header's end. Ruby 3.4 dropped the
-    # distinction, so this pass only runs on legacy Rubies.
-    #
-    # "Value position" here is narrower than general value-use: it is
-    # strictly method-return (tail) position. It reaches a node only through
-    # statement tails and `if`/`unless`/`when` arms. Assignments, blocks,
-    # lambdas, method arguments, `case/in` arms, and loop bodies all discard
-    # it (Coverage treats their empty arms as void). So `tail_children`
-    # names the constructs that forward tail position and everything else
-    # falls through to the void default.
+    # "Value position" here is strictly method-return (tail) position. It reaches
+    # a node only through statement tails and `if`/`unless`/`when` arms.
+    # Assignments, blocks, lambdas, method arguments, `case/in` arms, and loop
+    # bodies all discard it, so `tail_children` names the constructs that forward
+    # tail position and everything else falls through to the void default.
     module ValuePositions
-    module_function
-
-      # simplecov:disable
-      # This whole pass runs only on legacy Rubies (the modern dogfood
-      # never calls it), so its lines can't be covered on the CI Ruby that
-      # enforces 100%. Behavior is pinned instead by the differential
-      # tuple-equivalence spec, which runs against real Coverage on 3.3.
+      extend self
 
-      # An identity set (a `compare_by_identity` Hash used as a set) of the
-      # Prism nodes Coverage treats as being in value position.
+      # An identity set of the Prism nodes Coverage treats as being in value
+      # position. This pass runs natively only on legacy Rubies; elsewhere the
+      # specs drive it directly, pinned by the differential tuple-equivalence spec
+      # against real Coverage on 3.3.
       def call(root)
         positions = {} #: Hash[untyped, bool]
         positions.compare_by_identity
@@ -40,7 +31,7 @@ module SimpleCov
       end
 
       def mark(node, in_value, positions)
-        return unless node.is_a?(::Prism::Node)
+        return unless node.is_a?(Prism::Node)
 
         positions[node] = true if in_value
         children = tail_children(node, in_value)
@@ -49,26 +40,22 @@ module SimpleCov
         end
       end
 
-      # The children of `node` that inherit its tail position; empty for the
-      # void default. A method body is a tail context even when the `def`
-      # itself is not (the method still returns its last expression), so it
-      # is included regardless of `in_value`.
+      # A method body is a tail context even when the `def` itself is not, since
+      # the method still returns its last expression, so it is included regardless
+      # of `in_value`. `case/in` is intentionally absent: its `in` arms and `else`
+      # both discard tail position.
       def tail_children(node, in_value)
-        # A method body is a tail context even when the `def` is not.
-        return [node.body] if node.is_a?(::Prism::DefNode)
+        return [node.body] if node.instance_of?(Prism::DefNode)
         return [] unless in_value
 
-        # `case/in` (CaseMatchNode) is intentionally not a tail construct:
-        # its `in` arms and `else` both discard tail position.
         case node
-        when ::Prism::StatementsNode then [node.body.last]
-        when ::Prism::IfNode, ::Prism::UnlessNode then [node.statements, PrismCompat.subsequent(node)]
-        when ::Prism::CaseNode then [*node.conditions, PrismCompat.else_clause(node)]
-        when ::Prism::ElseNode, ::Prism::WhenNode, ::Prism::BeginNode, ::Prism::ProgramNode then [node.statements]
+        when Prism::StatementsNode then [node.body.last]
+        when Prism::IfNode, Prism::UnlessNode then [node.statements, PrismCompat.subsequent(node)]
+        when Prism::CaseNode then [*node.conditions, PrismCompat.else_clause(node)]
+        when Prism::ElseNode, Prism::WhenNode, Prism::BeginNode, Prism::ProgramNode then [node.statements]
         else []
         end
       end
-      # simplecov:enable
     end
   end
 end

data/lib/simplecov/static_coverage_extractor/visitor.rb

@@ -8,27 +8,22 @@ require_relative "value_position"
 
 module SimpleCov
   module StaticCoverageExtractor
-    # Prism visitor that accumulates branch and method tuples in the
-    # shape Ruby's `Coverage` reports. Tuple ids are sequential across
-    # the file like `Coverage`'s, but the numbering order can differ
-    # (e.g. `case`/`when` and chained `&.` are visited in a different
-    # order than Coverage numbers them). That's fine: the combiners
-    # intern on source span and the report output drops ids, so nothing
-    # downstream compares them. Only defined when Prism is loadable;
-    # `StaticCoverageExtractor.available?` is the runtime gate.
-    class Visitor < ::Prism::Visitor
-      # Method tuples and the class/module nesting that names them are
-      # collected by this mixin; this class focuses on branch extraction.
+    # Prism visitor that accumulates branch and method tuples in the shape
+    # Ruby's `Coverage` reports. Tuple ids are sequential across the file like
+    # `Coverage`'s, but the numbering order can differ. That's fine: the
+    # combiners intern on source span and the report output drops ids, so
+    # nothing downstream compares them.
+    class Visitor < Prism::Visitor
       include MethodCollector
-      # Source-range resolution, including the per-Ruby-version Coverage
-      # conventions. See issue #1226.
       include LocationConventions
-      # Which literal `if`/`unless`/ternary conditions the compiler folds
-      # away (so we emit no branch for them).
       include ConditionFolding
 
       attr_reader :branches, :methods
 
+      # Prism's Visitor is a stateless dispatch table whose initializer is
+      # Object's, so no mutation of the `super` call can be told apart. It
+      # stays for the day that stops being true.
+      # mutant:disable
       def initialize
         super
         @branches = {}
@@ -36,35 +31,25 @@ module SimpleCov
         @next_id = 0
         @class_stack = []
         @value_positions = nil
-        @suppress_methods = false
       end
 
-      # Entry point for a parsed file. On legacy Rubies the location of an
-      # empty branch arm depends on whether its construct is in value
-      # (tail) position, so precompute that once for the whole tree before
-      # emitting anything. Modern Rubies don't need it (see
-      # LocationConventions), so the pass is skipped there.
+      # On legacy Rubies the location of an empty branch arm depends on whether
+      # its construct is in value (tail) position, so precompute that once for
+      # the whole tree before emitting anything.
       def visit_program_node(node)
-        # simplecov:disable branch — legacy-only arm; unreachable on the modern dogfood Ruby
         @value_positions = ValuePositions.call(node) if LEGACY_COVERAGE_LOCATIONS
-        # simplecov:enable branch
         super
       end
 
-      # `if` / `unless` / postfix-if / postfix-unless / ternary all parse
-      # as IfNode (or UnlessNode). Both carry a `then` arm (the
-      # statements body) and an optional `subsequent` (an ElseNode for
-      # `else`, another IfNode for `elsif`). When the subsequent is
-      # missing, Coverage synthesizes a `:else` arm attributed to the
-      # whole condition's range — we do the same.
+      # `if` / `unless` / postfix / ternary all parse as IfNode (or UnlessNode).
+      # Both carry a `then` arm and an optional `subsequent` (an ElseNode for
+      # `else`, another IfNode for `elsif`). When the subsequent is missing,
+      # Coverage synthesizes a `:else` arm attributed to the whole condition's
+      # range, and so do we.
       #
-      # A folded condition emits no tuple, and on modern Rubies only its
-      # live arm is descended into: the compiler eliminates the dead
-      # arm's entire subtree, so a branch or method nested there would be
-      # a phantom no loaded run can produce. A falsy `if`'s elsif chain
-      # survives as a plain `if`, which is what visiting the subsequent
-      # IfNode emits. On 3.2 the dead arm is visited too, branches only
-      # (see visit_folded_arms).
+      # A folded condition emits no tuple, and only its live arm is descended
+      # into: the compiler eliminates the dead arm's entire subtree, so a branch
+      # or method nested there would be a phantom no loaded run can produce.
       def visit_if_node(node)
         verdict = folded_condition(node.predicate)
         return visit_folded_arms(verdict, node.statements, PrismCompat.subsequent(node)) if verdict
@@ -86,9 +71,8 @@ module SimpleCov
         super
       end
 
-      # `case`/`when` and `case`/`in` (pattern matching) parse as CaseNode
-      # and CaseMatchNode respectively. When there's no explicit `else`,
-      # Coverage synthesizes one at the case's range.
+      # When there's no explicit `else`, Coverage synthesizes one at the case's
+      # range.
       def visit_case_node(node)
         emit_case_like(node, :when)
         super
@@ -99,26 +83,22 @@ module SimpleCov
         super
       end
 
-      # One-line pattern matching: `x => pattern` (MatchRequiredNode) and
-      # `x in pattern` (MatchPredicateNode). Ruby 3.3's Coverage reports
-      # these as a `:case` with an `:in` and an `:else` arm; 3.4 dropped
-      # them entirely (no branch), so this is legacy-only. The two forms
-      # differ only in where Coverage anchors the synthesized `:else`:
-      # `=>` uses the whole expression, `in` uses just the pattern.
-      # simplecov:disable branch — legacy-only arms; unreachable on the modern dogfood Ruby
+      # One-line pattern matching: `x => pattern` and `x in pattern`. Ruby 3.3's
+      # Coverage reports these as a `:case` with an `:in` and an `:else` arm;
+      # 3.4 dropped them entirely, so this is legacy-only. The two forms differ
+      # only in where Coverage anchors the synthesized `:else`: `=>` uses the
+      # whole expression, `in` uses just the pattern.
       def visit_match_required_node(node)
-        emit_oneline_pattern(node, node.location) if LEGACY_COVERAGE_LOCATIONS
+        emit_oneline_pattern(node, node) if LEGACY_COVERAGE_LOCATIONS
         super
       end
 
       def visit_match_predicate_node(node)
-        emit_oneline_pattern(node, node.pattern.location) if LEGACY_COVERAGE_LOCATIONS
+        emit_oneline_pattern(node, node.pattern) if LEGACY_COVERAGE_LOCATIONS
         super
       end
-      # simplecov:enable branch
 
-      # `while` / `until` loops get a single `:body` arm. No synthetic
-      # else (the loop either runs the body or doesn't).
+      # A loop gets a single `:body` arm and no synthetic else.
       def visit_while_node(node)
         emit_loop(node, :while)
         super
@@ -129,11 +109,10 @@ module SimpleCov
         super
       end
 
-    private
+      private
 
-      # IfNode and UnlessNode share a shape (predicate + then body +
-      # optional else/elsif) but expose the trailing arm under different
-      # accessors. `if_like_else_location` hides that split.
+      # IfNode and UnlessNode share a shape but expose the trailing arm under
+      # different accessors, which `if_like_else_location` hides.
       def emit_if_like(node, type)
         then_loc = if_like_then_location(node, type)
         else_loc = if_like_else_location(node, type)
@@ -151,32 +130,33 @@ module SimpleCov
         }
       end
 
-      # simplecov:disable — legacy-only (3.4 emits no branch for one-line patterns)
-      def emit_oneline_pattern(node, else_location)
-        @branches[build_tuple(:case, node.location)] = {
-          build_tuple(:in, node.pattern.location) => 0,
-          build_tuple(:else, else_location) => 0
+      def emit_oneline_pattern(node, else_span)
+        @branches[build_tuple(:case, node)] = {
+          build_tuple(:in, node.pattern) => 0,
+          build_tuple(:else, else_span) => 0
         }
       end
-      # simplecov:enable
 
       def emit_case_like(node, when_type)
         arms = node.conditions.to_h do |when_node|
           [build_tuple(when_type, case_arm_location(node, when_node, when_type)), 0]
         end
         arms[build_tuple(:else, else_arm_location(node))] = 0
-        @branches[build_tuple(:case, node.location)] = arms
+        @branches[build_tuple(:case, node)] = arms
       end
 
       def emit_loop(node, type)
-        cond_tuple = build_tuple(type, node.location)
+        cond_tuple = build_tuple(type, node)
         @branches[cond_tuple] = {build_tuple(:body, loop_body_location(node)) => 0}
       end
 
-      def build_tuple(type, location)
+      # `span` is anything that answers the four position accessors: a location
+      # from LocationConventions, or the node itself where the range wanted is
+      # the node's own.
+      def build_tuple(type, span)
         id = @next_id
         @next_id += 1
-        [type, id, location.start_line, location.start_column, location.end_line, location.end_column]
+        [type, id, span.start_line, span.start_column, span.end_line, span.end_column]
       end
     end
   end

data/lib/simplecov/static_coverage_extractor.rb

@@ -1,110 +1,78 @@
 # frozen_string_literal: true
 
-begin
-  require "prism"
-rescue LoadError
-  # Prism isn't available on this Ruby (older than 3.3 without the gem).
-  # `StaticCoverageExtractor.available?` will return false and callers
-  # fall back to the previous "empty hashes" behavior.
-end
+require "prism"
 
 module SimpleCov
   # Static enumeration of the branches and methods Ruby's `Coverage` library
-  # WOULD have reported if a file had been loaded with `branches: true` /
+  # would have reported if a file had been loaded with `branches: true` /
   # `methods: true`. Used by `SimulateCoverage` to backfill data for files
-  # added via `cover` / `track_files` that were never `require`'d during the
-  # run — so unloaded files contribute to the branch/method denominators
-  # symmetrically with their line coverage, instead of vanishing from the
-  # totals (see #1059).
-  #
-  # Implementation uses Prism (stdlib in Ruby 3.3+, gem on older Rubies).
-  # When Prism isn't available, `available?` returns false and SimulateCoverage
-  # falls back to the previous behavior — older Rubies keep working, just
-  # without the synthesized data.
+  # added via `cover` / `track_files` that were never required during the run,
+  # so unloaded files contribute to the branch/method denominators
+  # symmetrically with their line coverage (#1059).
   #
-  # The emitted shape mirrors `Coverage.result[path]` for the same file:
-  # branches are nested as `{condition_tuple => {arm_tuple => 0, ...}}` and
-  # methods as `{["ClassName", :name, lines/cols] => 0}`. Position info
-  # comes from Prism's reported source locations; it doesn't always match
-  # `Coverage`'s byte-for-byte (the two parsers report slightly different
-  # column conventions for some constructs), but lines are reliable and
-  # downstream consumers that key off line numbers (the HTML formatter,
-  # SonarQube, etc.) see the data they expect.
+  # The emitted shape mirrors `Coverage.result[path]` for the same file.
+  # Position info comes from Prism's reported source locations; it doesn't
+  # always match `Coverage`'s byte-for-byte, but lines are reliable and
+  # downstream consumers that key off line numbers see the data they expect.
   module StaticCoverageExtractor
-  module_function
+    extend self
 
-    # simplecov:disable branch
-    # The Prism-unavailable arm of this ternary is unreachable when Prism
-    # itself IS loadable — i.e., on every engine that exercises the dogfood
-    # report. Asserted-on by callers; tested indirectly via the
-    # `available?`-returns-false fallback path in SimulateCoverage's spec.
-    def available?
-      defined?(::Prism) ? true : false
-    end
-    # simplecov:enable branch
-
-    # Parse `source` (a string of Ruby) and return a hash of the form
-    # `{"branches" => {...}, "methods" => {...}}` matching the shape that
-    # `Coverage.result[path]` produces. Returns nil on parse failure or
-    # when Prism isn't available; callers should treat that as "couldn't
-    # extract — fall back to empty hashes."
+    # Parse `source` and return `{"branches" => {...}, "methods" => {...}}`
+    # matching the shape `Coverage.result[path]` produces. Returns nil on parse
+    # failure, which callers treat as "couldn't extract, fall back to empty
+    # hashes".
     def call(source)
-      # simplecov:disable branch — `then` arm unreachable when Prism IS loadable
-      return nil unless available?
-
-      # simplecov:enable branch
-
-      result = ::Prism.parse(source)
+      result = Prism.parse(source)
       return nil if result.failure?
 
       visitor = Visitor.new
       visitor.visit(result.value)
       {"branches" => visitor.branches, "methods" => visitor.methods}
-    rescue StandardError
-      # simplecov:disable line
-      # Parser errors beyond the .failure? check, unsupported AST shapes,
-      # or anything else: fall back to empty hashes rather than crashing
-      # the whole report. Defensive; hard to trigger from a real source
-      # input that Prism accepts at parse time.
+    rescue
+      # Parser errors beyond the .failure? check, unsupported AST shapes, or
+      # anything else: fall back to empty hashes rather than crashing the whole
+      # report.
       nil
-      # simplecov:enable line
     end
 
-    # Summarize a source file's REAL branch and method positions, for the
-    # `:eval_generated` filter (SimpleCov.ignore_branches /
-    # SimpleCov.ignore_methods, #1046). Returns a hash:
+    # Summarize a source file's real branch and method positions, for the
+    # `:eval_generated` filter (#1046). Answers:
     #
     #   {
     #     branches: Set[start_line, ...],         # e.g., [3, 12, 20]
     #     methods:  Set[[name, start_line], ...]  # e.g., [[:foo, 7], [:bar, 13]]
     #   }
     #
-    # Branch matching is start_line-only rather than by the full tuple.
-    # Static extraction and Coverage can still disagree on a branch's exact
-    # column positions (and, for some constructs, its type), so matching on
-    # start_line alone is the conservative choice that tolerates those
-    # differences. Coincidental line-sharing between a real branch and an
-    # eval-generated one will keep both, which is an acceptable
-    # false-negative for an opt-in filter. Method matching uses
-    # (name, start_line) since a method name is unique at any line.
+    # Branch matching is start_line-only rather than by the full tuple. Static
+    # extraction and Coverage can still disagree on a branch's exact column
+    # positions, so matching on start_line alone tolerates those differences.
+    # Coincidental line-sharing between a real branch and an eval-generated one
+    # keeps both, an acceptable false-negative for an opt-in filter.
     #
-    # Returns nil when Prism is unavailable or parsing fails, signaling
-    # callers to keep every Coverage entry (no false drops).
+    # Returns nil when parsing fails, signaling callers to keep every Coverage
+    # entry.
     def real_source_positions(source)
       extracted = call(source)
       return nil unless extracted
 
       {
-        branches: extracted["branches"].keys.to_set { |tuple| tuple[2] },
-        methods: extracted["methods"].keys.to_set { |tuple| [tuple[1], tuple[2]] }
+        branches: extracted.fetch("branches").keys.to_set { |tuple| branch_start_line(*tuple) },
+        methods: extracted.fetch("methods").keys.to_set { |tuple| method_identity(*tuple) }
       }
     end
+
+    # Both keys carry their start line third, after the parts that vary between
+    # recordings. Read through a parameter list rather than an index, because
+    # every spelling of an index answers the same for a tuple of this fixed
+    # shape. Binding an argument has only the one spelling.
+    def branch_start_line(_type, _id, start_line, *)
+      start_line
+    end
+
+    def method_identity(_class_name, name, start_line, *)
+      [name, start_line]
+    end
   end
 end
 
-# simplecov:disable branch
-# The `else` arm (Prism missing) is unreachable on engines where the
-# dogfood report runs; the Visitor class only matters when Prism is
-# loadable.
-require_relative "static_coverage_extractor/visitor" if SimpleCov::StaticCoverageExtractor.available?
-# simplecov:enable branch
+require_relative "static_coverage_extractor/visitor"

data/lib/simplecov/test_tracker/accessors.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  class TestTracker
+    module Accessors
+      # Records the block's coverage delta as covered by `test_id`, returning the
+      # block's value. This is the seam test frameworks hang per-test tracking on. A
+      # no-op, with the block still running, unless `track_tests` is enabled and
+      # tracking has started, so callers never guard it.
+      def track_test(test_id, &)
+        tracker = test_tracker
+        return yield unless tracker
+
+        tracker.track(test_id, &)
+      end
+
+      def test_tracker
+        @test_tracker
+      end
+
+      # @api private. Reuses the tracker across repeated `start` calls for the same
+      # reason `Coverage` keeps counting across them: restarting must not lose what
+      # the process already recorded. The framework hooks are only wired up on the
+      # first.
+      def start_test_tracking
+        validate_test_tracking!
+        return unless track_tests? && test_tracker.nil?
+
+        @test_tracker = TestTracker.new(granularity: track_tests_granularity)
+        TestTracker.install_framework_hooks
+      end
+    end
+  end
+end