simplecov 1.1.0 → 1.2.0

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. Only defined when Prism is loadable.
+    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 = {}
@@ -39,32 +34,25 @@ module SimpleCov
         @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 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. On 3.2 the dead arm is visited too, branches
+      # only.
       def visit_if_node(node)
         verdict = folded_condition(node.predicate)
         return visit_folded_arms(verdict, node.statements, PrismCompat.subsequent(node)) if verdict
@@ -86,9 +74,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 +86,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 +112,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 +133,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

@@ -4,107 +4,91 @@ 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.
+  # `StaticCoverageExtractor.available?` will return false and callers fall
+  # back to the previous "empty hashes" behavior.
 end
 
 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).
+  # 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).
   #
-  # 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.
-  #
-  # 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
+      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 or when Prism isn't available, 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 Prism is unavailable or 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.
+# 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

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

data/lib/simplecov/test_tracker/constant_watch.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  class TestTracker
+    # A one-shot watch that runs a callback the moment a constant of a given name
+    # is defined under a host module, via Ruby's `Module#const_added`.
+    # `TestTracker` uses it to install the Minitest wrapper in the ordering
+    # minitest 6 abandoned plugins for: SimpleCov starts first, as coverage must
+    # to see the app load, and minitest is required later, so nothing of
+    # minitest's exists yet to hook into.
+    #
+    # Each watch is its own Module so it can be prepended to the host's singleton
+    # class and compose with any `const_added` the host already has. A prepend
+    # cannot be removed, so after firing the watch stays in place as a name
+    # comparison per constant definition, which is as close to free as Ruby gets.
+    class ConstantWatch < Module
+      # No `super`: it would forward the implicit block even given explicit
+      # arguments, and `Module#initialize` module_evals any block it gets.
+      def initialize(name, &on_added)
+        @name = name
+        @on_added = on_added
+        watch = self #: ConstantWatch
+        define_method(:const_added) do |added|
+          super(added) # steep:ignore UnexpectedPositionalArgument
+          watch.notice(added)
+        end
+      end
+
+      # `host.const_added` runs with the host as self, so reaching this watch's
+      # state takes the closure. At runtime the `super` inside is the host's next
+      # `const_added`; Steep resolves a define_method block's super against the
+      # lexically enclosing method instead.
+      def attach(host)
+        host.singleton_class.prepend(self)
+        self
+      end
+
+      def notice(added)
+        return unless added.equal?(@name)
+
+        callback = @on_added
+        return unless callback
+
+        @on_added = nil
+        callback.call
+      end
+    end
+  end
+end

data/lib/simplecov/test_tracker/delta.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  class TestTracker
+    # The peek-diff arithmetic behind the tracker: which in-root lines grew
+    # between two coverage snapshots. This is the part a native
+    # `Coverage.supported?(:contexts)` engine would replace outright.
+    class Delta
+      def initialize(root_regex:)
+        @root_regex = root_regex
+        @in_root = {} #: Hash[String, bool]
+      end
+
+      # Files outside the root are skipped; a file absent from `before` was loaded
+      # by the test itself, so everything it executed is the test's. The root match
+      # is memoized, so the regex runs once per file the process ever loads rather
+      # than once per file per test.
+      def call(before, after)
+        changed = {} #: Hash[String, Integer]
+        after.each do |path, file_coverage|
+          in_root = @in_root.fetch(path) { @in_root[path] = @root_regex.match?(path) }
+          next unless in_root
+
+          bitmap = line_delta(lines_in(before[path]), lines_in(file_coverage))
+          changed[path] = bitmap unless bitmap.zero?
+        end
+        changed
+      end
+
+      private
+
+      # A peek's per-file data is a criteria Hash when Coverage was started with a
+      # criteria hash, and a bare Array under the older lines-only form. No lines
+      # at all, from a branch-only or method-only start, means nothing to diff.
+      def lines_in(file_coverage)
+        case file_coverage
+        when Hash then file_coverage[:lines]
+        when Array then file_coverage
+        end
+      end
+
+      # The equality check is the overwhelmingly common case, the test never
+      # entering this file: an Array compare is fast C, the per-line loop is not.
+      #
+      # The bitmap is built as a binary string in one pass, so the
+      # arbitrary-precision math happens once per file rather than one bignum OR
+      # per executed line. The string reads lowest line first and the number wants
+      # it the other way round; the leading zero keeps the parse valid for an
+      # all-zero delta without changing any value.
+      def line_delta(before_lines, after_lines)
+        return 0 unless after_lines
+        return 0 if before_lines.eql?(after_lines)
+
+        bits = +""
+        after_lines.each_with_index do |count, index|
+          bits << (grew?(count, before_lines&.at(index)) ? "1" : "0")
+        end
+        Integer("0#{bits.reverse}", 2)
+      end
+
+      # `previous` is nil both for a non-executable line, whose count is nil too,
+      # and for a file the test itself loaded, where every executed line is the
+      # test's.
+      def grew?(count, previous)
+        !count.nil? && count > (previous || 0)
+      end
+    end
+  end
+end

