rigortype 0.4.4 → 0.4.5

data/lib/rigor/analysis/runner/pool_coordinator.rb

@@ -111,6 +111,13 @@ module Rigor
         # so the incremental session's dependency graph is refreshed whether analysis ran sequential or pooled.
         attr_reader :collected_dependencies
 
+        # Issue #1553 — the per-file plugin reads the fork pool's workers recorded this run (empty unless
+        # `record_dependencies:` and a pool run occurred), folded into `Runner#analysis_reads`. Each worker's are
+        # marshalled back beside its dependency records.
+        def collected_analysis_reads
+          @collected_analysis_reads ||= {}
+        end
+
         # ADR-103 WD12 — the per-file {Effects::FileCollection}s the fork pool captured this run (empty
         # unless the configuration carries an `effects:` block and a pool run occurred). The runner merges
         # these with its own sequential records before the post-pool fixpoint.
@@ -197,13 +204,17 @@ module Rigor
             if pool_mode?
               dispatch_pool(files, source_files: source_files)
             else
-              analyze_files_sequentially(
-                files, environment || resolve_sequential_environment(source_files: source_files)
-              )
+              environment ||= resolve_sequential_environment(source_files: source_files)
+              analyze_files_sequentially(files, environment)
             end
           # Issues #796 / #794 — a narrowed run's own demand set is a SUBSET of the full run's, so the two
-          # rows below are folded in after it, whichever backend produced the per-file stream.
-          replayed_restored_run_level_rows?(closure: files)
+          # rows below are folded in after it, whichever backend produced the per-file stream. Issue #1929 —
+          # the sequential run's environment re-derives a stale replayed failure; a pool run has none on
+          # this side and resolves one only when a stale failure needs it.
+          redemand_env = lambda do
+            environment ||= resolve_sequential_environment(source_files: source_files)
+          end
+          replayed_restored_run_level_rows?(closure: files, redemand_env: redemand_env)
           result
         end
 
@@ -261,7 +272,9 @@ module Rigor
           # `env` rather than `resolve.call`: read the demand the snapshots above just made when they built
           # an environment, and force nothing when they did not.
           record_definition_build_failures(env&.rbs_loader&.definition_build_failures)
-          record_hkt_scan_failure(hkt_scan_outcome(resolve.call)) unless replayed_restored_run_level_rows?
+          # An empty closure analyses no file, so only a deleted file's buffer can make a tuple stale here.
+          replayed = replayed_restored_run_level_rows?(closure: [], redemand_env: resolve)
+          record_hkt_scan_failure(hkt_scan_outcome(resolve.call)) unless replayed
           prepare_rows
         end
 
@@ -319,18 +332,46 @@ module Rigor
         # of its own — and so no environment.
         #
         # @param closure — the files this run analyses; see {#stale_replayed_failure?}.
-        def replayed_restored_run_level_rows?(closure: nil)
+        # @param redemand_env — resolves the environment {#redemand_stale_failures} re-derives a stale
+        #   failure in; nil (the empty closure, which has no stale failure) re-derives nothing.
+        def replayed_restored_run_level_rows?(closure: nil, redemand_env: nil)
           rows = @restored_run_level_rows
           return false if rows.nil?
 
-          replayable = Array(rows.definition_build_failures).reject do |failure|
+          stale, replayable = Array(rows.definition_build_failures).partition do |failure|
             stale_replayed_failure?(failure, closure)
           end
           record_definition_build_failures(replayable)
+          redemand_stale_failures(stale, redemand_env)
           record_hkt_scan_failure(rows.hkt_scan_failure)
           true
         end
 
