rigortype 0.4.0 → 0.4.1

data/lib/rigor/analysis/runner.rb

@@ -297,11 +297,15 @@ module Rigor
                      record_dependencies: false, record_self_calls: false, analyze_only: nil,
                      seed_bundles: nil, collect_seed_bundles: false, param_inferred_types: nil,
                      discovery_seed: nil, no_tolerated_effects: false,
-                     restored_run_level_rows: nil)
+                     restored_run_level_rows: nil, served_per_file_diagnostics: nil)
         @configuration = configuration
         # Issues #796 / #794 — the previous full run's run-level rows, supplied only by
         # {IncrementalSession} on a narrowed run; see {PoolCoordinator#replay_restored_run_level_rows}.
         @restored_run_level_rows = restored_run_level_rows
+        # Issue #1524 — `{path => rows}` the {IncrementalSession} serves from its per-file cache for the files a
+        # narrowed run does not analyse, spliced into this run's per-file stream by
+        # {#interleave_served_diagnostics}. Empty on every other run.
+        @served_per_file_diagnostics = served_per_file_diagnostics || {}
         @explain = explain
         @cache_store = enforce_read_only_cache(cache_store, buffer)
         @plugin_requirer = plugin_requirer
@@ -353,6 +357,12 @@ module Rigor
         @cached_effect_ancestry = nil
         @cached_collections_loader = nil
         @run_dependency_descriptor = nil
+        # ADR-45 WD2 (#1507) — the plugin reads each file's analysis made (`{path => [row]}`), and the boundary
+        # rows as they stood around the per-file loop; see {#incremental_slot_rows}. Recorded only by a
+        # dependency-recording (incremental) run.
+        @analysis_reads = {}
+        @pre_analysis_plugin_rows = nil
+        @post_analysis_plugin_rows = nil
         # Memoised activation decision for the `call.self-undefined-method` rule (nil = not yet computed).
         # See `self_undefined_rule_active?`.
         @self_undefined_rule_active = nil
@@ -414,6 +424,7 @@ module Rigor
         @project_discovered_prepends = {}.freeze
         # Issue #898 — the singleton-side twin of the include table (`extend M` / `extend self`).
         @project_discovered_extends = {}.freeze
+        @project_unpositioned_mixins = {}.freeze
         @project_discovered_deferred_ranges = {}.freeze
         # Issue #1120 — `{refined class => {method => [refining modules]}}`, every `refine X do … end` body.
         @project_discovered_refinements = {}.freeze
@@ -433,6 +444,9 @@ module Rigor
         @constant_shadower_index = nil
         @project_discovered_method_visibilities = {}.freeze
         @project_discovered_methods = {}.freeze
+        # ADR-119 WD1 — the `possible_*` / `contested_*` siblings of the paired members, ONE Hash keyed by sibling
+        # name so no adoption or seed path names a sibling and none can drop one.
+        @project_discovery_siblings = Scope::DiscoveryIndex::EMPTY_SIBLINGS
         # Issue #992 — the cross-file parameter-envelope table `call.wrong-arity` reads for an undeclared `def`.
         @project_discovered_parameter_envelopes = {}.freeze
         @project_data_member_layouts = {}.freeze
@@ -508,6 +522,9 @@ module Rigor
         # #788 — the per-file reader is assigned only on the analysis (miss) path; reset it here so a run the
         # ADR-45 result cache serves does not answer with the previous run's rows.
         @per_file_diagnostics = [].freeze
+        @analysis_reads = {}
+        @pre_analysis_plugin_rows = nil
+        @post_analysis_plugin_rows = nil
         # ADR-84 WD2 — roll the return-memo bucket: a fresh frozen token per run makes every per-file scope
         # of THIS run share one memo bucket while entries from any earlier run in this process (stale after
         # an edit) become unreachable.
@@ -828,6 +845,11 @@ module Rigor
         # then hit — the stats it would otherwise suppress were all gathered.
         @run_served_from_cache = !computed && analysis.nil?
         diagnostics
+      rescue Inference::DeclarationWalk::ContractError
+        # A broken walk contract in the project pre-pass (a shadow-harness divergence, an unknown variant) is
+        # not a cache failure: the fallback below would re-run the analysis with the pre-pass marked done and
+        # no project index, and report the resulting false positives instead of the failure.
+        raise
       rescue StandardError
         # The result cache must never break a run. If anything in the cache path fails, fall back to a
         # direct, uncached analysis.
