rigortype 0.3.9 → 0.4.0

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../check_rules/rule_ids"
 require_relative "../crash_signature"
 require_relative "../diagnostic"
 require_relative "../severity_stamp"
@@ -39,7 +40,9 @@ module Rigor
         #   (`[error_class, first_error_line, conflicting_buffer_names]`) or nil when the env built.
         # @param definition_build_failures_snapshot — issue #696 — reader returning the per-class
         #   `RBS::DefinitionBuilder` failures the run observed, as `[class_name, error_class, member,
-        #   conflicting_buffer_names]` tuples. Empty for a healthy sig set.
+        #   conflicting_buffer_names, unresolved_type_name_detail]` tuples (issue #997 added the fifth
+        #   element — `[token, location, refinement_hint]`, `nil` unless `error_class` is
+        #   `RBS::NoTypeFoundError`). Empty for a healthy sig set.
         # @param hkt_scan_failure_snapshot — issue #784 — reader returning the `[error_class_name,
         #   first_message_line, raw_frame_or_nil, stage]` tuple whichever stage of the HKT-registry build
         #   raised, or nil when both built (or were never demanded). `stage` is `:scan` (the RBS `type`-alias
@@ -51,7 +54,8 @@ module Rigor
                        pre_eval_diagnostics_from_scanner:, synthesized_namespaces_snapshot:,
                        quarantined_signatures_snapshot:, env_build_failure_snapshot:,
                        definition_build_failures_snapshot:, hkt_scan_failure_snapshot:,
-                       conformance_results_snapshot:, signature_standdowns_snapshot: -> { [] })
+                       conformance_results_snapshot:, signature_standdowns_snapshot: -> { [] },
+                       pooled_run_disclosures: -> { [] })
           @configuration = configuration
           @rbs_extended_reporter = rbs_extended_reporter
           @boundary_cross_reporter = boundary_cross_reporter
@@ -68,6 +72,9 @@ module Rigor
           @definition_build_failures_snapshot_reader = definition_build_failures_snapshot
           @hkt_scan_failure_snapshot_reader = hkt_scan_failure_snapshot
           @conformance_results_snapshot_reader = conformance_results_snapshot
+          # Issue #1051 — reader for the pool coordinator's de-duplicated run-scoped disclosure table.
+          # Empty on a sequential run, where `plugin_registry`'s own instances are the ones that registered.
+          @pooled_run_disclosures_reader = pooled_run_disclosures
         end
 
         # Pre-file diagnostic streams that fire once per run rather than per analyzed file: plugin load /
@@ -441,8 +448,9 @@ module Rigor
         # "Explicit conformance directive"). A class that declares `conforms-to _Interface` but is missing
         # a required interface method surfaces as `rbs_extended.unsatisfied-conformance`; an unresolvable
         # interface name surfaces as `dynamic.rbs-extended.unresolved` `:info` (the same fail-soft channel
-        # the other directive parsers use). Empty for a project with no directive, a well-formed
-        # conformance, or a non-sequential pool run (the snapshot mirrors `synthesized_namespaces`).
+        # the other directive parsers use). Empty for a project with no directive or a well-formed
+        # conformance; every analysis path, pooled or degraded, takes the snapshot `synthesized_namespaces`
+        # comes from.
         def conforms_to_diagnostics
           results = conformance_results_snapshot
           return [] if results.nil? || results.empty?
@@ -585,22 +593,50 @@ module Rigor
         end
 
         # The closing advice follows the FIRST failure's error class: `GenericParameterMismatchError` is two
-        # declarations of one CLASS at different generic arity (#610), and "remove the duplicate member"
-        # sends its reader after a member that does not exist.
+        # declarations of one CLASS at different generic arity (#610); `NoTypeFoundError` (issue #997) is
+        # ONE declaration naming a type that does not exist, which "remove the duplicate declaration" sends
+        # its reader after a duplicate that is not there — the fifth tuple element
+        # ({RbsLoader#unresolved_type_name_detail}) is non-nil for exactly that case. Every other error class
+        # (the two duplicated-definition errors, `RecursiveAncestorError`, …) keeps the duplicate-declaration
+        # wording, which is accurate for them.
         def definition_build_advice(failure)
-          _, error_class, = failure
+          _, error_class, _member, _buffers, unresolved = failure
           if error_class.to_s.end_with?("GenericParameterMismatchError")
             "Two signature sources declare the class with a different number of type parameters; make " \
               "the declarations agree (`rbs validate`) to restore type coverage."