+        # Issue #1929 — a stale replayed failure is RE-DERIVED, not dropped. Dropping it was right for the
+        # class whose collision the edit removed, and wrong for every class the edit left failing: the file
+        # that demanded such a class usually sits outside the recheck's closure (the edited file only
+        # contributes a conflicting buffer, such as a missing superclass every subclass inherits), so
+        # nothing in the recheck asks for it again, and the row lost classes a cold run reports. The class
+        # is asked for again in this run's environment ({Environment::RbsLoader#redemand_definition}), so
+        # it is reported exactly when it still fails, with the tuple the current signatures give it.
+        #
+        # A class this run's own analysis already reported is skipped; its tuple is current. The residue:
+        # a class whose only demand was in an edited file that no longer makes it, and which still fails,
+        # stays reported until a full run. The failure itself is real, unlike the dropped-collision case
+        # this replaced.
+        def redemand_stale_failures(stale, redemand_env)
+          return if stale.empty? || redemand_env.nil?
+
+          reported = @snapshots.definition_build_failures.to_set(&:first)
+          pending = stale.map(&:first).reject { |name| reported.include?(name) }
+          return if pending.empty?
+
+          loader = redemand_env.call&.rbs_loader
+          return if loader.nil?
+
+          record_definition_build_failures(pending.filter_map { |name| loader.redemand_definition(name) })
+        end
+
         # A replayed definition-build failure the snapshot's own fingerprint cannot vouch for. The
         # fingerprint digests the three signature sources it can read WITHOUT an environment — `sig:`,
         # `Gemfile.lock` / `rbs_collection.lock.yaml`, and the configuration — but NOT the virtual RBS a
@@ -340,11 +381,11 @@ module Rigor
         # closure, its analysis demands nothing that would re-derive the row, and the run reports a
         # collision between files that no longer collide.
         #
-        # The narrowed run cannot re-derive the row either (#696 forbids Rigor demanding a definition the
-        # analysis did not), so the honest answer is to DROP it and under-report rather than assert a
-        # diagnostic on a program that may now be correct — false positives outrank worst-case reading. The
-        # cost is bounded to the row's own conflicting buffers: a collision between two files neither of
-        # which this run touches still replays.
+        # Such a failure is not replayed as it stands; {#redemand_stale_failures} re-derives it instead
+        # (#1929), so the row asserts no collision the current signatures do not have. A failure whose
+        # buffers name no file this run touches still replays. A buffer whose file no longer exists is stale
+        # too: deleting an inline source a tuple names would otherwise replay the deleted declaration's
+        # failure, where a full run reports what the remaining signatures give.
         def stale_replayed_failure?(failure, closure)
           return false if closure.nil?
 
@@ -354,7 +395,10 @@ module Rigor
           closure_paths = closure.to_set { |path| File.absolute_path(path.to_s) }
           Array(buffers).any? do |name|
             path = virtual_buffer_path(name)
-            !path.nil? && closure_paths.include?(File.absolute_path(path))
+            next false if path.nil?
+
+            absolute = File.absolute_path(path)
+            closure_paths.include?(absolute) || !File.exist?(absolute)
           end
         end
 
@@ -870,7 +914,7 @@ module Rigor
             merge_run_disclosures(session.drain_run_disclosures)
             # The degraded slice was re-analysed on the parent session, so its dependency records live there,
             # not in a child payload — fold them in alongside the successful children's.
-            @collected_dependencies.merge!(session.drain_dependencies) if @record_dependencies
+            collect_dependencies(session.drain_dependencies, session.drain_analysis_reads) if @record_dependencies
             @collected_effects.merge!(session.drain_effects) if @record_effects
           end
 
@@ -907,6 +951,7 @@ module Rigor
           results = slice.to_h { |path| [path, session.analyze(path)] }
           payload = { results: results, reporters: session.drain_reporters,
                       dependencies: session.drain_dependencies,
+                      analysis_reads: session.drain_analysis_reads,
                       disclosures: session.drain_run_disclosures,
                       refusals: session.drain_trust_refusals }
           # ADR-103 WD13 — the effects slot exists only on a collecting run, so a normal `--workers N` run
@@ -945,7 +990,9 @@ module Rigor
               merge_run_disclosures(payload.fetch(:disclosures, []))
               refusals = payload.fetch(:refusals, [])
               refusals_by_slice ? refusals_by_slice[child[:index]] = refusals : merge_trust_refusals(refusals)