@@ -1175,19 +1197,55 @@ module Rigor
       # `#per_file_diagnostics`: the `analyze_files` return, stamped with the same severity profile the run's
       # own stream gets (`SeverityStamp` drops `:off` rows and re-stamps overrides, and the per-file cache never
       # re-stamps), sliced to the rows positioned at the targets. Returns the RAW return for the run's stream,
-      # which is stamped once, at the end of `#run_analysis`.
+      # which is stamped once, at the end of `#run_analysis` — on a narrowed incremental run with the served
+      # files' rows spliced in (#1524), which `#per_file_diagnostics` never carries.
       def analyze_targets(targets, environment:, project_files:)
         raw = template_units.remap(
           @pool_coordinator.analyze_files(targets, environment: environment, project_files: project_files)
         )
+        # ADR-45 WD2 (#1507) — the boundaries as the per-file loop left them; with the snapshot the first
+        # analysed file took, the rows {#incremental_slot_rows} checks every analysis-time read against.
+        @post_analysis_plugin_rows = plugin_boundary_rows if @record_dependencies
         analysed = targets.to_set
         @per_file_diagnostics = @diagnostic_aggregator.apply_severity_profile(raw)
                                                       .select { |diagnostic| analysed.include?(diagnostic.path) }
                                                       .freeze
-        raw
+        interleave_served_diagnostics(raw, analysed, project_files | targets)
       end
       private :analyze_targets
 
+      # Issue #1524 — splices the rows {IncrementalSession} serves from its per-file cache into this narrowed
+      # run's per-file stream, each file's rows where a full run of the same tree lists them. A full run
+      # analyses `order` (the project's files, then any buffer and template-unit targets) one file after
+      # another and a narrowed run a subsequence of it, so a served file's rows go just before the first row
+      # positioned at an analysed file later in `order`, or at the end when there is none. Only such a row
+      # marks a place, so the rows this run produced keep their relative order and a pool backend's
+      # `.rigor.yml` rows stay at the head. Splicing here rather than into the finished result keeps the
+      # run-level streams on either side of the per-file stream, where a full run has them. The served rows
+      # are already severity-resolved and the run's final stamp leaves them unchanged: a resolved severity
+      # resolves to itself, and a row the profile turns `:off` is never cached.
+      def interleave_served_diagnostics(raw, analysed, order)
+        served = @served_per_file_diagnostics
+        return raw if served.empty?
+
+        rank = order.each_with_index.to_h
+        # A served path the expansion no longer lists (a file deleted between the session's listing and this
+        # run) keeps its rows, after every other file's, as the concatenation this replaced did.
+        known, unknown = served.keys.partition { |path| rank.key?(path) }
+        pending = known.sort_by { |path| rank.fetch(path) }
+        merged = []
+        raw.each do |diagnostic|
+          # `order` lists every target, so an analysed path always has a rank; one that did not would only
+          # mark no place, since a misplaced row must never abort the run (ADR-5).
+          position = analysed.include?(diagnostic.path) ? rank.fetch(diagnostic.path, -1) : -1
+          merged.concat(served.fetch(pending.shift)) while pending.any? && rank.fetch(pending.first) < position
+          merged << diagnostic
+        end
+        (pending + unknown).each { |path| merged.concat(served.fetch(path)) }
+        merged
+      end
+      private :interleave_served_diagnostics
+
       # ADR-67 WD6a — the check-walk parameter-inference pre-pass. Populates `@project_param_inferred_types`
       # (read by `project_scope_seed_tables`) with the call-site union of every undeclared parameter, running
       # ONE round (a single hop of call-site → param typing; the protection scan's three-round fixpoint stays a
@@ -1310,25 +1368,205 @@ module Rigor
         # `.rbs` files that existed while the run read them, so without these a signature file written after
         # the run left the slot validating fresh and the warm run answered without it.
         globs = rbs_descriptor.globs + template_unit_glob_entries
