rigortype 0.4.6 → 0.4.8

data/lib/rigor/analysis/crash_signature.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../source/node_children"
+
 module Rigor
   module Analysis
     # Issues #665 / #674 / #683 / #686 / #696 — the ONE definition of "an internal failure made this run
@@ -104,12 +106,52 @@ module Rigor
       # into. Built here, not at either rescue site, so the two twins cannot drift (issue #665) — and so
       # the appended crash frame is derived identically on the sequential and pooled paths. Keeps the
       # {CHECK_RULE_MESSAGE_PREFIX} prefix every consumer matches on; the frame is a trailing hint.
-      def check_rule_message(error)
+      def check_rule_message(error, root = nil)
+        return stack_overflow_message(error, root) if error.is_a?(SystemStackError)
+
         base = "#{CHECK_RULE_MESSAGE_PREFIX}: #{error.class}: #{error.message}"
         frame = crash_frame(error)
         frame ? "#{base} (#{frame})" : base
       end
 
+      # The crash-row message for a rescued error, for the per-file rescues of `Runner` and `WorkerSession`. Re-raises a
+      # `SystemStackError` raised from C (no backtrace): that one leaves no stack to recover on and a second would kill
+      # the process with a signal, so it keeps the run-level abort ({CLI::FATAL_ERRORS}, exit 70). `parse_result` may be
+      # nil when the error predates the parse.
+      def contained_message!(error, parse_result)
+        raise error if error.is_a?(SystemStackError) && error.backtrace.nil?
+
+        check_rule_message(error, parse_result&.value)
+      end
+
+      # #2455 — the AST depth above which a `SystemStackError` is read as the file's own nesting rather than a Rigor
+      # recursion defect. The recursive walkers overflow from about 700 nested `if`s (twice as many AST levels) and
+      # 1,300 nested array literals or chained calls, so a file past this bound is one they cannot be expected to walk.
+      DEEP_NESTING_BOUND = 500
+
+      DEEP_NESTING_DETAIL = "this file is nested too deeply to analyse (stack level too deep); " \
+                            "split the deeply nested expression"
+      STACK_DEFECT_DETAIL = "stack level too deep; this is a defect in Rigor, please report it at " \
+                            "https://github.com/rigortype/rigor/issues"
+
+      # No crash frame: the frame that overflowed is whichever the stack ran out in, which differs by mode and cache and
+      # would make the row unstable. `root` is nil when the file never parsed, which reads as the defect wording.
+      def stack_overflow_message(error, root)
+        deep = !root.nil? && Source::NodeChildren.nested_deeper_than?(root, DEEP_NESTING_BOUND)
+        "#{CHECK_RULE_MESSAGE_PREFIX}: #{error.class}: #{deep ? DEEP_NESTING_DETAIL : STACK_DEFECT_DETAIL}"
+      end
+
+      # ADR-129 WD5 (#2785) — `diagnostics` (one file's) with a crash row for each of `errors`, raised errors the
+      # typing path may have swallowed under a `rescue StandardError` (`MemoAudit`'s mismatches), so a swallowed one
+      # is reported exactly as one no rescue caught. An error that did reach the file's crash row is not repeated.
+      def with_swallowed(path, diagnostics, errors)
+        return diagnostics if errors.empty?
+
+        seen = diagnostics.map(&:message)
+        rows = errors.map { |error| check_rule_message(error) }.uniq.reject { |message| seen.include?(message) }
+        diagnostics + rows.map { |message| Diagnostic.new(path: path, line: 1, column: 1, message: message) }
+      end
+
       # The first `lib/rigor/` backtrace frame — the raise site, path made repo-relative so it reads the
       # same whether Rigor runs from a checkout or an installed gem. A LOCATION, not an attribution: a
       # bundled or third-party plugin also lives under `lib/rigor/<plugin>/`, so a frame here says where
@@ -149,8 +191,8 @@ module Rigor
 
       # True when `diagnostic` reports a failure inside Rigor that left the run readable but invalid as a
       # measurement of Rigor — see {ANALYZER_DEFECT_RULES}. Orthogonal to {.discards_file_analysis?}: the