-              @collected_dependencies.merge!(payload.fetch(:dependencies, {})) if @record_dependencies
+              if @record_dependencies
+                collect_dependencies(payload.fetch(:dependencies, {}), payload.fetch(:analysis_reads, {}))
+              end
               @collected_effects.merge!(payload.fetch(:effects, {})) if @record_effects
             else
               degraded.concat(child[:slice])
@@ -954,6 +1001,12 @@ module Rigor
           degraded
         end
 
+        # ADR-46 / issue #1553 — fold one worker's dependency records and per-file plugin reads.
+        def collect_dependencies(dependencies, analysis_reads)
+          @collected_dependencies.merge!(dependencies)
+          collected_analysis_reads.merge!(analysis_reads)
+        end
+
         # @return the child's `{results:, reporters:}` payload, or nil when the child exited
         #   abnormally or wrote no readable payload. `Marshal.load` is safe here: the blob was written by
         #   our own forked child to a temp file we created.

data/lib/rigor/analysis/runner.rb

@@ -26,6 +26,7 @@ require_relative "../effects/identity"
 require_relative "../effects/propagator"
 require_relative "../inference/parameter_inference_collector"
 require_relative "../inference/pre_eval_constants"
+require_relative "../inference/project_seed_tables"
 require_relative "../inference/scope_indexer"
 require_relative "../inference/synthetic_method_scanner"
 require_relative "../inference/project_patched_scanner"
@@ -98,6 +99,16 @@ module Rigor
         pooled.empty? ? @file_dependencies : @file_dependencies.merge(pooled)
       end
 
+      # Issue #1553 — the plugin reads ({Plugin::IoBoundary.attributing}) each file's analysis made this run,
+      # `{path => [row]}`, reconciled from the sequential and pooled halves exactly as {#file_dependencies} is.
+      # Empty unless `record_dependencies: true`; a file whose analysis read nothing has no key. The incremental
+      # session keeps them beside each file's cached rows so a later recheck re-analyses the file once one of
+      # them goes stale.
+      def analysis_reads
+        pooled = @pool_coordinator.collected_analysis_reads
+        pooled.empty? ? @analysis_reads : @analysis_reads.merge(pooled)
+      end
+
       # ADR-103 — the run's propagated effect graph, or {Effects::EffectTable.empty} when collection did
       # not run. Reconciled from the sequential and pooled halves exactly as {#file_dependencies} is, then
       # closed by the post-pool fixpoint in {#assemble_run_diagnostics}.
@@ -464,6 +475,9 @@ module Rigor
         @project_struct_member_layouts = {}.freeze
         # Issue #684 — set per run by {#project_discovery_expansion}; nil on every path that does not widen.
         @project_discovery_expansion = nil
+        # Issue #1583 — whether this run widened its discovery to the configured paths, even when the widening
+        # added no file; {#discovery_glob_entries} lists the configured roots for every such run.
+        @discovery_widened = false
         # ADR-67 WD6a — the call-site parameter-inference table, populated by the opt-in pre-pass in
         # `assemble_run_diagnostics` when `parameter_inference:` is enabled, then seeded onto every per-file
         # scope (sequential + fork-worker) through `project_scope_seed_tables`. Empty by default, so the gate-off
@@ -518,6 +532,7 @@ module Rigor
 
         expansion = expand_paths(paths)
         @project_discovery_expansion = project_discovery_expansion(paths, expansion)
+        @discovery_widened = widen_discovery_to_project?(paths)
         @snapshots.reset_for_run
         # Per-run reset of the deferred-discovery memo (see `#ensure_project_discovery`).
         @project_discovery_done = false
@@ -599,6 +614,19 @@ module Rigor
         expand_paths(paths).fetch(:files)
       end
 
