rigortype 0.3.9 → 0.4.1

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
@@ -258,10 +287,10 @@ module Rigor
           buffers = failure.is_a?(Array) ? failure[3] : nil
           return false if buffers.nil?
 
-          closure_paths = closure.to_set { |path| File.expand_path(path.to_s) }
+          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.expand_path(path))
+            !path.nil? && closure_paths.include?(File.absolute_path(path))
           end
         end
 
@@ -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
@@ -21,7 +23,7 @@ module Rigor
       # ivar surface, preserving the exact assignment order and timing the inline body had. The `pool_mode`
       # predicate is injected (it keys on `@workers` / `@buffer`, owned by the Runner) so this collaborator
       # never calls back into it.
-      class ProjectPrePasses
+      class ProjectPrePasses # rubocop:disable Metrics/ClassLength -- the Discovery slots are one declaration per table
         # Frozen bundle of the EAGER (env-input) project-wide state the pre-passes produce — the slots whose
         # products feed the RBS environment build. Mirrors the env-input ivars `apply_pre_passes_result`
         # sets on the {Runner}. The cross-file discovery tables live in the separate {Discovery} bundle
@@ -51,12 +53,13 @@ module Rigor
         # consumes them and so never pays the double parse (see {#discover} + `Runner#ensure_project_discovery`).
         # The slot names mirror the discovery half of {Result} exactly.
         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_extends, :discovered_class_sources, :constant_values, :constant_sources, :constant_writes,
-          :discovered_method_visibilities, :discovered_methods, :data_member_layouts,
-          :struct_member_layouts
+          :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_prepends, :discovered_extends,
+          :unpositioned_mixins, :discovered_class_sources, :constant_values, :constant_sources, :constant_writes,
+          :discovered_method_visibilities, :discovered_methods, :discovered_parameter_envelopes, :data_member_layouts,
+          :struct_member_layouts, :discovered_deferred_ranges, :discovered_refinements, :siblings,
+          :discovered_global_write_census
         )
 
         # Internal: drives every EAGER project-wide pre-pass — the ones whose products feed the RBS
@@ -164,24 +167,39 @@ 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_extends: def_index.fetch(:extends), unpositioned_mixins: def_index.fetch(:unpositioned_mixins),
             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
+            # Issue #1367 — the census; ADR-119 WD1 — `{sibling name => table}` for `DiscoveryIndex::SIBLINGS`.
+            discovered_global_write_census: def_index.fetch(:global_write_census), siblings: def_index.fetch(:siblings)
           )
         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 +207,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
 
@@ -214,13 +235,19 @@ module Rigor
         # {Rigor::Plugin::Registry} WITHOUT the synthetic-method / dependency-source / pre-eval scanners. The
         # incremental fact-surface fingerprint probe ({Analysis::PluginFactFingerprint}) uses this to read the
         # ADR-9 fact store + drive the ADR-60 producers without paying for the full pre-pass or building the RBS
-        # environment. `prepare` runs unconditionally here — the probe is always sequential (its `pool_mode?`
+        # environment. `prepare` runs whatever the pool mode — the probe is always sequential (its `pool_mode?`
         # reader returns false), so the pool-mode skip in {#run} does not apply. Prepare diagnostics are
         # discarded: a plugin that raises in `#prepare` publishes no facts, so its surface is simply absent from
         # the fingerprint, exactly as it would be absent from analysis.
-        def prepared_registry
+        #
+        # Issue #1536 — `prepare: false` loads the plugins without running `#prepare`, for a caller that reads
+        # only what a manifest declares: the incremental session reads each plugin's `source_rbs_synthesizer`
+        # before its recheck runner exists. A synthesizer's output is a function of the file, the plugin's
+        # config and the engine — the key its `Cache::Store` entry already rests on — so `#prepare` has
+        # nothing to add to it, and skipping it keeps that read off every plugin's prepare-time scans.
+        def prepared_registry(prepare: true)
           registry = load_plugins
-          plugin_prepare_diagnostics(registry) unless registry.empty?
+          plugin_prepare_diagnostics(registry) if prepare && !registry.empty?
           registry
         end
 
@@ -269,12 +296,12 @@ module Rigor
         def build_trust_policy
           trusted_gems = @configuration.plugins.map { |entry| trusted_gem_name(entry) }.uniq
           roots = [Dir.pwd]
-          Array(@configuration.signature_paths).each { |sp| roots << File.expand_path(sp) }
+          Array(@configuration.signature_paths).each { |sp| roots << File.absolute_path(sp) }
           trusted_gems.each do |gem_name|
             path = trusted_gem_root(gem_name)
             roots << path if path
           end
-          @configuration.plugins_io_allowed_paths.each { |p| roots << File.expand_path(p) }
+          @configuration.plugins_io_allowed_paths.each { |p| roots << File.absolute_path(p) }
 
           Plugin::TrustPolicy.new(
             trusted_gems: trusted_gems,