+          elsif unresolved
+            unresolved_type_name_advice(unresolved)
           else
             "Two signature sources declare the same member; remove the duplicate declaration " \
               "(`rbs validate`) to restore type coverage."
           end
         end
 
-        # `[class_name, error_class, member, buffers]`. The member is nil for the error classes that carry no
-        # name at all (`RecursiveAncestorError`), and the clause then names the error class alone rather than
-        # inventing a member.
+        # Issue #997 — `unresolved` is {RbsLoader#unresolved_type_name_detail}'s `[token, location,
+        # refinement_hint]`. `refinement_hint` turns the message into a fix: the token is not a typo to
+        # chase down but the start of a Rigor refinement name that is not valid in an RBS type position, and
+        # the reader is told the spelling that IS valid today. Without a hint, the token is named with its
+        # position and the reader is left with the same "not a duplicate" correction plus a typo/missing-load
+        # check — still narrower than the duplicate-declaration wording it replaces.
+        def unresolved_type_name_advice(unresolved)
+          token, location, refinement_hint = unresolved
+          position = location ? " at `#{location}`" : ""
+          if refinement_hint
+            "`#{token}`#{position} does not name a type RBS can resolve; it is the start of the Rigor " \
+              "refinement `#{refinement_hint}`, which is not valid in an RBS type position. Write it as " \
+              "an `%a{rigor:v1:param: name is #{refinement_hint}}` (or `return:` / `assert`) annotation " \
+              "alongside the plain RBS type instead — see docs/manual/16-rbs-extended-annotations.md — " \
+              "to restore type coverage."
+          else
+            "One signature source names `#{token}`#{position}, which is not a type RBS can resolve; fix " \
+              "the typo, or if it names a class, confirm it is loaded (`rbs validate`) to restore type " \
+              "coverage."
+          end
+        end
+
+        # `[class_name, error_class, member, buffers, unresolved_type_name_detail]`. The member is nil for
+        # the error classes that carry no name at all (`RecursiveAncestorError`), and the clause then names
+        # the error class alone rather than inventing a member.
         def first_failure_clause(failure)
           _, error_class, member, = failure
           return " First failure: #{error_class}." if member.nil? || member.empty?
@@ -849,10 +885,29 @@ module Rigor
           return [] if @source_rbs_synthesis_reporter.empty?
 
           @source_rbs_synthesis_reporter.entries.map do |entry|
-            entry.kind == :not_honoured ? not_honoured_diagnostic(entry) : synthesis_failed_diagnostic(entry)
+            case entry.kind
+            when :not_honoured then not_honoured_diagnostic(entry)
+            when :contradiction then contradicting_signature_diagnostic(entry)
+            else synthesis_failed_diagnostic(entry)
+            end
           end
         end
 