+        boundary = plugin_boundary_rows
+        entries.concat(boundary.files)
+        globs.concat(boundary.globs).concat(producer_watch_glob_entries)
+        Cache::Descriptor.new(files: entries, globs: globs.uniq)
+      end
+
+      # Every file a plugin read or probed through its `IoBoundary` (#577 / #613), and every directory it listed
+      # (#954), as the boundaries stand when asked.
+      def plugin_boundary_rows
+        files = []
+        globs = []
         @plugin_registry.plugins.each do |plugin|
           # Read the boundary WITHOUT triggering its lazy `@io_boundary ||=` initializer: plugin instances
           # are frozen after the run, and a plugin that never built a boundary read no files through it,
           # so it contributes no dependencies.
           boundary = plugin.instance_variable_get(:@io_boundary)
-          if boundary
-            # #629 — a boundary carries GlobEntry listing rows too (`IoBoundary#list_directory`), and they
-            # are the only edge back to a file the run decided was ABSENT from a directory it consulted.
-            boundary_descriptor = boundary.cache_descriptor
-            entries.concat(boundary_descriptor.files)
-            globs.concat(boundary_descriptor.globs)
+          next unless boundary
+
+          # #629 — a boundary carries GlobEntry listing rows too (`IoBoundary#list_directory`), and they
+          # are the only edge back to a file the run decided was ABSENT from a directory it consulted.
+          boundary_descriptor = boundary.cache_descriptor
+          files.concat(boundary_descriptor.files)
+          globs.concat(boundary_descriptor.globs)
+        end
+        Cache::Descriptor.new(files: files, globs: globs)
+      end
+
+      # One glob row per producer `watch:` pattern (ADR-60 WD3), recomputed against the tree as it stands.
+      def producer_watch_glob_entries
+        @plugin_registry.plugins.flat_map do |plugin|
+          plugin.class.producers.each_value.flat_map do |prod|
+            prod[:watch] ? plugin.send(:watch_glob_entries, prod[:watch]) : []
           end