data/lib/simplecov/test_tracker/framework_hooks.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  # The test-framework side of per-test tracking: how the wrapper gets
+  # installed into RSpec and Minitest, and how each framework's tests are
+  # identified. The recording itself lives in test_tracker.rb.
+  class TestTracker
+    class << self
+      def install_framework_hooks
+        install_rspec_hook
+        install_minitest_hook_when_loaded
+      end
+
+      # Wraps every RSpec example in a `track_test` call. Called from
+      # `SimpleCov.start_tracking`, where RSpec is already loaded when the suite
+      # is an RSpec suite. Installs once per process no matter how often
+      # tracking is restarted.
+      def install_rspec_hook(rspec = rspec_module)
+        return unless rspec
+        return if @rspec_hook_installed
+
+        @rspec_hook_installed = true
+        rspec.configure do |config|
+          # The block runs instance-eval'd in the example group, so everything it
+          # touches must be fully qualified.
+          config.around do |example|
+            SimpleCov.track_test(TestTracker.rspec_example_id(example)) { example.run }
+          end
+        end
+      end
+
+      # The RSpec this process has, if it has one. A Minitest-only suite has
+      # none, and no example can make this process into one: hiding the RSpec
+      # constant takes down the very runner asking the question.
+      # simplecov:disable branch — the RSpec-less arm is unreachable from an RSpec-driven suite
+      # mutant:disable
+      def rspec_module
+        ::RSpec if defined?(::RSpec.configure)
+      end
+      # simplecov:enable branch
+
+      # @api private -- test seam, so specs can exercise installation repeatedly
+      # without touching the process-wide guard for real.
+      def reset_rspec_hook!
+        @rspec_hook_installed = false
+      end
+
+      # Called by the minitest plugin under minitest 5, and by the constant
+      # watch below under minitest 6, whose autorun no longer discovers
+      # plugins. Prepending a module already in the chain is a no-op, which is
+      # the whole of the idempotence.
+      def install_minitest_hook(test_case = (Minitest::Test if defined?(Minitest::Test)))
+        return if test_case.nil?
+
+        test_case.prepend(MinitestRun)
+      end
+
+      # Installs the Minitest wrapper now when Minitest is already loaded, and
+      # otherwise the moment `Minitest::Test` is defined. The deferred half is
+      # what covers minitest 6 under the canonical helper ordering (SimpleCov
+      # first, so coverage sees the app load; minitest after), where no plugin
+      # ever fires. `root` is Object outside of tests.
+      def install_minitest_hook_when_loaded(root = Object)
+        minitest = loaded_const(root, :Minitest)
+        test_case = minitest && loaded_const(minitest, :Test)
+        return install_minitest_hook(test_case) if test_case
+        return watch_for_minitest_test(minitest) if minitest
+
+        ConstantWatch.new(:Minitest) do
+          # `loaded_const` rather than the block capturing a module: the module
+          # does not exist yet when the watch is armed.
+          watch_for_minitest_test(loaded_const(root, :Minitest))
+        end.attach(root)
+      end
+
+      # Relative the way RSpec prints it (`./spec/a_spec.rb:12` becomes
+      # `spec/a_spec.rb:12`).
+      def rspec_example_id(example)
+        example.metadata.fetch(:location).delete_prefix("./")
+      end
+
+      # An autoload declaration fires `const_added` without the module existing
+      # yet; that arrangement is left to the plugin, so nil means nothing to
+      # watch.
+      def watch_for_minitest_test(minitest)
+        return unless minitest
+
+        ConstantWatch.new(:Test) { install_minitest_hook(loaded_const(minitest, :Test)) }.attach(minitest)
+      end
+
+      # The constant when it is genuinely loaded, nil when absent or merely
+      # declared for autoload: const_get would force such a load, and installing
+      # a coverage hook must never be what requires a test framework.
+      def loaded_const(mod, name)
+        return nil unless mod.const_defined?(name, false)
+        return nil if mod.autoload?(name, false)
+
+        mod.const_get(name)
+      end
+
+      # A Minitest test's identity: the `path:line` where the test method is
+      # defined, relative to `SimpleCov.root`. Falls back to
+      # `ClassName#method_name` when the method has no source location.
+      def minitest_test_id(test)
+        path, line = definition_site(test)
+        return "#{test.class}##{test.name}" unless path
+
+        "#{path.delete_prefix(File.join(SimpleCov.root, ""))}:#{line}"
+      end
+
+      # A method defined in C or through an eval without a filename has no site,
+      # and a runner exotic enough to name a method it never defined deserves
+      # an id over an exception out of the middle of its run.
+      def definition_site(test)
+        test.method(test.name).source_location
+      rescue NameError
+        nil
+      end
+    end
+
+    # Prepended to `Minitest::Test` by `install_minitest_hook`, wrapping each
+    # test method run, setup and teardown included: a line only a setup block
+    # reaches is still this test's line.
+    module MinitestRun
+      def run
+        SimpleCov.track_test(TestTracker.minitest_test_id(self)) { super }
+      end
+    end
+  end
+end