+        # ADR-112 WD5 / issue #1075 — a member whose two declarations contradict, or whose refinement is
+        # outside its own declared type. An error in every profile: the false-positive discipline is carried
+        # by the rule's narrow definition of a contradiction, never by the severity (ADR-112 WD5). The message
+        # is composed where the record is read ({Environment.record_member_consistency}), since only there
+        # are both sources' paths at hand.
+        def contradicting_signature_diagnostic(entry)
+          Diagnostic.new(
+            path: entry.path, line: entry.line || 1, column: 1,
+            message: entry.message,
+            severity: :error,
+            rule: CheckRules::RULE_CONTRADICTING_SIGNATURE,
+            source_family: :builtin
+          )
+        end
+
         def synthesis_failed_diagnostic(entry)
           Diagnostic.new(
             path: entry.path, line: 1, column: 1,
@@ -938,6 +993,103 @@ module Rigor
           plugin_registry.plugins.filter_map { |plugin| plugin_trust_refusal_diagnostic(plugin) }
         end
 
+        # Issue #1051 — the run-scoped plugin disclosures ({Plugin::Base#disclose_once}), the run's
+        # project-global notices about its own inputs. Two sources feed one table:
+        #
+        # - the coordinator-side registry, which is where a SEQUENTIAL run's `#prepare` and per-file hooks
+        #   ran; and
+        # - `pooled_run_disclosures`, the pool coordinator's already-de-duplicated collection from the
+        #   pre-fork parent session and every worker payload.
+        #
+        # Both are keyed `[plugin id, key]` and the first registration of a pair wins, so a run emits one
+        # row per pair no matter how many plugin instances (workers) reached it — the #1051 bug, where a
+        # per-instance `@emitted` flag produced one row per WORKER.
+        #
+        # The emitted order is `(registry position, key)`, NOT registration order: a worker's slice
+        # determines which instance registers a key first, so registration order is a function of
+        # `--workers N` and would make a pooled run's stream differ from a sequential one's even with the
+        # duplicates gone. Registry position is the plugin load order (topological by `consumes:`), which
+        # both modes share.
+        #
+        # Position is `.rigor.yml:1:1` for every row; see {Plugin::Base#disclose_once} for why that and not
+        # the first analysed file. A positioned batch ({Plugin::Base#emit_once}) shares the table but not
+        # this stream — see {#plugin_run_emission_diagnostics}.
+        def plugin_run_disclosure_diagnostics
+          ordered_run_disclosure_records
+            .reject { |record| record.key?(:diagnostics) }
+            .map { |record| run_disclosure_diagnostic(record) }
+        end
+
+        # Issue #1060 — the positioned batches ({Plugin::Base#emit_once}) from the same table, de-duplicated
+        # by the same `[plugin id, key]` identity over the same sources, so the first registration of a key
+        # wins whole and a batch is never merged row by row across workers. Unlike a disclosure, every row
+        # keeps the position the plugin gave it; the engine only stamps `source_family: "plugin.<id>"`, the
+        # same stamp a `#diagnostics_for_file` row gets, so a baseline keyed to the row's own file and
+        # qualified rule matches it before and after a plugin moves onto this channel.
+        #
+        # Order is `(registry position, key)` and then the batch's own row order — the same
+        # `--workers`-independent order the disclosure stream uses. The runner appends this stream right
+        # after the per-file stream rather than into the run-level block: these rows are about files, and
+        # the files they name are usually not among the analysed targets (a view template), so there is no
+        # file slot to splice them into.
+        def plugin_run_emission_diagnostics
+          ordered_run_disclosure_records
+            .select { |record| record.key?(:diagnostics) }
+            .flat_map { |record| record[:diagnostics].map { |row| run_emission_diagnostic(row, record[:plugin_id]) } }
+        end
+
+        def ordered_run_disclosure_records
+          registry = plugin_registry
+          return [] if registry.empty?
+
+          positions = {}
+          registry.plugins.each_with_index { |plugin, index| positions[disclosure_plugin_id(plugin)] ||= index }
+          collect_run_disclosure_records(registry)
+            .sort_by { |record| [positions.fetch(record[:plugin_id], positions.size), record[:key].to_s] }
+        end
+
+        def collect_run_disclosure_records(registry)
+          records = {}
+          Array(pooled_run_disclosures).each do |record|
+            records[[record[:plugin_id], record[:key]]] ||= record
+          end
+          registry.plugins.each do |plugin|
+            plugin_id = disclosure_plugin_id(plugin)
+            Array(plugin.run_disclosure_records).each do |record|
+              records[[plugin_id, record[:key]]] ||= record.merge(plugin_id: plugin_id)
+            end
+          rescue StandardError
+            next
+          end
+          records.values
+        end
+
+        def run_disclosure_diagnostic(record)
+          Diagnostic.new(
+            path: ".rigor.yml", line: 1, column: 1,
+            message: record.fetch(:message),
+            severity: record.fetch(:severity),
+            rule: record.fetch(:rule),
+            source_family: "plugin.#{record[:plugin_id]}"
+          )
+        end
+
+        def run_emission_diagnostic(row, plugin_id)
+          Diagnostic.new(
+            path: row.path, line: row.line, column: row.column,
+            message: row.message,
+            severity: row.severity,
+            rule: row.rule,
+            source_family: "plugin.#{plugin_id}"
+          )
+        end
+
+        def disclosure_plugin_id(plugin)
+          plugin.manifest.id
+        rescue StandardError
+          plugin.class.to_s
+        end
+
         def plugin_trust_refusal_diagnostic(plugin)
           summary = plugin.io_boundary.refusal_summary
           return nil if summary.nil?
@@ -1024,6 +1176,10 @@ module Rigor
           @cached_plugin_prepare_diagnostics_reader.call
         end
 
+        def pooled_run_disclosures
+          @pooled_run_disclosures_reader.call
+        end
+
         def pre_eval_diagnostics_from_scanner
           @pre_eval_diagnostics_from_scanner_reader.call
         end

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

@@ -250,9 +250,7 @@ module Rigor
           )
         end
 