-          plugin.class.producers.each_value do |prod|
-            globs.concat(plugin.send(:watch_glob_entries, prod[:watch])) if prod[:watch]
+        end
+      end
+
+      # ADR-45 WD2 (#1507) — the rows `rigor check --incremental`'s run-result slot records beside the analysed
+      # files (whose digests {IncrementalSession} holds itself). Every run reads these inputs again and re-derives
+      # its answer from them; they are split by when the row was taken, which decides whether the session's
+      # {IncrementalRunSlot::WriteGuard} must vouch for it:
+      #
+      # - `observed` — every plugin row (`#prepare`, producers, template synthesis, and this run's per-file reads
+      #   too), recorded by the {Plugin::IoBoundary} as the plugin read. It includes each producer's `watch:`
+      #   globs, which a producer replays into its boundary whether it computed or was served (#1558). A save
+      #   after the read leaves the row stale, so no guard is needed.
+      # - `derived` — rows taken when the run ENDS: the template files and their claimed globs (#392, re-analysed
+      #   every run), and one existence row per analysis root and per `pre_eval:` entry. A run's path errors (`no
+      #   such file or directory`, `pre-eval.file-not-found`) answer to those last rows; the plain slot records
+      #   neither, and the incremental path regenerates the errors every run, so a slot that served one past the
+      #   edit that retracts it would print what no run of that tree prints. Existence rows carry ADR-45 WD1b's
+      #   bound: a directory replaced by a file of the same name stays fresh.
+      # - `by_file` — `{path => Descriptor}`, the plugin reads each file's analysis made
+      #   ({Plugin::IoBoundary.attributing}). A narrowed run analyses only its closure, so the session carries the
+      #   other files' reads forward from the previous slot.
+      #
+      # The template rows stand in for the `template-units` slot the plain key carries, which only a run can
+      # compute. That digest is a function of each unit's compiled Ruby (the template's bytes, and whatever else
+      # the transform read, through its boundary), its transform (the plugin, whose identity and configuration
+      # the key carries) and the synthesis version (the engine's): each of those has a row or a key slot.
+      #
+      # The inputs a recheck does NOT re-derive are {#baseline_dependency_rows}. nil when this run cannot vouch for
+      # its rows — a pool run, whose workers' reads never reach this process; a run that recorded no dependencies,
+      # whose analysis no session owns; or a run in which a boundary row changed during the per-file loop that no
+      # file's analysis was credited with, such as a read from a thread the plugin started.
+      IncrementalSlotRows = Data.define(:observed, :derived, :by_file)
+
+      # @param roots — the analysis roots the run was given.
+      def incremental_slot_rows(roots:)
+        return nil if pool_mode? || !@record_dependencies
+        return nil unless analysis_reads_attributed?
+
+        IncrementalSlotRows.new(
+          observed: plugin_boundary_rows,
+          derived: Cache::Descriptor.new(
+            files: template_unit_file_entries + existence_entries(Array(roots) + @configuration.pre_eval),
+            globs: template_unit_glob_entries
+          ),
+          by_file: @analysis_reads.transform_values do |reads|
+            Cache::Descriptor.new(
+              files: reads.grep(Cache::Descriptor::FileEntry).uniq,
+              globs: reads.grep(Cache::Descriptor::GlobEntry).uniq
+            )
           end
+        )
+      end
+
+      # Whether every boundary row that appeared or changed during the per-file loop is one some file's analysis
+      # was credited with. A row outside every file's attribution would ride this run's `run` rows only, and the
+      # next narrowed run — which does not repeat the read — would drop it.
+      def analysis_reads_attributed?
+        post = @post_analysis_plugin_rows || plugin_boundary_rows
+        pre = @pre_analysis_plugin_rows || post
+        credited = @analysis_reads.each_value.flat_map(&:itself).to_set
+        (post.files - pre.files).all? { |row| credited.include?(row) } &&
+          (post.globs - pre.globs).all? { |row| credited.include?(row) }
+      end
+
+      # ADR-45 WD2 (#1507) — the rows a FULL run records for the inputs an incremental recheck does not re-derive,
+      # which the session therefore carries unchanged from the full run that recorded them to every later slot:
+      #
+      # - the signature tree the plain slot records (`RbsDescriptor.file_entries` / `.glob_entries` over the loader
+      #   roots this run's analysis resolved), and an existence row per signature root, configured or the
+      #   auto-detected `sig` — a recheck rebuilds no environment unless its closure is non-empty, and the snapshot
+      #   fingerprint digests the same roots (configured, or the auto-detected `sig`), so a change to one drops the
+      #   snapshot and forces a full run rather than reaching a recheck;
+      # - the discovered-not-analysed files (#684) and a listing row per discovery root — a narrowed recheck does
+      #   not widen discovery at all;
+      # - every `pre_eval:` file outside `files` (a stat row, or an absence row) — the session tracks only analysed
+      #   files, and one that is analysed is guarded by its own row.
+      #
+      # Recomputing any of these on a recheck would vouch for the tree the recheck saw while its answer still
+      # carries rows computed before the change, so a change to one keeps the probe declining until the next full
+      # run. nil when this process analysed no file itself — a pool run, or a run with no files.
+      #
+      # Split by what identifies the input. `pinned` holds the signature files outside the project's own signature
+      # roots, which the slot's key identifies already: the engine's own (`data/`, a bundled plugin's `sig/`, a
+      # gem overlay) by the engine slot, a gem's `sig/` and an `rbs collection` directory by the lockfiles. `owned`
+      # holds the rest, which only their rows identify. The session's write guard refuses an `owned` row whose
+      # change time it cannot read, and passes over a `pinned` one.
+      BaselineRows = Data.define(:owned, :pinned)
+
+      SignatureRoots = Struct.new(:signature_paths)
+      private_constant :SignatureRoots
+
+      # @param files — the run's analysed-path set.
+      def baseline_dependency_rows(files:)
+        return nil if pool_mode? || !@collect_stats || @analyzed_files.empty?
+
+        own, pinned = signature_rows
+        BaselineRows.new(
+          owned: Cache::Descriptor.new(
+            files: own.files + existence_entries(signature_root_candidates) +
+                   discovery_file_entries({ files: files }) + unanalysed_pre_eval_entries(files),
+            globs: (own.globs + discovery_glob_entries).uniq
+          ),
+          pinned: pinned
+        )
+      end
+
+      # The signature tree's rows, the project's own and the rest.
+      def signature_rows
+        roots = SignatureRoots.new(@snapshots.signature_paths)
+        own = signature_root_candidates.map { |root| File.join(File.absolute_path(root.to_s), "") }
+        own_files, other_files = Cache::RbsDescriptor.file_entries(roots, comparator: :stat)
+                                                     .partition { |row| within?(row.path, own) }
+        own_globs, other_globs = Cache::RbsDescriptor.glob_entries(roots).partition { |row| within?(row.root, own) }
+        [Cache::Descriptor.new(files: own_files, globs: own_globs.uniq),
+         Cache::Descriptor.new(files: other_files, globs: other_globs.uniq)]
+      end
+
+      def within?(path, roots)
+        directory = File.join(File.absolute_path(path.to_s), "")
+        roots.any? { |root| directory.start_with?(root) }
+      end
+
+      # The project's own signature roots, whether or not they exist: the configured `signature_paths:`, or the
+      # `sig` directory `Environment.default_signature_paths` auto-detects when none are configured. The
+      # signature rows' listing rows cover a file appearing under a root that existed; only an existence row
+      # covers the root itself appearing.
+      def signature_root_candidates
+        @configuration.signature_paths || ["sig"]
+      end
+
+      # One names-mode listing row per directory the discovery widening globbed, so a file appearing there is seen
+      # as well as an edit to one that existed.
+      def discovery_glob_entries
+        return [] if @project_discovery_expansion.nil?
+
+        @configuration.paths.select { |root| File.directory?(root) }.map do |root|
+          Cache::Descriptor::GlobEntry.compute(root: root, pattern: PathExpansion::RUBY_GLOB, mode: :names)
         end