-      # user-facing tier reads the run; the Rigor-measuring tier should refuse it (the mutation fuzz does,
-      # the ADR-69 kill oracle does not yet — #790).
+      # user-facing tier reads the run; the Rigor-measuring tier should refuse it (the mutation fuzz and the
+      # ADR-69 kill oracle both do, #790).
       def analyzer_defect?(diagnostic)
         ANALYZER_DEFECT_RULES.include?(diagnostic.rule)
       end

data/lib/rigor/analysis/dependency_recorder.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../typing_state"
+
 module Rigor
   module Analysis
     # ADR-46 slice 1 — records, per analyzed file, which OTHER source files its analysis read declarations /
@@ -12,9 +14,67 @@ module Rigor
     #
     # Modelled on {Inference::BudgetTrace}: process-thread-local state, a cheap disabled fast path, and a
     # frozen snapshot for consumers.
-    module DependencyRecorder
-      KEY = :__rigor_dependency_recorder__
-      private_constant :KEY
+    module DependencyRecorder # rubocop:disable Metrics/ModuleLength
+      # ADR-129 WD1 — the installed accumulator is a Frame whose contents are a Resource for its suspension count, the
+      # one mutation that touches ({record_for}); its filings are entries of the bound Table {READS} and are journaled
+      # instead. WD4 shuts the `type_of` memo under recording only until these reads are journaled, which they now are.
+      # The activation count below is a process switch, outside the typing state (WD5).
+      RECORDER = TypingState.frame(
+        :dependency_recorder,
+        contents: :resource, reason: "the consumer's accumulator a recording installs; each read files into it",
+        # G1′ witness: the dependency reads are a journaled Table (WD4), so the memo may run under recording, and typing
+        # reads the accumulator (`read_site`, `read_name`) inside `type_of`.
+        witness: "spec/fixtures/typing_state_witnesses/dependency_recorder.rb"
+      )
+      private_constant :RECORDER
+
+      # ADR-129 WD1 — the recorded dependency reads are a bound Table: the installed {Accumulator} and each open
+      # {Capture} are its stores, keyed on the event tuples they deduplicate on (a frozen `[path, symbol_or_nil]` pair
+      # for a positive edge, a `"kind:name"` String for a name-keyed one). Each event that files into a store logs a
+      # read of its key (`true` when the store already held it, else {TypingState::ABSENT}) and, when it adds, a write
+      # of `true`, while a capture is open, so a later `type_of` memo can validate the reads and replay the writes.
+      # The keys are built only then: a run with no journal capture open allocates nothing for the journal, whether
+      # or not an ADR-84 capture is open.
+      # ADR-129 WD3 — {READS}'s entry protocol over an {Accumulator} or a {Capture}: a positive edge's
+      # `[path, symbol_or_nil]` pair is held in the accumulator's symbol or ancestry table (a capture's `reads`), a
+      # name-keyed `"kind:name"` String in `missing`. Every entry is `true`; a replayed write files the edge the way the
+      # event that logged it did.
+      module Entries
+        module_function
+
+        def entry(store, key)
+          held = if key.is_a?(String) then store.missing.include?(key)
+                 elsif store.is_a?(Capture) then store.reads.include?(key)
+                 else store.holds_read?(key[0], key[1])
+                 end
+          held ? true : TypingState::ABSENT
+        end
+
+        def put(store, key, _value)
+          if key.is_a?(String) then store.missing.add(key)
+          elsif store.is_a?(Capture) then store.reads.add(key)
+          else store.add_read(key[0], key[1])
+          end
+        end
+
+        def delete(store, key)
+          if key.is_a?(String) then store.missing.delete(key)
+          elsif store.is_a?(Capture) then store.reads.delete(key)
+          else store.remove_read(key[0], key[1])
+          end
+        end
+
+        def container(_state, _slot)
+          raise ArgumentError, "dependency reads are a bound table: a store is an accumulator or a capture"
+        end
+      end
+
+      READS = TypingState.table(
+        :dependency_reads,
+        bound: true, entries: Entries,
+        reason: "event tuple => true per accumulator and per open capture; set-only, in first-filing order"
+      )
+      private_constant :READS
 
       # ADR-84 WD2 — thread-local Array of active {Capture}s (nil when none). A capture observes-and-forwards:
       # every read recorded while it is active flows into the current consumer's accumulator exactly as before