-        def table_class_names
-          @effect_table.keys.filter_map { |key| Effects::MethodKey.owner(key) }.uniq
-        end
+        def table_class_names = @effect_table.keys.filter_map { |k| Effects::MethodKey.envelope_owner(k) }.uniq
 
         def judge(scan)
           Effects::EnvelopeCheck.run(
@@ -301,7 +299,7 @@ module Rigor
 
         def build_diagnostic(finding)
           Diagnostic.new(
-            path: finding.path || ".rigor.yml",
+            path: finding.path || unit_source_path(finding.key) || ".rigor.yml",
             line: finding.line,
             column: 1,
             message: message_for(finding),
@@ -312,6 +310,13 @@ module Rigor
           )
         end
 
+        # #393 — a template unit has no `def` for {Effects::EnvelopeCheck::Positions} to find, so a view
+        # finding would land on `.rigor.yml` — the config file, not the template the reviewer has to open.
+        # `Runner#effect_sources` already records the file every unit key came from; the line stays at the
+        # finding's own (1 for a whole-file unit), because the bound is exceeded by the unit, not by one
+        # line of it, and the explanation chain names the origin site.
+        def unit_source_path(key) = Effects::MethodKey.template_unit?(key) ? @unit_sources[key.to_s]&.first : nil
+
         def message_for(finding)
           EnvelopeMessages.exceeded(finding)
         end

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

@@ -10,6 +10,7 @@ require_relative "../run_stats"
 require_relative "../../effects/signature_sources"
 require_relative "../../rbs_extended/conformance_checker"
 require_relative "../../runtime/jit"
+require_relative "../../cache/engine_source"
 
 module Rigor
   module Analysis
@@ -44,7 +45,7 @@ module Rigor
                        snapshots:, plugin_registry:, dependency_source_index:,
                        synthetic_method_index:, project_patched_methods:,
                        analyze_file:, project_scope_seed: -> { {} }, record_dependencies: false,
-                       restored_run_level_rows: nil)
+                       restored_run_level_rows: nil, template_units: -> { TemplateUnits.empty })
           @configuration = configuration
           @cache_store = cache_store
           @explain = explain
@@ -59,6 +60,11 @@ module Rigor
           # `#collected_effects`, so a pooled run's effect graph is the sequential run's graph.
           @record_effects = configuration.effects_enabled?
           @collected_effects = {}
+          # Issue #1051 — run-scoped plugin disclosures ({Plugin::Base#disclose_once}), keyed
+          # `[plugin id, key]` so the FIRST worker to register a pair wins and every later copy is dropped.
+          # The de-duplication has to happen here, on the parent, because each fork worker owns its own
+          # plugin instances and therefore its own `@run_disclosures` table.
+          @collected_run_disclosures = {}
           @collect_stats = collect_stats
           @buffer = buffer
           @environment_override = environment_override
@@ -71,6 +77,10 @@ module Rigor
           @synthetic_method_index_reader = synthetic_method_index
           @project_patched_methods_reader = project_patched_methods
           @project_scope_seed_reader = project_scope_seed
+          # #392 — read through a proc, like every other runner-owned table here: the units are synthesised
+          # on the parent during the run and handed to the ONE pre-fork {WorkerSession}, so every child
+          # inherits the same compiled bytes.
+          @template_units_reader = template_units
           @analyze_file = analyze_file
           # Issues #796 / #794 — the previous full run's run-level rows, handed down by
           # {Analysis::IncrementalSession} on a NARROWED run only (a recheck's closure, a
@@ -88,6 +98,25 @@ module Rigor
         # these with its own sequential records before the post-pool fixpoint.
         attr_reader :collected_effects
 