-        Cache::Descriptor.new(files: entries, globs: globs.uniq)
       end
 
+      def unanalysed_pre_eval_entries(files)
+        analysed = files.to_set { |path| File.absolute_path(path) }
+        outside = @configuration.pre_eval.reject { |path| analysed.include?(File.absolute_path(path)) }
+        outside.map do |path|
+          if File.file?(path)
+            Cache::Descriptor::FileEntry.stat(path: path, digest: Cache::FileDigest.hexdigest(path))
+          else
+            existence_entries([path]).first
+          end
+        end
+      end
+
+      def existence_entries(paths)
+        paths.uniq.map do |path|
+          physical = @buffer ? @buffer.resolve(path) : path
+          if File.exist?(physical)
+            Cache::Descriptor::FileEntry.present(path: physical)
+          else
+            Cache::Descriptor::FileEntry.absent(path: physical)
+          end
+        end
+      end
+      private :plugin_boundary_rows, :producer_watch_glob_entries, :existence_entries,
+              :analysis_reads_attributed?, :signature_root_candidates, :discovery_glob_entries,
+              :unanalysed_pre_eval_entries, :signature_rows, :within?
+
       # Issue #684 — the project files this run DISCOVERED but did not analyse. A widened run's diagnostics
       # are a function of them (that is the entire point: the method whose absence would have been reported
       # is defined in one of them), so the run-result cache must invalidate when one changes. Empty on every
@@ -1483,8 +1721,10 @@ module Rigor
       end
 
       # The tables only check rules read beyond dispatch — the issue #1120 refinements and the issue #1367
-      # global-write census. Extracted to keep {#apply_discovery_result} under its ABC budget.
+      # global-write census — and the ADR-119 WD1 siblings of the paired members. Extracted to keep
+      # {#apply_discovery_result} under its ABC budget.
       def apply_discovery_call_surface_tables(discovery)
+        @project_discovery_siblings = discovery.siblings
         @project_discovered_refinements = discovery.discovered_refinements
         @project_discovered_global_write_census = discovery.discovered_global_write_census
       end
@@ -1496,6 +1736,7 @@ module Rigor
         @project_discovered_includes = discovery.discovered_includes
         @project_discovered_prepends = discovery.discovered_prepends
         @project_discovered_extends = discovery.discovered_extends
+        @project_unpositioned_mixins = discovery.unpositioned_mixins
       end
 
       # Internal: builds the deferred cross-file discovery tables at most once per run and adopts them.
@@ -1512,7 +1753,7 @@ module Rigor
 
         @project_discovery_done = true
         # Issue #684 — the cross-file index spans the PROJECT even when the analysis targets a file list.
-        expansion = @project_discovery_expansion || expansion
+        expansion = @project_discovery_expansion || once_each(expansion)
         if @collect_seed_bundles
           # ADR-85 WD2 — rebuild discovery from the prior run's bundles (re-walking only changed files) and
           # capture the refreshed bundle set for the session to persist.