@@ -27,14 +87,24 @@ module Rigor
       # each outer one's: the inner capture was pushed after the outer, and everything added since reached both.
       # {withhold} swaps in a fresh stack and restores this one untouched, so it keeps the property too.
       # {tee_read} and {tee_missing} rely on it to stop at the first capture that already holds an event.
-      CAPTURE_KEY = :__rigor_dependency_capture_stack__
-      private_constant :CAPTURE_KEY
+      #
+      # ADR-129 WD3 — the stack is an id-determined Resource: every change of it ({capture}'s push and pop,
+      # {withhold}'s swap and restore) takes a fresh state id, so reading it on the event paths is exempt.
+      CAPTURES = TypingState.resource(
+        :dependency_capture_stack,
+        read_exemption: :id_determined,
+        reason: "the open capture windows, pushed per window and swapped by withhold"
+      )
+      private_constant :CAPTURES
 
       # The read sets an {Accumulator} or {Capture} already holds in full, by identity: replayed into it, or
       # captured by a window it saw every event of ({capture}). Both only ever grow and a {ReadSet} is frozen,
       # so replaying such a set into the same target again adds nothing. Recording replays the same stored
       # read set many times over: on Rigor's own `lib`, 71% of the replays into a consumer repeated one
       # already made into it, carrying 65% of the replayed events.
+      #
+      # ADR-129 — the held marks are an extensional dedupe cache over the store's own {READS} entries (every event of
+      # a held set is already in the store), so marking and probing them log nothing; {ChainMemory} likewise.
       module ReplayMemory
         def holds?(read_set)
           !@held.nil? && @held.key?(read_set)
@@ -74,8 +144,8 @@ module Rigor
           @sources = Set.new
           @missing = Set.new
           # ADR-46 slice 4 — symbol-granularity tracking.
-          # `symbol_sources`: source_path → Set<"ClassName#method"> for method-call deps.
-          # `ancestry_sources`: Set<source_path> for class-ancestry (superclass / include) deps —
+          # `symbol_sources`: source_path → the "ClassName#method" names read from it, for method-call deps.
+          # `ancestry_sources`: the source paths read for class-ancestry (superclass / include) deps —
           # file-granularity by nature (a superclass edge touches the whole class).
           @symbol_sources = Hash.new { |h, k| h[k] = Set.new }
           @ancestry_sources = Set.new
@@ -90,6 +160,39 @@ module Rigor
           @suspensions += 1
         end
 
