rigortype 0.2.8 → 0.3.0

data/lib/rigor/analysis/dependency_recorder.rb

@@ -16,6 +16,15 @@ module Rigor
       KEY = :__rigor_dependency_recorder__
       private_constant :KEY
 
+      # 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
+      # AND into every active capture, so a caller gets a replayable read-set without disturbing recording.
+      # It is a STACK because captures nest (a memoised callee body evaluating another memo-miss callee): an
+      # outer capture must also see the inner window's reads, or its read-set would be non-transitive and a
+      # later replay would drop the nested callee's edges.
+      CAPTURE_KEY = :__rigor_dependency_capture_stack__
+      private_constant :CAPTURE_KEY
+
       # Mutable per-consumer accumulator. Frozen into a {Record} snapshot when `record_for` returns.
       class Accumulator
         attr_reader :consumer, :sources, :missing, :symbol_sources, :ancestry_sources
@@ -49,6 +58,27 @@ module Rigor
       # `ancestry_sources`: frozen Set<source_path> (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
+      # `[path, symbol_or_nil]` pairs (symbol nil = ancestry edge), `missing` a frozen Set of `"kind:name"`
+      # strings. Deliberately UNFILTERED by consumer: a read of the capturing consumer's own file is included
+      # because it is a genuine cross-file edge for every OTHER consumer a replay may serve — the per-consumer
+      # self-read filter is applied at {replay} time, mirroring {read_site}.
+      ReadSet = Data.define(:reads, :missing)
+
+      # Mutable capture accumulator; snapshot into a frozen {ReadSet} when the capture window closes.
+      class Capture
+        attr_reader :reads, :missing
+
+        def initialize
+          @reads = Set.new
+          @missing = Set.new
+        end
+
+        def snapshot
+          ReadSet.new(reads: reads.dup.freeze, missing: missing.dup.freeze)
+        end
+      end
+
       # Module-level activation count so the disabled fast path ({active?}) is a plain integer read rather
       # than a `Thread.current` hash lookup — `user_def_for` (the instrumented accessor) is on the
       # per-dispatch hot path, so a normal (non-recording) run must pay as little as possible. The per-thread
@@ -79,32 +109,86 @@ module Rigor
         @active_count.positive?
       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
+      # {active?}; opening a capture with no accumulator active would collect reads no run is recording.
+      def capture
+        captures = (Thread.current[CAPTURE_KEY] ||= [])
+        capture = Capture.new
+        captures.push(capture)
+        begin
+          result = yield
+        ensure
+          captures.pop
+        end
+        [result, capture.snapshot]
+      end
+
+      # ADR-84 WD2 — replays a {ReadSet} into the current consumer's accumulator as if each read happened
+      # 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]
+        return if accumulator.nil? || read_set.nil?
+
+        captures = Thread.current[CAPTURE_KEY]
+        read_set.reads.each do |pair|
+          captures&.each { |c| c.reads.add(pair) }
+          path, symbol = pair
+          next if path == accumulator.consumer
+
+          accumulate_read(accumulator, path, symbol)
+        end
+        read_set.missing.each do |entry|
+          captures&.each { |c| c.missing.add(entry) }
+          accumulator.missing << entry
+        end
+      end
+
       # 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
       # `sources` set. Without `symbol` the read is a class-ancestry edge (file-granularity) and is added to
-      # `ancestry_sources` only. Self-reads and nil sites are ignored in all cases.
+      # `ancestry_sources` only. Self-reads and nil sites are ignored for the accumulator; active captures
+      # (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]
         return if accumulator.nil? || path_line.nil?
 
         path = path_line.split(":", 2).first
-        return unless path && path != accumulator.consumer
+        return unless path
 
-        accumulator.sources << path
-        if symbol
-          accumulator.symbol_sources[path] << symbol
-        else
-          accumulator.ancestry_sources << path
-        end
+        captures = Thread.current[CAPTURE_KEY]
+        captures&.each { |c| c.reads.add([path, symbol].freeze) }
+        return if path == accumulator.consumer
+
+        accumulate_read(accumulator, path, symbol)
       end
 
       # Records a cross-file lookup of `name` (kind `:method` / `:class` / `:const` / …) that resolved to
       # nothing — a negative dependency.
       def read_missing(kind, name)
         accumulator = Thread.current[KEY]
-        accumulator&.missing&.add("#{kind}:#{name}")
+        return if accumulator.nil?
+
+        entry = "#{kind}:#{name}"
+        Thread.current[CAPTURE_KEY]&.each { |c| c.missing.add(entry) }
+        accumulator.missing.add(entry)
+      end
+
+      # The positive-edge aggregation shared by {read_site} and {replay}.
+      def accumulate_read(accumulator, path, symbol)
+        accumulator.sources << path
+        if symbol
+          accumulator.symbol_sources[path] << symbol
+        else
+          accumulator.ancestry_sources << path
+        end
       end
+      private_class_method :accumulate_read
     end
   end
 end

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

@@ -4,6 +4,7 @@ require "prism"
 
 require_relative "return_type_heuristic"
 require_relative "../../source/constant_path"
+require_relative "../../source/node_children"
 
 module Rigor
   module Analysis
@@ -125,7 +126,7 @@ module Rigor
         end
 
         def walk_children(node, qualified_prefix, in_singleton_class, accumulator, budget)
-          node.compact_child_nodes.each do |child|
+          node.rigor_each_child do |child|
             break if accumulator.size >= budget
 
             walk_node(child, qualified_prefix, in_singleton_class, accumulator, budget)