@@ -1546,11 +1787,42 @@ module Rigor
       # Excluded, each because its expansion is already the one it means: the LSP `prebuilt:` path (which
       # seeds discovery from a snapshot), editor `buffer:` mode, `run_source`'s in-memory single file, and
       # ADR-46's `analyze_only` subset mode (which already passes the full expansion and filters later).
+      #
+      # Issue #1556 — the widened set holds each FILE once. `.rigor.yml`'s `paths:` load as absolute paths and a
+      # path argument usually does not, so `rigor check lib` widened discovery over both spellings of every file:
+      # the pre-pass then saw two writers for every constant a file declares and withheld its publication (#644),
+      # and every file was a discovered-not-analysed dependency of the run's cache entry.
+      #
+      # The widening decision itself still compares the paths as spelled. `exclude:` patterns match a path as it
+      # is spelled, so until #1576 is fixed the configured absolute `lib` can discover files the argument `lib`
+      # excludes (a relative `lib/gen/**` pattern never matches `/abs/lib/gen/x.rb`), and treating the two as the
+      # same root would drop those files from discovery.
       def project_discovery_expansion(paths, expansion)
         return nil unless widen_discovery_to_project?(paths)
 
-        widened = expand_paths(@configuration.paths | paths)
-        widened.fetch(:files).size > expansion.fetch(:files).size ? widened : nil
+        analysed = expansion.fetch(:files)
+        files = discovery_files(expand_paths(@configuration.paths | paths).fetch(:files), analysed)
+        # Overlapping arguments (`lib lib/user.rb`) name an analysed file twice; the widened set names it once.
+        files.size > analysed.uniq { |path| File.absolute_path(path) }.size ? { files: files, errors: [] } : nil
+      end
+
+      # The expansion with each file once, first spelling kept: overlapping arguments (`lib ./lib`) that do not
+      # widen discovery still name a file twice, and the pre-pass would take every constant in it for one written
+      # twice (#1556). Symlinked aliases (`src -> lib`) are not folded; that needs a realpath and stays out of scope.
+      def once_each(expansion)
+        files = expansion.fetch(:files)
+        unique = files.uniq { |path| File.absolute_path(path) }
+        unique.size == files.size ? expansion : expansion.merge(files: unique)
+      end
+
+      # Each file once, in project order, under the spelling the analysis uses when it is analysed.
+      def discovery_files(project_files, analysed_files)
+        spelling = analysed_files.to_h { |path| [File.absolute_path(path), path] }
+        seen = Set.new
+        project_files.filter_map do |path|
+          absolute = File.absolute_path(path)
+          spelling.fetch(absolute, path) if seen.add?(absolute)
+        end
       end
 
       def widen_discovery_to_project?(paths)
@@ -1569,7 +1841,7 @@ module Rigor
 
       private :run_project_pre_passes, :adopt_prebuilt_project_scan, :apply_pre_passes_result,
               :apply_discovery_result, :ensure_project_discovery, :force_eager_discovery?,
-              :project_discovery_expansion, :widen_discovery_to_project?
+              :project_discovery_expansion, :discovery_files, :once_each, :widen_discovery_to_project?
 
       # Ruby versions probed (ascending) to discover the lowest one this Prism build accepts for
       # `version:`. Prism exposes no version list, so the floor is found empirically — only when a
@@ -1832,7 +2104,7 @@ module Rigor
       end
 
       def shadow_rule_walk?
-        ENV.fetch("RIGOR_SHADOW_RULE_WALK", nil)
+        ShadowHarness.enabled?
       end
 
       def collect_plugin_diagnostics(plugin, path, root, scope, node_result)
@@ -1977,13 +2249,9 @@ module Rigor
         # bucket identically to the sequential path.
         tables[:run_generation] = @run_generation if @run_generation
         tables[:discovered_classes] = @project_discovered_classes unless @project_discovered_classes.empty?
-        tables[:discovered_def_nodes] = @project_discovered_def_nodes unless @project_discovered_def_nodes.empty?
         unless @project_discovered_def_nestings.empty?
           tables[:discovered_def_nestings] = @project_discovered_def_nestings
         end
-        unless @project_discovered_singleton_def_nodes.empty?
-          tables[:discovered_singleton_def_nodes] = @project_discovered_singleton_def_nodes
-        end
         seed_def_source_tables(tables)
         unless @project_discovered_superclasses.empty?
           tables[:discovered_superclasses] = @project_discovered_superclasses