+      # Issue #1583 — the project files a run over `paths` would DISCOVER without analysing them (#684's
+      # widening), by globbing only. Empty whenever the run would not widen, which includes every run over
+      # the configured `paths:`. {IncrementalSession} digests them, because an edit to one moves the
+      # diagnostics of the files it does analyse.
+      def discovery_only_file_set(paths = @configuration.paths)
+        expansion = expand_paths(paths)
+        widened = project_discovery_expansion(paths, expansion)
+        return [] if widened.nil?
+
+        analysed = expansion.fetch(:files).to_set
+        widened.fetch(:files).reject { |path| analysed.include?(path) }
+      end
+
       # ADR-46 §2 — inverts {#file_dependencies} into the reverse edge the incremental step walks:
       # `dependents[X] = { A : A read a declaration / body from X }`. On an edit to X, the body tier
       # (slice 2) re-analyses `{X} ∪ dependents[X]` and serves every other file from the per-file cache.
@@ -791,6 +819,7 @@ module Rigor
         @project_discovery_done = false
         # This entry point supplies its own expansion; it never widens (see {#project_discovery_expansion}).
         @project_discovery_expansion = nil
+        @discovery_widened = false
         @run_generation = Object.new.freeze
         run_project_pre_passes(expansion: expansion)
         ensure_project_discovery(expansion)
@@ -1391,7 +1420,7 @@ module Rigor
         # #979 — the signature ROOTS' listings, one glob row each. `rbs_descriptor.files` covers only the
         # `.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
+        globs = rbs_descriptor.globs + template_unit_glob_entries + discovery_glob_entries
         boundary = plugin_boundary_rows
         entries.concat(boundary.files)
         globs.concat(boundary.globs).concat(producer_watch_glob_entries)
@@ -1406,7 +1435,7 @@ module Rigor
       # auto-detected `sig`: the loader reads a directory and a file differently, and #979's listing rows cover a
       # file appearing under a root that existed, not the root appearing. A kind row rather than an existence row,
       # because a directory replaced by a file of the same name leaves an existence row fresh. The `--incremental`
-      # slot records existence rows for the same paths ({#incremental_slot_rows}, {#baseline_dependency_rows}).
+      # slot records kind rows for the same paths ({#incremental_slot_rows}, {#baseline_dependency_rows}, #1977).
       def root_presence_entries(expansion)
         (expansion.fetch(:roots) + @configuration.pre_eval + signature_root_candidates)
           .uniq.map { |path| Cache::Descriptor::FileEntry.kind(path: path) }
@@ -1452,11 +1481,11 @@ module Rigor
       #   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.
+      #   every run), and one `:kind` row per analysis root and per `pre_eval:` entry. A run's path errors (`no
+      #   such file or directory`, `not a Ruby file`, `pre-eval.file-not-found`) answer to those last rows, 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. A kind row rather than an existence row (#1977): an
+      #   existence row reads a directory replaced by a file of the same name as fresh, ADR-45 WD1b's bound.
       # - `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.