+        # Issue #1051 — the run-scoped disclosures a pool run collected, de-duplicated by `[plugin id, key]`
+        # and in first-registration order. Empty on a sequential run: there the runner's own plugin
+        # registry is the one that registered them, and {Runner} reads it directly.
+        def collected_run_disclosures
+          @collected_run_disclosures.values
+        end
+
+        # Issue #1051 — folds one session's / one worker payload's disclosures in, keeping the first
+        # registration of each `[plugin id, key]` pair. Nothing here inspects the message: two workers that
+        # disclose the same key with differently interpolated text still collapse to one row, which is the
+        # point — the key is the identity a plugin author controls, and an author who interpolates
+        # worker-varying text into a message has authored one disclosure, not N.
+        def merge_run_disclosures(records)
+          Array(records).each do |record|
+            identity = [record[:plugin_id], record[:key]].freeze
+            @collected_run_disclosures[identity] ||= record
+          end
+        end
+
         # ADR-15 Phase 4b — pool mode is enabled when `@workers > 0`. Editor mode (`buffer:` non-nil)
         # silently overrides pool mode to sequential: per design § "Ractor pool mode", the pool's warm-up
         # cost dominates one-file wall time, so the pool gains nothing on a per-buffer invocation. The
@@ -474,6 +503,20 @@ module Rigor
           # (shareable) registry into the class-ivar cache before any worker reads.
           Environment::ClassRegistry.default
 
+          # #1055 — the same treatment for the engine-source digest. Every worker's `Environment.for_project`
+          # reaches `Cache::EngineSource.key_config_entries` whenever a source-RBS synthesizer is wired (the
+          # ADR-93 `rigor-rbs-inline` auto-wire, on by default and off throughout the spec suite), and the
+          # memo behind it is a 90 ms tree walk that cannot be eager-loaded at require time. Warming it here
+          # is what makes the worker's access a READ of a frozen String rather than a forbidden class-ivar
+          # write. `Unavailable` is left to the worker: it raises rather than assigning, so it costs the pool
+          # no more than it costs a sequential run, and swallowing it here would hide a tree the engine
+          # cannot identify.
+          begin
+            Cache::EngineSource.process_identity
+          rescue Cache::EngineSource::Unavailable
+            nil
+          end
+
           # ADR-15 Phase 4b.x — pre-warm the RBS cache so workers serve every reflection query from the
           # Marshal blob on disk. Without this, the first cache MISS inside a worker falls through to
           # `RBS::EnvironmentLoader.new`, which reads a chain of non-`Ractor.shareable?` RubyGems / RBS
@@ -507,7 +550,18 @@ module Rigor
           # matching explicit call for the HKT-scan outcome: every worker already demands it from its OWN
           # environment in `#drain_reporters`, and the scan has one outcome whoever demands it, so a
           # worker's report already says what the coordinator's own demand would.
-          warm_env = prewarm_rbs_cache_for_pool(source_files: source_files)
+          # #1064 — the lockfile is resolved HERE, once, and travels to every worker as frozen data the way
+          # `source_files` does: Bundler's parser reads RubyGems module state a non-main Ractor may not touch,
+          # so a worker resolving its own raised `Ractor::IsolationError`, printed a "malformed Gemfile.lock"
+          # warning per worker, and analysed with the project's gem signatures silently missing.
+          locked_gems = Ractor.make_shareable(
+            Environment::LockfileResolver.locked_gems(
+              lockfile_path: @configuration.bundler_lockfile,
+              project_root: Dir.pwd,
+              auto_detect: @configuration.bundler_auto_detect
+            )
+          )
+          warm_env = prewarm_rbs_cache_for_pool(source_files: source_files, locked_gems: locked_gems)
           snapshot_project_signature_state(warm_env)
           snapshot_effect_annotation_carrier(warm_env&.rbs_loader)
           record_definition_build_failures(warm_env&.rbs_loader&.definition_build_failures)
@@ -523,14 +577,15 @@ module Rigor
           shareable_source_files = source_files.map { |path| path.to_s.dup.freeze }.freeze
 
           pool = Array.new(@workers) do
-            Ractor.new(configuration, cache_root, blueprints, explain, shareable_source_files) do |configuration, cache_root, blueprints, explain, shareable_source_files| # rubocop:disable Layout/LineLength
+            Ractor.new(configuration, cache_root, blueprints, explain, shareable_source_files, locked_gems) do |configuration, cache_root, blueprints, explain, shareable_source_files, locked_gems| # rubocop:disable Layout/LineLength
               cache_store = cache_root ? Rigor::Cache::Store.new(root: cache_root) : nil
               session = Rigor::Analysis::WorkerSession.new(
                 configuration: configuration,
                 cache_store: cache_store,
                 plugin_blueprints: blueprints,
                 explain: explain,
-                source_files: shareable_source_files
+                source_files: shareable_source_files,
+                locked_gems: locked_gems
               )
               main = Ractor.main
               main.send([:prepare, session.prepare_diagnostics])