@@ -1992,27 +2260,41 @@ module Rigor
           tables[:discovered_header_nestings] = @project_discovered_header_nestings
         end
         seed_mixin_tables(tables)
-        unless @project_discovered_method_visibilities.empty?
-          tables[:discovered_method_visibilities] = @project_discovered_method_visibilities
-        end
-        tables[:discovered_methods] = @project_discovered_methods unless @project_discovered_methods.empty?
-        unless @project_discovered_deferred_ranges.empty?
-          tables[:discovered_deferred_ranges] = @project_discovered_deferred_ranges
-        end
+        seed_paired_tables(tables)
         seed_call_surface_tables(tables)
         seed_opt_in_pre_pass_tables(tables)
         seed_member_layout_tables(tables)
         seed_dependency_attribution_tables(tables)
-        tables
+        # Only a base seed can bring in half a pair (`seed_paired_tables` writes both halves), so a run without
+        # one skips the copy this costs per file.
+        @discovery_seed ? Scope::DiscoveryIndex.compact_pairs(tables) : tables
+      end
+
+      # ADR-119 WD1 — the members `Scope::DiscoveryIndex::SIBLINGS` pairs, each with its sibling. A pair rides the
+      # seed when either half is non-empty and is left out when both are, which keeps an `discovery_seed:` base's
+      # table for a pair this run computed nothing for. {Scope::DiscoveryIndex#with} takes the two together, and
+      # `compact_pairs` completes a half pair a base seed brought in.
+      PAIRED_MEMBER_IVARS = Scope::DiscoveryIndex::SIBLINGS.keys.to_h do |member|
+        [member, :"@project_#{member}"]
+      end.freeze
+      private_constant :PAIRED_MEMBER_IVARS
+
+      def seed_paired_tables(tables)
+        PAIRED_MEMBER_IVARS.each do |member, ivar|
+          sibling = Scope::DiscoveryIndex::SIBLINGS.fetch(member)
+          table = instance_variable_get(ivar)
+          own = @project_discovery_siblings.fetch(sibling)
+          next if table.empty? && own.empty?
+
+          tables[member] = table
+          tables[sibling] = own
+        end
       end
 
-      # The tables only check rules read: the issue #992 parameter envelopes (`call.wrong-arity`), the issue #1120
-      # refinements (`call.undefined-method`), and the issue #1367 global-write census (the `global.*` write
-      # rules). Split out of {#project_scope_seed_tables} to keep it under the complexity budget.
+      # The tables only check rules read: the issue #1120 refinements (`call.undefined-method`) and the issue #1367
+      # global-write census (the `global.*` write rules); the issue #992 envelopes ride {#seed_paired_tables}. Split
+      # out of {#project_scope_seed_tables} to keep it under the complexity budget.
       def seed_call_surface_tables(tables)
-        unless @project_discovered_parameter_envelopes.empty?
-          tables[:discovered_parameter_envelopes] = @project_discovered_parameter_envelopes
-        end
         tables[:discovered_refinements] = @project_discovered_refinements unless @project_discovered_refinements.empty?
         # Issue #1367 — read by the `global.*` write rules.
         return if @project_discovered_global_write_census.empty?
@@ -2028,12 +2310,14 @@ module Rigor
         tables[:discovered_includes] = @project_discovered_includes unless @project_discovered_includes.empty?
         tables[:discovered_prepends] = @project_discovered_prepends unless @project_discovered_prepends.empty?
         tables[:discovered_extends] = @project_discovered_extends unless @project_discovered_extends.empty?
+        tables[:unpositioned_mixins] = @project_unpositioned_mixins unless @project_unpositioned_mixins.empty?
       end
 
-      # ADR-46 slice 1 / issue #644 — the two SOURCE-ATTRIBUTION tables, read only by the recording accessors
+      # ADR-46 slice 1 / issue #644 — the two SOURCE-ATTRIBUTION tables, read by the recording accessors
       # (`Scope#record_class_dependency` for the class-declaration map, `Scope#record_constant_dependency`