@@ -1480,7 +1509,7 @@ module Rigor
         IncrementalSlotRows.new(
           observed: plugin_boundary_rows,
           derived: Cache::Descriptor.new(
-            files: template_unit_file_entries + existence_entries(Array(roots) + @configuration.pre_eval),
+            files: template_unit_file_entries + kind_entries(Array(roots) + @configuration.pre_eval),
             globs: template_unit_glob_entries
           ),
           by_file: @analysis_reads.transform_values do |reads|
@@ -1507,13 +1536,14 @@ module Rigor
       # 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;
+      #   roots this run's analysis resolved), and a `:kind` row per signature root, configured or the
+      #   auto-detected `sig` — a recheck rebuilds no environment unless its closure is non-empty. The snapshot
+      #   fingerprint digests the same roots, so a change to one makes the next full-path run a full run rather
+      #   than a recheck, but the engine-free slot probe serves before any fingerprint is consulted: a root that
+      #   turns from a file into a directory (or back) is declined there by this `:kind` row alone (#1977);
       # - 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
+      # - every `pre_eval:` file outside `files` (a stat row, or a kind 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
@@ -1537,7 +1567,7 @@ module Rigor
         own, pinned = signature_rows
         BaselineRows.new(
           owned: Cache::Descriptor.new(
-            files: own.files + existence_entries(signature_root_candidates) +
+            files: own.files + kind_entries(signature_root_candidates) +
                    discovery_file_entries({ files: files }) + unanalysed_pre_eval_entries(files),
             globs: (own.globs + discovery_glob_entries).uniq
           ),
@@ -1563,16 +1593,18 @@ module Rigor
 
       # 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.
+      # signature rows' listing rows cover a file appearing under a root that existed; only a row for the root
+      # itself covers it 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.
+      # as well as an edit to one that existed. Issue #1583 — keyed on the widening decision, not on what it
+      # added: a run over `lib/b.rb` alone in `lib` widens to nothing, and a `lib/a.rb` created afterwards must
+      # still move the answer of the run-result cache and the `--incremental` slot.
       def discovery_glob_entries
-        return [] if @project_discovery_expansion.nil?
+        return [] unless @discovery_widened
 
         @configuration.paths.select { |root| File.directory?(root) }.map do |root|
           Cache::Descriptor::GlobEntry.compute(root: root, pattern: PathExpansion::RUBY_GLOB, mode: :names)
@@ -1586,22 +1618,18 @@ module Rigor
           if File.file?(path)
             Cache::Descriptor::FileEntry.stat(path: path, digest: Cache::FileDigest.hexdigest(path))
           else
-            existence_entries([path]).first
+            kind_entries([path]).first
           end
         end
       end
 
-      def existence_entries(paths)
+      # #1977 — one `:kind` row per path, the row {#root_presence_entries} records in the plain slot.
+      def kind_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
+          Cache::Descriptor::FileEntry.kind(path: @buffer ? @buffer.resolve(path) : path)
         end
       end
-      private :plugin_boundary_rows, :producer_watch_glob_entries, :existence_entries, :root_presence_entries,
+      private :plugin_boundary_rows, :producer_watch_glob_entries, :kind_entries, :root_presence_entries,
               :analysis_reads_attributed?, :signature_root_candidates, :discovery_glob_entries,
               :unanalysed_pre_eval_entries, :signature_rows, :within?
 
@@ -1825,8 +1853,14 @@ module Rigor
       # on what else was on the command line.
       #
       # 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).
+      # seeds discovery from a snapshot), editor `buffer:` mode, and `run_source`'s in-memory single file.
+      #
+      # Issue #1583 — ADR-46's `analyze_only` subset mode widens like a full run. It was excluded on the
+      # reading that it "already passes the full expansion", which holds only when the incremental session
+      # runs over the configured `paths:`. `rigor check --incremental lib/b.rb` passes the argument's
+      # expansion, so its rechecks (and `--verify-incremental`'s partitions) discovered the argument alone
+      # while its baseline discovered the project, and `lib/b.rb`'s report on a sibling's constant came and
+      # went with the run kind.
       #
       # 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:
@@ -1864,8 +1898,7 @@ module Rigor
       end
 
       def widen_discovery_to_project?(paths)
-        @prebuilt.nil? && @buffer.nil? && @in_memory_sources.nil? && @analyze_only.nil? &&
-          paths != @configuration.paths
+        @prebuilt.nil? && @buffer.nil? && @in_memory_sources.nil? && paths != @configuration.paths
       end
 
       # ADR-46 — the dependency-recording and subset-analysis modes read the discovery tables OUTSIDE the
@@ -2425,50 +2458,21 @@ module Rigor
         tables[:published_constant_names] = names unless names.empty?
       end
 
-      # Issue #617 — the censused names that bind, grouped by last segment (`Scope#bound_constant_names`). A
-      # name some write other than a memo `||=` touches always binds. A memo-only name binds once memos of its
-      # segment span two files: either may load first and set the constant the other then reads, so only a
-      # memo no other file shares keeps the idiom's reading. Files are counted expanded, because discovery can
-      # walk one file under two spellings (`lib/b.rb`, `./lib/b.rb`).
+      # Issue #617 / #1290 — the binding and shadowing constant names, by last segment; derived by
+      # {Inference::ProjectSeedTables}, which the seed paths that run no `check` share.
       def constant_writer_index
-        @constant_writer_index ||= begin
-          memo_files = memo_files_by_segment
-          @project_constant_writes.each_with_object({}) do |(name, by_path), index|
-            segment = name.split("::").last
-            next if memo_only?(by_path) && memo_files.fetch(segment).size < 2
-
-            (index[segment] ||= []) << name
-          end.each_value(&:freeze).freeze
-        end
+        @constant_writer_index ||= Inference::ProjectSeedTables.constant_writers(@project_constant_writes)
       end
 
-      # Issue #1290 — the censused names some write other than a memo `||=` assigns, grouped by last segment
-      # (`Scope#shadowing_constant_names`): the ones that exist whether or not an outer constant of the name
-      # does, and so stop the lexical ladder above it. A memo-only name is left out however many files memoize
-      # it, unlike in {#constant_writer_index}: `X ||= v` resolves `X` through the very lookup whose lower rung
-      # the stop would replace, so wherever that rung answers, the memo finds it and never creates the name.
       def constant_shadower_index
-        @constant_shadower_index ||= @project_constant_writes.each_with_object({}) do |(name, by_path), index|
-          (index[name.split("::").last] ||= []) << name unless memo_only?(by_path)
-        end.each_value(&:freeze).freeze
+        @constant_shadower_index ||= Inference::ProjectSeedTables.constant_shadowers(@project_constant_writes)
       end
 
-      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.absolute_path(path) if memo_descriptor?(descriptor) }
-        end
-      end
-
-      def memo_only?(by_path) = by_path.each_value.all? { |descriptor| memo_descriptor?(descriptor) }
-      def memo_descriptor?(descriptor) = descriptor == Inference::ScopeIndexer::CONSTANT_MEMO
-
       # Issue #644 — the LAST SEGMENTS of the published table, the run-wide half of
       # `Scope#published_constant?`. Seeded on EVERY run (unlike `constant_sources`, which only a recording
       # run needs) because {CheckRules::PublishedConstantGuard} asks the question on every `if` / `unless`.
       def published_constant_name_set
-        @published_constant_name_set ||=
-          @project_constant_values.keys.to_set { |name| name.split("::").last }.freeze
+        @published_constant_name_set ||= Inference::ProjectSeedTables.published_constant_names(@project_constant_values)
       end
 
       # Issue #644 — the seeded `in_source_constants` table, joining the two cross-file constant producers.

data/lib/rigor/analysis/severity_stamp.rb

@@ -19,6 +19,9 @@ module Rigor
     # `plugin.<id>`, never to a bare id or `all`. The run-level rows outside the check-rule catalogue
     # (`rbs.coverage.*`, `dynamic.dependency-source.*`, the plugin loader, `plugin_trust.*`, `pool-degraded`) keep
     # answering to `severity_overrides:` only, by any spelling.
+    # Issue #1985 — `severity_overrides:` follows the same rule: a plugin's row answers to its qualified id or
+    # `plugin.<id>`, never to its bare rule or a family wildcard; the plugin loader's rows answer to
+    # `plugin_loader.<rule>` first and to their bare `load-error` / `runtime-error` after it.
     #
     # Extracted (ADR-87 WD4) so the miss path ({Runner::DiagnosticAggregator}) and the boot-slimming hit path
     # ({RunCacheProbe}, which never loads the aggregator) apply the IDENTICAL final filter — a warm HIT's
@@ -52,11 +55,19 @@ module Rigor
         diagnostic.source_family == Diagnostic::DEFAULT_SOURCE_FAMILY && CHECK_RULES.include?(diagnostic.rule)
       end
 
+      # `plugin.<id>` for a row a plugin emitted, nil for every other row.
+      def plugin_family(diagnostic)
+        family = diagnostic.source_family.to_s
+        family if family.start_with?(CheckRules::PLUGIN_FAMILY_PREFIX)
+      end
+
       def stamp(diagnostic, configuration)
         return diagnostic if diagnostic.rule.nil?
 
         resolved = Configuration::SeverityProfile.resolve(
           rule: diagnostic.rule,
+          qualified_rule: diagnostic.qualified_rule,
+          plugin_family: plugin_family(diagnostic),
           authored_severity: diagnostic.severity,
           profile: configuration.severity_profile,
           overrides: configuration.severity_overrides,

data/lib/rigor/analysis/worker_session.rb

@@ -170,8 +170,13 @@ module Rigor
         return analyze_with_effects(path) unless @record_dependencies
 
         diagnostics = nil
-        record = DependencyRecorder.record_for(path) { diagnostics = analyze_with_effects(path) }
+        reads = []
+        record = Plugin::IoBoundary.attributing(reads) do
+          DependencyRecorder.record_for(path) { diagnostics = analyze_with_effects(path) }
+        end
         @file_dependencies[path] = record
+        # Issue #1553 — the plugin reads this file's analysis made, as `Runner#analyze_file` keeps them.
+        (@analysis_reads ||= {})[path] = reads unless reads.empty?
         diagnostics
       end
 
@@ -309,6 +314,12 @@ module Rigor
         @file_dependencies
       end
 
+      # Issue #1553 — the plugin reads ({Plugin::IoBoundary.attributing}) each `#analyze` call's file made (empty
+      # unless `record_dependencies:` was set). The rows are value objects of frozen Strings, so they marshal back.
+      def drain_analysis_reads
+        @analysis_reads || {}
+      end
+
       # ADR-103 WD12 — the per-file {Effects::FileCollection}s this session collected (empty unless the
       # configuration carries an `effects:` block). Marshal-clean by construction — frozen Hashes of
       # Strings, `LabelSet`s of frozen Arrays, and `Data` edges — so the fork pool ships them back to the

data/lib/rigor/cache/descriptor.rb

@@ -4,6 +4,7 @@ require "digest"
 require "json"
 require_relative "../value_semantics"
 require_relative "file_digest"
+require_relative "../rooted_glob"
 
 module Rigor
   module Cache
@@ -87,7 +88,13 @@ module Rigor
       # appears, vanishes or changes kind invalidates the warm entry. A
       # pre-19 entry carries none of them and would validate fresh across exactly those edits, so cached
       # entries must read as misses once and rebuild carrying the rows.
-      SCHEMA_VERSION = 19
+      # v20: #1977 — the `--incremental` run-result slot records a `:kind` row, not an existence row, per analysis
+      # root, `pre_eval:` entry and project signature root. A pre-20 slot's existence row validates fresh across a
+      # directory replaced by a file of the same name, so it must read as a miss once and rebuild.
+      # v21: #1984 — the visibility walk records each class's singleton slots (`[:singleton, name]`) in the seed
+      # bundles' `method_visibilities`. A pre-21 bundle carries none for an unchanged file, so cached bundles must read
+      # as misses once and rebuild carrying them.
+      SCHEMA_VERSION = 21
 
       # Per-slot entry value objects. Constructors validate enums / required fields and freeze the resulting
       # struct so no caller can mutate after the entry is in a Descriptor.
@@ -325,7 +332,12 @@ module Rigor
         # tuple moves, so a `git checkout`, a `bundle install` or a CI cache restored over a fresh checkout
         # keeps the file rows fresh while it would move every glob signature, turning every such run into a
         # full re-analysis. `:names` also reads no stat at all, so it costs a `Dir.glob` and nothing else.
-        VALID_MODES = %i[stat names].freeze
+        #
+        # `:kinds` (#1959) is `:names` plus each match's `File.lstat` file type: the set moves it, and so does a
+        # path that keeps its name and changes kind (a file `gen` replaced by a directory `gen/`, a symlinked
+        # directory replaced by a real one). It reads one `lstat` per match and no content, so a `touch` or an
+        # edit leaves it fresh.
+        VALID_MODES = %i[stat names kinds].freeze
 
         attr_reader :root, :pattern, :value
 
@@ -357,13 +369,15 @@ module Rigor
         # The aggregate signature the entry's `value` carries: SHA-256 over the sorted per-file rows. In the
         # default (`:stat`) mode a row is the file's `(path, size, mtime_ns, ctime_ns, inode)` tuple — NO
         # content read; in strict mode a row is `(path, content-sha256)`, restoring the pre-ADR-87 authority.
-        # In `:names` mode a row is the path alone, stat-free, so only the matching SET moves the signature.
+        # In `:names` mode a row is the path alone, stat-free, so only the matching SET moves the signature; in
+        # `:kinds` mode it is the path and its {.lstat_kind}.
         # Per-file stat failures (a file vanishing between the glob and the stat) drop the row — same race
         # posture as {Descriptor#file_entry_fresh?}. `Dir.glob` returns sorted entries by default so the row
         # order — and therefore the signature — is stable.
         def self.signature_for(root:, pattern:, mode: :stat)
-          paths = Dir.glob(File.join(root, pattern))
+          paths = RootedGlob.glob(root, pattern)
           return Digest::SHA256.hexdigest(paths.map { |path| "#{path}#{ROW_SEPARATOR}" }.join) if mode == :names
+          return kinds_signature(paths) if mode == :kinds
 
           strict = FileDigest.strict_validation?
           rows = paths.filter_map do |path|
@@ -382,10 +396,29 @@ module Rigor
           Digest::SHA256.hexdigest(rows.join)
         end
 
+        # #1959 — what `path` itself is, a symlink not followed: `:file`, `:directory`, `:symlink` or `:other`, and
+        # `:absent` for a path that vanished between the glob and the `lstat`.
+        def self.lstat_kind(path)
+          case File.lstat(path).ftype
+          when "file" then :file
+          when "directory" then :directory
+          when "link" then :symlink
+          else :other
+          end
+        rescue SystemCallError
+          :absent
+        end
+
+        def self.kinds_signature(paths)
+          rows = paths.map { |path| "#{path}#{FIELD_SEPARATOR}#{lstat_kind(path)}#{ROW_SEPARATOR}" }
+          Digest::SHA256.hexdigest(rows.join)
+        end
+        private_class_method :kinds_signature
+
         # ADR-87 WD2 — fresh iff re-globbing + re-stat-ing reproduces the recorded signature. Zero file-content
-        # bytes are read in the default mode, and no stat at all in `:names`. Any failure reads as stale
-        # (recompute), never a crash. A stored signature recorded under the opposite validation mode simply
-        # mismatches and recomputes.
+        # bytes are read in the default mode, no stat at all in `:names`, and one `lstat` per match in `:kinds`.
+        # Any failure reads as stale (recompute), never a crash. A stored signature recorded under the opposite
+        # validation mode simply mismatches and recomputes.
         def self.fresh?(entry)
           signature_for(root: entry.root, pattern: entry.pattern, mode: entry.mode) == entry.value
         rescue StandardError

data/lib/rigor/cache/engine_source.rb

@@ -4,6 +4,7 @@ require "digest"
 
 require_relative "../version"
 require_relative "descriptor"
+require_relative "../rooted_glob"
 
 module Rigor
   module Cache
@@ -195,8 +196,8 @@ module Rigor
       # Sorted, de-duplicated absolute paths of every engine `.rb` file and {DATA_GLOBS} data file, across
       # the directories that exist. `plugins/*/sig/**/*.rbs` overlaps nothing else but is de-duplicated anyway.
       def source_files(root)
-        sources = SOURCE_DIRECTORIES.flat_map { |relative| Dir.glob(File.join(root, relative, "**", "*.rb")) }
-        data = DATA_GLOBS.flat_map { |pattern| Dir.glob(File.join(root, pattern)) }
+        sources = SOURCE_DIRECTORIES.flat_map { |relative| RootedGlob.glob(root, File.join(relative, "**", "*.rb")) }
+        data = DATA_GLOBS.flat_map { |pattern| RootedGlob.glob(root, pattern) }
         (sources + data).uniq.sort
       end
     end