@@ -542,7 +597,10 @@ module Rigor
                 main.send([:file, msg, session.analyze(msg)])
               end
 
-              main.send([:done, session.drain_reporters])
+              # Issue #1051 — sent with `:done`, not with `:prepare`: this backend builds no parent session,
+              # so the worker's own table is the only place a disclosure exists, and it is complete only
+              # once the worker has finished its files.
+              main.send([:done, session.drain_reporters, session.drain_run_disclosures])
             end
           end
 
@@ -576,7 +634,8 @@ module Rigor
             when :file
               results_by_path[message[1]] = message[2]
             when :done
-              merge_worker_reporters(message.last)
+              merge_worker_reporters(message[1])
+              merge_run_disclosures(message[2])
             end
           end
 
@@ -604,6 +663,18 @@ module Rigor
         # definition-build failures the re-analysis demanded (#696) and the HKT-scan outcome, demanded
         # once more by the run itself (#784 — a rescued scan failure otherwise vanished with the worker).
         # The fork backend needs none of this: it re-analyses on the parent {WorkerSession} and drains it.
+        #
+        # Issue #1051, known exception: run-scoped disclosures a plugin registered from `#prepare` are NOT
+        # recovered here — nor, since #1060, a positioned `#emit_once` batch registered there, which rides
+        # the same table. There is no session to drain — this backend builds none on the coordinator — and
+        # `#prepare` deliberately does not run on the coordinator-side registry under pool mode, so a
+        # prepare-time disclosure lives only inside the Ractor that died with it. A disclosure registered
+        # from `#diagnostics_for_file` IS recovered, because the re-analysis below runs the coordinator-side
+        # plugin instances that {DiagnosticAggregator#plugin_run_disclosure_diagnostics} reads directly.
+        # Left as is: recovering the rest means running `#prepare` on the coordinator registry, which would
+        # re-publish every cross-plugin fact for a degrade, and this backend is off by default. Since #1055
+        # the path is also rare rather than universal — it used to be taken on every run, because every
+        # worker died in its constructor on a class-ivar memo.
         def reanalyze_degraded_in_process(degraded, results_by_path, source_files:)
           return if degraded.empty?
 
@@ -641,7 +712,8 @@ module Rigor
             project_patched_methods: project_patched_methods,
             project_scope_seed: project_scope_seed,
             source_files: source_files,
-            record_dependencies: @record_dependencies
+            record_dependencies: @record_dependencies,
+            template_units: template_units
           )
           # Force the full RBS load on the parent so children copy-on-write inherit a warm Environment
           # rather than each rebuilding it after the fork.
@@ -662,6 +734,14 @@ module Rigor
           # same project).
           snapshot_project_signature_state(session.environment)
           snapshot_effect_annotation_carrier(session.environment.rbs_loader)
+          # Issue #1051 — taken BEFORE the fork, for the same reason and with the same effect as the two
+          # snapshots above: `#prepare` ran on the parent when the session was built, so every disclosure a
+          # plugin registers there (the normal case — a disclosure is a fact about the project's inputs,
+          # known before a file is read) is already in this table, in the same order the sequential path
+          # would produce. Each child inherits the identical table and re-offers it in its payload, where
+          # `merge_run_disclosures` drops it as a duplicate; only a disclosure a worker registers while
+          # analysing its own slice adds anything.
+          merge_run_disclosures(session.drain_run_disclosures)
           snapshot_fork_pool_stats(session) if @collect_stats
 
           worker_count = [@workers, files.size].min
@@ -680,6 +760,8 @@ module Rigor
           unless degraded.empty?
             degraded.each { |path| results_by_path[path] = session.analyze(path) }
             merge_worker_reporters(session.drain_reporters)
+            # The degraded slice ran on the parent session, so a disclosure it registered lives there.
+            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
@@ -704,7 +786,8 @@ module Rigor
           Runtime::Jit.rearm_after_fork
           results = slice.to_h { |path| [path, session.analyze(path)] }
           payload = { results: results, reporters: session.drain_reporters,
-                      dependencies: session.drain_dependencies }
+                      dependencies: session.drain_dependencies,
+                      disclosures: session.drain_run_disclosures }
           # ADR-103 WD13 — the effects slot exists only on a collecting run, so a normal `--workers N` run
           # marshals exactly the payload it marshalled before the feature existed.
           payload[:effects] = session.drain_effects if @record_effects