-      # for the constant-write map). A normal run carries neither of the two. Extracted to keep
-      # {#project_scope_seed_tables} under the complexity budget.
+      # for the constant-write map). The class-declaration map rides every run: an ancestor-order reader also
+      # asks whether a class is declared in more than one file. The constant-write map rides only a recording
+      # run. Extracted to keep {#project_scope_seed_tables} under the complexity budget.
       #
       # Issue #617 — the census's binding writes, grouped by last segment, ride every run instead: a constant
       # compound write whose plain read resolves nothing reads its binding off them, a TYPE rather than an edge.
@@ -2043,10 +2327,10 @@ module Rigor
         tables[:constant_writers] = writers unless writers.empty?
         shadowers = constant_shadower_index
         tables[:constant_shadowers] = shadowers unless shadowers.empty?
-        return unless @record_dependencies
-
         tables[:discovered_class_sources] = @project_discovered_class_sources unless
           @project_discovered_class_sources.empty?
+        return unless @record_dependencies
+
         tables[:constant_sources] = @project_constant_sources unless @project_constant_sources.empty?
       end
 
@@ -2108,7 +2392,7 @@ module Rigor
       def memo_files_by_segment
         @project_constant_writes.each_with_object({}) do |(name, by_path), files|
           set = (files[name.split("::").last] ||= Set.new)
-          by_path.each { |path, descriptor| set << File.expand_path(path) if memo_descriptor?(descriptor) }
+          by_path.each { |path, descriptor| set << File.absolute_path(path) if memo_descriptor?(descriptor) }
         end
       end
 
@@ -2166,14 +2450,14 @@ module Rigor
         writers = @project_constant_sources[name]
         wildcard = @project_constant_sources["#{Inference::ScopeIndexer::DYNAMIC_TARGET_PREFIX}#{segment}"]
         [writers, wildcard].any? do |paths|
-          paths&.any? { |path| !listed.include?(File.expand_path(path)) }
+          paths&.any? { |path| !listed.include?(File.absolute_path(path)) }
         end
       end
 
       # The listed `pre_eval:` files, expanded so a census path and a configured one compare as the same
       # file whichever spelling each arrived in.
       def pre_eval_path_set
-        @pre_eval_path_set ||= @configuration.pre_eval.to_set { |path| File.expand_path(path) }
+        @pre_eval_path_set ||= @configuration.pre_eval.to_set { |path| File.absolute_path(path) }
       end
 
       # ADR-46 — seed the instance + singleton `"path:line"` def-source tables (each only when non-empty).
@@ -2203,11 +2487,18 @@ module Rigor
       def analyze_file(path, environment)
         return analyze_with_effects(path, environment) unless @record_dependencies
 
+        # ADR-45 WD2 (#1507) — every plugin read this file's analysis makes is attributed to it, so the
+        # incremental session can validate them on a later run that serves this file's answer from cache.
+        @pre_analysis_plugin_rows ||= plugin_boundary_rows
+        reads = []
         diagnostics = nil
-        record = DependencyRecorder.record_for(path) do
-          diagnostics = analyze_with_effects(path, environment)
+        record = Plugin::IoBoundary.attributing(reads) do
+          DependencyRecorder.record_for(path) do
+            diagnostics = analyze_with_effects(path, environment)
+          end
         end
         @file_dependencies[path] = record
+        @analysis_reads[path] = reads unless reads.empty?
         diagnostics
       end
 

data/lib/rigor/analysis/shadow_harness.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Analysis
+    # The `RIGOR_SHADOW_RULE_WALK` switch, read in one place by both halves of the shadow harness: the rule
+    # walk's collectors (ADR-53 Track B, {CheckRules}) and the discovery tables (ADR-116 WD5,
+    # {Inference::DeclarationWalk::Shadow}, which also says how a run must be made), and by the cache keys that
+    # must not let a warm run answer for either. A leaf file, so the ADR-87 boot-slim probe loads it without
+    # any engine code.
+    module ShadowHarness
+      ENV_KEY = "RIGOR_SHADOW_RULE_WALK"
+
+      module_function
+
+      # Set to anything, `0` and the empty string included.
+      def enabled?
+        !ENV[ENV_KEY].nil?
+      end
+
+      # What the run-result cache and the incremental snapshot key on: nil with the harness off, which adds
+      # no key slot, so a run without the variable computes the key it computed before the harness existed.
+      def cache_identity
+        enabled? ? ENV_KEY : nil
+      end
+    end
+  end
+end