+        # The positive-edge aggregation shared by {DependencyRecorder.read_site}, {DependencyRecorder.replay} and a
+        # replayed {READS} write. `sources` is the union of the other two tables' paths, and this is the only writer of
+        # all three, so a read the finer table already holds is already in `sources` and costs one Set probe instead
+        # of two. Answers whether the read was new (truthy) or already held (nil), which is its {READS} filing.
+        def add_read(path, symbol)
+          added = symbol ? @symbol_sources[path].add?(symbol) : @ancestry_sources.add?(path)
+          @sources << path if added
+          added
+        end
+
+        # Undoes an {#add_read} that filed a new edge (G1's stage-4 form): `sources` keeps `path` while another table
+        # still holds it, and a `symbol_sources` set left empty goes, as no read had made it.
+        def remove_read(path, symbol)
+          if symbol
+            symbols = @symbol_sources.key?(path) ? @symbol_sources[path] : nil
+            if symbols
+              symbols.delete(symbol)
+              @symbol_sources.delete(path) if symbols.empty?
+            end
+          else
+            @ancestry_sources.delete(path)
+          end
+          @sources.delete(path) unless @ancestry_sources.include?(path) || @symbol_sources.key?(path)
+        end
+
+        # Whether the edge {#add_read} files for `path` and `symbol` is held. Reads `symbol_sources` without its
+        # default block, so asking adds no empty set.
+        def holds_read?(path, symbol)
+          return @ancestry_sources.include?(path) unless symbol
+
+          @symbol_sources.key?(path) && @symbol_sources[path].include?(symbol)
+        end
+
         def snapshot
           frozen_sym = @symbol_sources.transform_values(&:freeze).freeze
           Record.new(
@@ -103,8 +206,8 @@ module Rigor
       end
 
       # Frozen record of one file's cross-file reads.
-      # `symbol_sources`: source_path → frozen Set<"ClassName#method"> (method-call edges).
-      # `ancestry_sources`: frozen Set<source_path> (class-ancestry edges, file-granularity).
+      # `symbol_sources`: source_path → frozen set of "ClassName#method" names (method-call edges).
+      # `ancestry_sources`: frozen set of source paths (class-ancestry edges, file-granularity).
       Record = Data.define(:consumer, :sources, :missing, :symbol_sources, :ancestry_sources)
 
       # ADR-84 WD2 — a replayable, consumer-independent read-set: `reads` is a frozen Set of frozen
@@ -154,16 +257,22 @@ module Rigor
       # the frozen {Record}. Nests safely (the inner consumer's reads do not leak to the outer one); restores
       # the previous recorder on exit.
       def record_for(consumer)
-        previous = Thread.current[KEY]
-        previous&.suspend!
+        state = TypingState.current
+        previous = state[RECORDER]
+        if previous
+          state.touch(RECORDER)
+          previous.suspend!
+        end
         accumulator = Accumulator.new(consumer.to_s)
-        Thread.current[KEY] = accumulator
-        @mutex.synchronize { @active_count += 1 }
-        yield
-        accumulator.snapshot
-      ensure
-        Thread.current[KEY] = previous
-        @mutex.synchronize { @active_count -= 1 }
+        state.with(RECORDER, accumulator) do
+          @mutex.synchronize { @active_count += 1 }
+          begin
+            yield
+            accumulator.snapshot
+          ensure
+            @mutex.synchronize { @active_count -= 1 }
+          end
+        end
       end
 
       # Plain integer read (GVL-atomic) — no `Thread.current` lookup on the disabled fast path.
@@ -175,25 +284,26 @@ module Rigor
       # window. {active?} answers for the process and is the cheap gate; this is the exact one, for a caller
       # that must know whether an empty {capture} means "nothing to record" or "nothing was watching".
       def recording?
-        !Thread.current[KEY].nil?
+        !TypingState.current[RECORDER].nil?
       end
 
       # ADR-84 WD2 — runs the block under an observe-and-forward capture window and returns
       # `[block_result, read_set]`. Reads recorded during the window reach the current consumer's accumulator
       # unchanged (forwarding) and are additionally collected into the returned frozen {ReadSet} (observing),
-      # which {replay} can later apply to a different consumer. Nests (see CAPTURE_KEY). Callers guard on
+      # which {replay} can later apply to a different consumer. Nests (see CAPTURES). Callers guard on
       # {active?}; opening a capture with no accumulator active would collect reads no run is recording.
       def capture
-        captures = (Thread.current[CAPTURE_KEY] ||= [])
-        accumulator = Thread.current[KEY]
+        state = TypingState.current
+        accumulator = state[RECORDER]
         suspensions = accumulator&.suspensions
         capture = Capture.new
-        captures.push(capture)
+        state.push(CAPTURES, capture)
         begin
           result = yield
         ensure
-          captures.pop
+          state.pop(CAPTURES)
         end
+        captures = state[CAPTURES]
         read_set = capture.snapshot
         note_captured(read_set, captures, accumulator, suspensions)
         [result, read_set]
@@ -209,7 +319,7 @@ module Rigor
         return if read_set.equal?(EMPTY_READ_SET)
 
         captures.last&.hold!(read_set)
-        return unless accumulator && Thread.current[KEY].equal?(accumulator)
+        return unless accumulator && TypingState.current[RECORDER].equal?(accumulator)
         return unless accumulator.suspensions == suspensions
 
         accumulator.hold!(read_set)
@@ -223,18 +333,22 @@ module Rigor
       # edge would make every correct call on a project class re-check on any edit to the class's files.
       # Returns a nil read set when no recording is active.
       def withhold
-        previous = Thread.current[KEY]
+        state = TypingState.current
+        previous = state[RECORDER]
         return [yield, nil] if previous.nil?
 
-        previous_captures = Thread.current[CAPTURE_KEY]
+        previous_captures = state[CAPTURES]
         capture = Capture.new
-        Thread.current[KEY] = Accumulator.new(previous.consumer)
-        Thread.current[CAPTURE_KEY] = [capture]
-        begin
-          result = yield
-        ensure
-          Thread.current[KEY] = previous
-          Thread.current[CAPTURE_KEY] = previous_captures
+        result = state.with(RECORDER, Accumulator.new(previous.consumer)) do
+          # A swap of the whole stack: a write, then a rewrite, so the swapped-in stack is read under a fresh id.
+          state.write(CAPTURES, [capture])
+          state.rewrite(CAPTURES)
+          begin
+            yield
+          ensure
+            state.write(CAPTURES, previous_captures)
+            state.rewrite(CAPTURES)
+          end
         end
         [result, capture.snapshot]
       end
@@ -243,11 +357,12 @@ module Rigor
       # here, applying the same per-consumer self-read filter as {read_site}, and tees into every active
       # capture so an enclosing capture window stays transitive when a memo hit substitutes for a body walk.
       def replay(read_set)
-        accumulator = Thread.current[KEY]
+        state = TypingState.current
+        accumulator = state[RECORDER]
         return if accumulator.nil? || read_set.nil? || read_set.equal?(EMPTY_READ_SET)
 
-        captures = Thread.current[CAPTURE_KEY]
-        tee_read_set(captures, read_set) if captures && !captures.empty?
+        captures = state[CAPTURES]
+        tee_read_set(state, captures, read_set) if captures && !captures.empty?
         # Each set keeps its own insertion order whichever target is filled first, and a skipped replay is one
         # that could only have re-added what the target already holds.
         return if accumulator.holds?(read_set)
@@ -255,25 +370,29 @@ module Rigor
         consumer = accumulator.consumer
         read_set.reads.each do |pair|
           path, symbol = pair
-          accumulate_read(accumulator, path, symbol) unless path == consumer
+          next if path == consumer
+
+          added = accumulate_read(accumulator, path, symbol)
+          log_filing(state, accumulator, pair, added) if state.capturing?
         end
         missing = accumulator.missing
-        read_set.missing.each { |entry| missing << entry }
+        read_set.missing.each { |entry| file_missing(state, accumulator, missing, entry) }
         accumulator.hold!(read_set)
       end
 
       # #1590 — runs the block, which files a resolution chain's edges from entry `start` (nil: the root and the
       # whole chain) against `discovery`, unless the current consumer's accumulator AND the innermost open capture
       # already hold that filing; the block files the same edges every time, so skipping it there changes nothing.
-      # Every event reaches every capture open at the time (see CAPTURE_KEY), so the innermost capture holding the
+      # Every event reaches every capture open at the time (see CAPTURES), so the innermost capture holding the
       # filing means every open capture does. A filing the accumulator holds but a capture opened since does not is
       # filed again, so that capture's read set, replayed elsewhere, still carries it; and {withhold} starts a fresh
       # accumulator and capture, which hold nothing. The marks are made only once the block has run, as {hold!}'s are.
       def file_chain_once(chain, start, discovery)
-        accumulator = Thread.current[KEY]
+        state = TypingState.current
+        accumulator = state[RECORDER]
         return if accumulator.nil?
 
-        captures = Thread.current[CAPTURE_KEY]
+        captures = state[CAPTURES]
         open = captures && !captures.empty?
         if accumulator.chain_filed?(chain, start, discovery) &&
            (!open || captures.last.chain_filed?(chain, start, discovery))
@@ -286,33 +405,78 @@ module Rigor
       end
 
       # {replay}'s share for the open captures. The innermost capture having seen `read_set` already means every
-      # open capture holds all of it (see CAPTURE_KEY).
-      def tee_read_set(captures, read_set)
+      # open capture holds all of it (see CAPTURES).
+      def tee_read_set(state, captures, read_set)
         innermost = captures.last
         return if innermost.holds?(read_set)
 
-        read_set.reads.each { |pair| tee_read(captures, pair) }
-        read_set.missing.each { |entry| tee_missing(captures, entry) }
+        read_set.reads.each { |pair| tee_read(state, captures, pair) }
+        read_set.missing.each { |entry| tee_missing(state, captures, entry) }
         innermost.hold!(read_set)
       end
       private_class_method :tee_read_set
 
       # Adds a read pair to the open captures, innermost first, and stops at the first capture that already holds
-      # it: every capture outside that one holds it too (see CAPTURE_KEY). The capture sets end up exactly as
-      # adding it to every capture would leave them, in the same insertion order.
-      def tee_read(captures, pair)
-        index = captures.size - 1
-        index -= 1 while index >= 0 && captures[index].reads.add?(pair)
+      # it: every capture outside that one holds it too (see CAPTURES). The capture sets end up exactly as
+      # adding it to every capture would leave them, in the same insertion order. Each capture probed logs its
+      # filing; the ones outside the first holder are not probed, and hold the key by the same property.
+      def tee_read(state, captures, pair)
+        if state.capturing?
+          tee_logged(state, captures, pair, :reads)
+        else
+          index = captures.size - 1
+          index -= 1 while index >= 0 && captures[index].reads.add?(pair)
+        end
       end
       private_class_method :tee_read
 
       # {tee_read} for a name-keyed `missing` entry.
-      def tee_missing(captures, entry)
-        index = captures.size - 1
-        index -= 1 while index >= 0 && captures[index].missing.add?(entry)
+      def tee_missing(state, captures, entry)
+        if state.capturing?
+          tee_logged(state, captures, entry, :missing)
+        else
+          index = captures.size - 1
+          index -= 1 while index >= 0 && captures[index].missing.add?(entry)
+        end
       end
       private_class_method :tee_missing
 
+      # {tee_read} / {tee_missing} while a capture is open: the same walk, logging each capture's filing.
+      def tee_logged(state, captures, key, set)
+        index = captures.size - 1
+        while index >= 0
+          capture = captures[index]
+          added = capture.public_send(set).add?(key)
+          log_filing(state, capture, key, added)
+          break unless added
+
+          index -= 1
+        end
+      end
+      private_class_method :tee_logged
+
+      # Logs one filing of `key` into `store` (an {Accumulator} or a {Capture}): a read of the key, which the store held
+      # unless the filing `added` it, and the write when it did. Callers log only while a capture is open.
+      def log_filing(state, store, key, added)
+        state.log_bound_read(READS, store, key, added ? TypingState::ABSENT : true)
+        state.log_bound_write(READS, store, key, true, TypingState::ABSENT) if added
+      end
+      private_class_method :log_filing
+
+      # A positive edge filed into the consumer's accumulator ({Accumulator#add_read}): truthy when it was new.
+      def accumulate_read(accumulator, path, symbol) = accumulator.add_read(path, symbol)
+      private_class_method :accumulate_read
+
+      # Files a name-keyed entry into an accumulator's `missing` set, logging the filing while a capture is open.
+      def file_missing(state, accumulator, missing, entry)
+        if state.capturing?
+          log_filing(state, accumulator, entry, missing.add?(entry))
+        else
+          missing << entry
+        end
+      end
+      private_class_method :file_missing
+
       # Records that the current consumer read a declaration / body whose definition site is `path_line` (a
       # `"path:line"` String, or nil). When `symbol` is given (a `"ClassName#method"` String), the read is a
       # method-call edge and is recorded at symbol granularity in `symbol_sources` in addition to the coarse
@@ -321,17 +485,20 @@ module Rigor
       # (ADR-84 WD2) observe every valid-path read UNfiltered — the self-read filter is per-consumer and is
       # re-applied by {replay} against whichever consumer a replay serves.
       def read_site(path_line, symbol = nil)
-        accumulator = Thread.current[KEY]
+        state = TypingState.current
+        accumulator = state[RECORDER]
         return if accumulator.nil? || path_line.nil?
 
         path = site_path(path_line)
         return unless path
 
-        captures = Thread.current[CAPTURE_KEY]
-        tee_read(captures, [path, symbol].freeze) if captures && !captures.empty?
+        captures = state[CAPTURES]
+        pair = [path, symbol].freeze if (captures && !captures.empty?) || state.capturing?
+        tee_read(state, captures, pair) if captures && !captures.empty?
         return if path == accumulator.consumer
 
-        accumulate_read(accumulator, path, symbol)
+        added = accumulate_read(accumulator, path, symbol)
+        log_filing(state, accumulator, pair, added) if state.capturing?
       end
 
       # The path part of a `"path:line"` site: what `path_line.split(":", 2).first` answers, without the Array
@@ -355,13 +522,14 @@ module Rigor
       # currently wins: a second declarer appearing in a file the reader has no edge to must drop the name to
       # `Dynamic` at that reader, and only a name-keyed edge can see it.
       def read_name(kind, name)
-        accumulator = Thread.current[KEY]
+        state = TypingState.current
+        accumulator = state[RECORDER]
         return if accumulator.nil?
 
         entry = "#{kind}:#{name}"
-        captures = Thread.current[CAPTURE_KEY]
-        tee_missing(captures, entry) if captures && !captures.empty?
-        accumulator.missing.add(entry)
+        captures = state[CAPTURES]
+        tee_missing(state, captures, entry) if captures && !captures.empty?
+        file_missing(state, accumulator, accumulator.missing, entry)
       end
 
       # {read_name} keyed on the LAST SEGMENT of a constant path, `name.delete_prefix("::").split("::").last`,
@@ -370,7 +538,7 @@ module Rigor
       # objects a call over half a million calls. A name the scan could read differently from `split` (one
       # that is not ASCII, or carries a run of colons or a trailing one) takes `split`'s answer.
       def read_last_segment(kind, name)
-        return if Thread.current[KEY].nil?
+        return unless recording?
 
         segment = last_segment(name)
         read_name(kind, segment) if segment
@@ -394,15 +562,16 @@ module Rigor
       # {read_name} for prebuilt, frozen `"kind:name"` keys: a caller that files the same keys on every read
       # (a resolution chain's hook edges, #1641) builds them once and adds them here without a String apiece.
       def read_keys(keys)
-        accumulator = Thread.current[KEY]
+        state = TypingState.current
+        accumulator = state[RECORDER]
         return if accumulator.nil?
 
-        captures = Thread.current[CAPTURE_KEY]
+        captures = state[CAPTURES]
         open = captures && !captures.empty?
         missing = accumulator.missing
         keys.each do |entry|
-          tee_missing(captures, entry) if open
-          missing.add(entry)
+          tee_missing(state, captures, entry) if open
+          file_missing(state, accumulator, missing, entry)
         end
       end
 
@@ -412,7 +581,7 @@ module Rigor
       # the name private passes `"*"` as the class; the key fires when any entry of the name moves. A wildcard
       # slot (`[:singleton, :*]`) is `*` as the method name.
       def read_visibility(class_name, method_name)
-        return if Thread.current[KEY].nil?
+        return unless recording?
 
         read_name(:visibility, "#{class_name}##{method_name}")
       end
@@ -423,18 +592,6 @@ module Rigor
       def read_missing(kind, name)
         read_name(kind, name)
       end
-
-      # The positive-edge aggregation shared by {read_site} and {replay}. `sources` is the union of the other
-      # two tables' paths, and this is the only writer of all three, so a read the finer table already holds is
-      # already in `sources` and costs one Set probe instead of two.
-      def accumulate_read(accumulator, path, symbol)
-        if symbol
-          accumulator.sources << path if accumulator.symbol_sources[path].add?(symbol)
-        elsif accumulator.ancestry_sources.add?(path)
-          accumulator.sources << path
-        end
-      end
-      private_class_method :accumulate_read
     end
   end
 end

data/lib/rigor/analysis/dependency_source_inference/boundary_cross_reporter.rb

@@ -25,9 +25,9 @@ module Rigor
           @mutex = Mutex.new
         end
 
-        # @return frozen snapshot of the recorded boundary-cross events. Each entry is a Data
-        #   with `class_name` (String), `method_name` (Symbol), `gem_name` (String), and `rbs_display` (String
-        #   — the authoritative-side type's human-facing form, embedded into the diagnostic message).
+        # @return frozen snapshot of the recorded boundary-cross events. Each entry is a Data with `class_name`,
+        #   `method_name`, `gem_name`, and `rbs_display` (the authoritative-side type's human-facing form, embedded
+        #   into the diagnostic message).
         def entries
           @mutex.synchronize { @entries.dup.freeze }
         end
@@ -50,6 +50,17 @@ module Rigor
           end
         end
 
+        # The pool drain ({Rigor::Analysis::WorkerSession#drain_reporters}): the frozen entries.
+        def snapshot
+          entries
+        end
+
+        # Replays one worker's {#snapshot}; the record-time dedup collapses every worker's copy. Nil records
+        # nothing.
+        def absorb(snapshot)
+          Array(snapshot).each { |entry| record(**entry.to_h) }
+        end
+
         private
 
         def same_key?(existing, entry)

data/lib/rigor/analysis/dependency_source_inference/gem_resolver.rb

@@ -44,7 +44,7 @@ module Rigor
           Resolved.new(
             gem_name: entry.gem,
             version: spec.version.to_s,
-            gem_dir: spec.full_gem_path, # rigor:disable undefined-method
+            gem_dir: spec.full_gem_path,
             mode: entry.mode,
             roots: entry.roots
           )

data/lib/rigor/analysis/dependency_source_inference/index.rb

@@ -15,10 +15,9 @@ module Rigor
                     :class_to_gem, :budget_overrun_strategy, :gem_modes, :refinements, :bound_constants,
                     :bound_segments
 
-        # @param method_catalog — => Symbol}] the flat
-        #   `(class_name, method_name) → :instance | :singleton` table produced by {Walker.walk}, aggregated
-        #   across every resolved gem in the run. The Index itself stays gem-agnostic — the per-gem
-        #   attribution that slice 3's cache descriptor needs lives on `Resolved`, not here.
+        # @param method_catalog — the flat `(class_name, method_name) → CatalogEntry` table produced by
+        #   {Walker.walk}, aggregated across every resolved gem in the run. The Index itself stays gem-agnostic —
+        #   the per-gem attribution that slice 3's cache descriptor needs lives on `Resolved`, not here.
         # @param budget_exceeded — gem names whose {Walker} run hit the per-gem catalog cap
         #   (slice 4). The Runner consumes this list to emit one `dynamic.dependency-source.budget-exceeded`
         #   warning per gem.
@@ -110,10 +109,9 @@ module Rigor
           mode_for(class_name) == :full
         end
 
-        # Looks up the recorded method kind for a `(class_name, method_name)` pair. Returns `:instance` /
-        # `:singleton` when the walker observed a definition under one of the resolved gems' `roots:`, or
-        # `nil` otherwise. Slice 2b-ii enriches this with the inferred return type so the dispatcher tier can
-        # build a `Type::Dynamic` directly from the lookup result.
+        # Looks up the `CatalogEntry` (kind, and the heuristic return type) for a `(class_name, method_name)` pair.
+        # Returns it when the walker observed a definition under one of the resolved gems' `roots:`, or `nil`
+        # otherwise.
         def contribution_for(class_name:, method_name:)
           @method_catalog[[class_name, method_name]]
         end