@@ -736,6 +819,7 @@ module Rigor
             if payload
               results_by_path.merge!(payload.fetch(:results))
               merge_worker_reporters(payload.fetch(:reporters))
+              merge_run_disclosures(payload.fetch(:disclosures, []))
               @collected_dependencies.merge!(payload.fetch(:dependencies, {})) if @record_dependencies
               @collected_effects.merge!(payload.fetch(:effects, {})) if @record_effects
             else
@@ -798,13 +882,14 @@ module Rigor
         # index, the synthetic-method / project-patched indexes) is withheld for the same reason: nothing
         # here dispatches.
         # @param source_files — the WHOLE project's file list, never the analyzed subset.
-        def prewarm_rbs_cache_for_pool(source_files:)
+        def prewarm_rbs_cache_for_pool(source_files:, locked_gems: nil)
           warm_env = Environment.for_project(
             libraries: @configuration.libraries,
             signature_paths: @configuration.signature_paths,
             cache_store: @cache_store,
             plugin_registry: plugin_registry,
             source_files: source_files,
+            locked_gems: locked_gems,
             **ProjectEnvironment.dependency_discovery_options(@configuration)
           )
           warm_env.rbs_loader&.prewarm
@@ -820,6 +905,11 @@ module Rigor
         #   i.e. with no synthesized RBS at all, even on a full run.
         def analyze_files_sequentially_fallback(files, reason:, source_files: files)
           environment = build_runner_environment(source_files: source_files)
+          # Same set, same ORDER as `#analyze_files_sequentially`. The signature state used to be hand-copied
+          # here slot by slot, which dropped `synthesized-namespace` and every conformance row. The conformance
+          # scan inside it demands the definition of every `rigor:v1:conforms-to` class, so it has to run
+          # BEFORE the definition-build failures are read below, or a failure only that scan reaches is lost.
+          snapshot_project_signature_state(environment)
           snapshot_effect_annotation_carrier(environment.rbs_loader)
           diagnostics = files.flat_map { |path| @analyze_file.call(path, environment) }
           loader = environment.rbs_loader
@@ -834,10 +924,6 @@ module Rigor
           record_hkt_scan_failure(hkt_scan_outcome(environment))
           @snapshots.class_decl_paths = loader&.class_decl_paths || {}.freeze
           @snapshots.signature_paths = loader&.signature_paths || [].freeze
-          @snapshots.signature_standdowns = plugin_signature_paths? ? signature_standdowns_for(loader) : []
-          @snapshots.quarantined_signatures =
-            project_signature_paths? ? (loader&.quarantined_signatures || []) : []
-          @snapshots.env_build_failure = project_signature_paths? ? loader&.env_build_failure : nil
           diagnostics.unshift(
             Diagnostic.new(
               path: ".rigor.yml", line: 1, column: 1,
@@ -864,10 +950,12 @@ module Rigor
           # `:failed`, so under `--workers N` a WD12 "parsed but not honoured" row came back as
           # `source-rbs-synthesis-failed` — a different id, and a message telling the user the file
           # contributed nothing when all but one of its annotations bound. Every worker reads the same
-          # sources and so hands over the same entries; the reporter's own dedup collapses them.
+          # sources and so hands over the same entries; the reporter's own dedup collapses them. `line:` rides
+          # along for the same reason (#1075): a consistency error is positioned at its `.rbs` member.
           Array(drained[:source_rbs_synthesis]).each do |entry|
             @source_rbs_synthesis_reporter.record(
-              plugin_id: entry.plugin_id, path: entry.path, message: entry.message, kind: entry.kind
+              plugin_id: entry.plugin_id, path: entry.path, message: entry.message, kind: entry.kind,
+              line: entry.line
             )
           end
           # Issue #696. Fetched with a default so an older drain stays compatible, exactly as the line above.
@@ -1022,6 +1110,10 @@ module Rigor
           @project_patched_methods_reader.call
         end
 
+        def template_units
+          @template_units_reader.call
+        end
+
         def project_scope_seed
           @project_scope_seed_reader.call
         end

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

@@ -8,6 +8,8 @@ require_relative "../../inference/synthetic_method_scanner"
 require_relative "../../inference/project_patched_scanner"
 require_relative "../dependency_source_inference"
 require_relative "../project_scan"
+require_relative "../template_units"
+require_relative "../template_unit_collector"
 
 module Rigor
   module Analysis
@@ -53,10 +55,10 @@ module Rigor
         Discovery = Data.define(
           :discovered_classes, :discovered_def_nodes, :discovered_def_nestings,
           :discovered_singleton_def_nodes, :discovered_def_sources, :discovered_singleton_def_sources,
-          :discovered_superclasses, :discovered_header_nestings, :discovered_includes,
+          :discovered_superclasses, :discovered_header_nestings, :discovered_includes, :discovered_prepends,
           :discovered_extends, :discovered_class_sources, :constant_values, :constant_sources, :constant_writes,
-          :discovered_method_visibilities, :discovered_methods, :data_member_layouts,
-          :struct_member_layouts
+          :discovered_method_visibilities, :discovered_methods, :discovered_parameter_envelopes, :data_member_layouts,
+          :struct_member_layouts, :discovered_deferred_ranges, :discovered_refinements, :discovered_global_write_census
         )
 
         # Internal: drives every EAGER project-wide pre-pass — the ones whose products feed the RBS
@@ -164,24 +166,38 @@ module Rigor
             # the cref Ruby resolves it in rather than by peeling the subclass's own qualified name.
             discovered_header_nestings: def_index.fetch(:header_nestings),
             discovered_includes: def_index.fetch(:includes),
+            # Issue #1123 — the instance-side prepend table, kept beside the include one so
+            # `Scope#user_def_through_ancestors` can search a prepended module ahead of the class's own
+            # `def`s from a sibling file the way it does within the declaring one.
+            discovered_prepends: def_index.fetch(:prepends),
             # Issue #898 — the singleton-side mixin table, kept beside the instance-side one so a class
             # object's `extend`s reach `Narrowing` from a sibling file the way its `include`s already do.
             discovered_extends: def_index.fetch(:extends),
             discovered_class_sources: def_index.fetch(:class_sources),
             # Issue #644 — the cross-file value-constant publication table and its write attribution.
-            constant_values: def_index.fetch(:constant_values),
-            constant_sources: def_index.fetch(:constant_sources),
+            constant_values: def_index.fetch(:constant_values), constant_sources: def_index.fetch(:constant_sources),
             constant_writes: def_index.fetch(:constant_writes),
             discovered_method_visibilities: def_index.fetch(:method_visibilities),
             discovered_methods: def_index.fetch(:methods),
+            discovered_parameter_envelopes: def_index.fetch(:parameter_envelopes),
             data_member_layouts: def_index.fetch(:data_member_layouts),
-            struct_member_layouts: def_index.fetch(:struct_member_layouts)
+            struct_member_layouts: def_index.fetch(:struct_member_layouts),
+            # Issue #1097 — per-file def / block / lambda body ranges, the execution-timing table the
+            # `*_def_shadows_call?` predicates order `sig`-shadowing defs against.
+            discovered_deferred_ranges: def_index.fetch(:deferred_ranges),
+            discovered_refinements: def_index.fetch(:refinements), # Issue #1120
+            discovered_global_write_census: def_index.fetch(:global_write_census) # Issue #1367
           )
         end
 
         # Builds the LSP-facing {ProjectScan} snapshot from a fresh pre-pass run. The runner adopts `result`
         # onto its ivars first so the same registry object that ran `#prepare` (and so the populated
         # `services.fact_store`) is the one the snapshot carries.
+        #
+        # Since #1038 the snapshot also carries the template-unit index, so a long-lived owner's per-buffer
+        # publishes carry it instead of re-running every plugin transform per keystroke. It is built through
+        # {TemplateUnitCollector.collect_for_scan}, which owns both of that slot's rules — no buffer binding,
+        # and an ADR-87 run scope around the packs a later run revalidates against.
         def build_project_scan(result)
           ProjectScan.new(
             plugin_registry: result.plugin_registry,
@@ -189,7 +205,10 @@ module Rigor
             synthetic_method_index: result.synthetic_method_index,
             project_patched_methods: result.project_patched_methods,
             plugin_prepare_diagnostics: result.cached_plugin_prepare_diagnostics.dup.freeze,
-            pre_eval_diagnostics: result.pre_eval_diagnostics_from_scanner.dup.freeze
+            pre_eval_diagnostics: result.pre_eval_diagnostics_from_scanner.dup.freeze,
+            template_units: TemplateUnitCollector.collect_for_scan(
+              registry: result.plugin_registry, strict: @configuration.cache_validation_strict?
+            )
           )
         end