rigortype 0.3.3 → 0.3.5

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

@@ -6,6 +6,7 @@ require_relative "../../environment"
 require_relative "../diagnostic"
 require_relative "../worker_session"
 require_relative "../run_stats"
+require_relative "../../effects/signature_sources"
 require_relative "../../rbs_extended/conformance_checker"
 require_relative "../../runtime/jit"
 
@@ -61,6 +62,11 @@ module Rigor
           # slice's cross-file reads, marshalled back into `#collected_dependencies` for the runner's graph.
           @record_dependencies = record_dependencies
           @collected_dependencies = {}
+          # ADR-103 WD13 — effect collection, derived from the configuration exactly as `Runner` and
+          # `WorkerSession` derive it. A worker's per-file collections marshal back into
+          # `#collected_effects`, so a pooled run's effect graph is the sequential run's graph.
+          @record_effects = configuration.effects_enabled?
+          @collected_effects = {}
           @collect_stats = collect_stats
           @buffer = buffer
           @environment_override = environment_override
@@ -81,6 +87,11 @@ module Rigor
         # so the incremental session's dependency graph is refreshed whether analysis ran sequential or pooled.
         attr_reader :collected_dependencies
 
+        # 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.
+        attr_reader :collected_effects
+
         # 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
@@ -113,6 +124,7 @@ module Rigor
 
         def analyze_files_sequentially(files, environment)
           snapshot_project_signature_state(environment)
+          snapshot_effect_annotation_carrier(environment&.rbs_loader)
           result = files.flat_map { |path| @analyze_file.call(path, environment) }
           if @collect_stats
             loader = environment.rbs_loader
@@ -147,6 +159,27 @@ module Rigor
           @snapshots.conformance_results = RbsExtended::ConformanceChecker.scan(loader)
         end
 
+        # #441 — the inline stratum of `effect.annotations-unchecked`, carried out of the analysis path as
+        # small plain data, for the same reason the block above is: the environment stays a LOCAL so it goes
+        # GC-eligible when the path returns, and the residual pass runs after it.
+        #
+        # {Runner#effect_annotation_residual_diagnostics} used to read the loader off `@run_environment`,
+        # which only the ADR-45 result-cacheable path ever assigns — so a `--no-cache`, `--workers N` or
+        # `--incremental` run reported a `.rbs` annotation and stayed silent about the identical one written
+        # as an rbs-inline comment, while a default run reported both. The environment was there either way;
+        # nothing was carrying it. {Effects::SignatureSources.annotated_carrier} reduces it to at most ONE
+        # synthesized buffer, which is all a one-`:info`-per-run pass can spend.
+        #
+        # Skipped when collection is on — then {Runner::EffectEnvelopePass} reads the loader directly and
+        # this pass is gated off — so a collecting run pays nothing, and a project with no synthesizing
+        # plugin answers with an empty array and no regex at all.
+        def snapshot_effect_annotation_carrier(loader)
+          virtual = @record_effects ? nil : loader&.virtual_rbs
+          @snapshots.effect_annotation_carrier = Effects::SignatureSources.annotated_carrier(virtual)
+        rescue StandardError
+          @snapshots.effect_annotation_carrier = [].freeze
+        end
+
         # Sequential-mode environment resolver. Returns the supplied `environment:` override (with the
         # runner's fresh per-run reporter pair attached so dispatcher events route to THIS runner's
         # diagnostics) when present; otherwise builds a fresh Environment per-call via
@@ -179,8 +212,12 @@ module Rigor
         # per-worker dependency records back, and the Ractor path additionally lacks the cross-file
         # `project_scope_seed` its worker would need to record complete edges. Without `fork` (Windows) a
         # recording run degrades to sequential, which records correctly through `@analyze_file`.
+        #
+        # An effects run (ADR-103 WD13) is pinned for exactly the same reason — the Ractor messages carry
+        # no side-table channel — and degrades the same way. The degrade is sound rather than merely safe:
+        # the sequential fallback still collects, so the effect graph is complete either way.
         def dispatch_pool(files)
-          if @record_dependencies
+          if @record_dependencies || @record_effects
             return analyze_files_in_fork_pool(files) if Process.respond_to?(:fork)
 
             return analyze_files_sequentially_fallback(
@@ -250,6 +287,14 @@ module Rigor
         # replayed into the runner-side accumulators via their `record_*` APIs, which dedupe on the same
         # keys as a single-session run would. Net result: reporter state is identical to the sequential
         # path.
+        #
+        # **This backend cannot analyse a file under rbs 4.x, and the blocker is upstream** (#414).
+        # `RBS::Namespace.[]` interns every namespace through a process-wide flyweight cache held in
+        # module ivars (`@intern_trie_absolute` / `@intern_trie_relative`, mutable by design), and reading
+        # an unshareable module ivar from a non-main Ractor is `Ractor::IsolationError` — so every file a
+        # worker touches comes back as an internal analyzer error. What the code below fixes is the
+        # failure MODE, not the backend: the run used to hang forever instead of saying anything. Reviving
+        # the backend needs an upstream change, which is why `pool_backend` keeps `fork` as the default.
         def analyze_files_in_pool(files) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
           # Pre-warm class-level lazy memos on the MAIN Ractor. `Environment::ClassRegistry.default` is the
           # default kwarg threaded through `Environment.new` inside each worker session; lazy-initialising
@@ -303,15 +348,30 @@ module Rigor
             end
           end
 
+          # #414 — every worker is monitored BEFORE any file is dispatched, so a worker that dies at
+          # construction is still observed. `Ractor#monitor` posts `:exited` / `:aborted` to this
+          # Ractor's default port, which is the same mailbox the workers push their results to.
+          pool.each { |worker| worker.monitor(Ractor.current.default_port) }
+
           files.each_with_index { |path, index| pool[index % pool.size].send(path) }
           pool.each { |worker| worker.send(nil) }
 
           prepare_diagnostics = nil
           results_by_path = {}
-          done_count = 0
-
-          while done_count < pool.size
+          terminated = 0
+
+          # Bounded by TERMINATION, not by `:done`. A worker that dies never says `:done`, and the loop
+          # that counted `:done` blocked on `Ractor.receive` for as long as the process lived — the whole
+          # backend hung that way once `Environment.for_project` started raising `Ractor::IsolationError`
+          # inside `WorkerSession#initialize` (#414). Monitor notices are bare Symbols; worker messages
+          # are Arrays, so the two never collide.
+          while terminated < pool.size
             message = Ractor.receive
+            if message.is_a?(Symbol)
+              terminated += 1
+              next
+            end
+
             case message.first
             when :prepare
               prepare_diagnostics ||= message.last
@@ -319,13 +379,27 @@ module Rigor
               results_by_path[message[1]] = message[2]
             when :done
               merge_worker_reporters(message.last)
-              done_count += 1
             end
           end
 
-          pool.each(&:join)
+          # `join` re-raises an abnormal worker's exception as `Ractor::RemoteError`; the degrade below is
+          # this path's answer to that, so the raise carries no information the coordinator acts on.
+          pool.each do |worker|
+            worker.join
+          rescue Ractor::Error
+            nil
+          end
+
+          # The files no worker reported — every file of a worker that died, and any file in flight when
+          # it did. Re-analysed in process, exactly as the fork backend re-analyses a dead child's slice.
+          degraded = files.reject { |path| results_by_path.key?(path) }
+          unless degraded.empty?
+            environment = build_runner_environment(source_files: files)
+            degraded.each { |path| results_by_path[path] = @analyze_file.call(path, environment) }
+          end
 
-          Array(prepare_diagnostics) + files.flat_map { |path| results_by_path.fetch(path, []) }
+          diagnostics = Array(prepare_diagnostics) + files.flat_map { |path| results_by_path.fetch(path, []) }
+          degraded.empty? ? diagnostics : diagnostics.unshift(pool_degraded_diagnostic(degraded.size, "ractor"))
         end
 
         # ADR-15 Amendment (2026-05-20) — fork-based worker pool, the active backend for `workers > 0`.
@@ -357,6 +431,7 @@ module Rigor
           # 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.
           session.environment.rbs_loader&.prewarm
+          snapshot_effect_annotation_carrier(session.environment.rbs_loader)
           snapshot_fork_pool_stats(session) if @collect_stats
 
           worker_count = [@workers, files.size].min
@@ -378,11 +453,12 @@ module Rigor
             # 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
+            @collected_effects.merge!(session.drain_effects) if @record_effects
           end
 
           diagnostics = Array(session.prepare_diagnostics) +
                         files.flat_map { |path| results_by_path.fetch(path, []) }
-          degraded.empty? ? diagnostics : diagnostics.unshift(fork_degraded_diagnostic(degraded.size))
+          degraded.empty? ? diagnostics : diagnostics.unshift(pool_degraded_diagnostic(degraded.size, "fork"))
         end
 
         # Child-process body for {#analyze_files_in_fork_pool}. Analyses the slice with the
@@ -399,6 +475,9 @@ module Rigor
           results = slice.to_h { |path| [path, session.analyze(path)] }
           payload = { results: results, reporters: session.drain_reporters,
                       dependencies: session.drain_dependencies }
+          # 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
           File.binwrite(out_path, Marshal.dump(payload))
           exit!(0)
         rescue StandardError
@@ -430,6 +509,7 @@ module Rigor
               results_by_path.merge!(payload.fetch(:results))
               merge_worker_reporters(payload.fetch(:reporters))
               @collected_dependencies.merge!(payload.fetch(:dependencies, {})) if @record_dependencies
+              @collected_effects.merge!(payload.fetch(:effects, {})) if @record_effects
             else
               degraded.concat(child[:slice])
             end
@@ -448,10 +528,12 @@ module Rigor
           nil
         end
 
-        def fork_degraded_diagnostic(count)
+        # Both pool backends degrade the same way — the files a dead worker owed are re-analysed in
+        # process — so they say so the same way, naming which backend it was (#414).
+        def pool_degraded_diagnostic(count, backend)
           Diagnostic.new(
             path: ".rigor.yml", line: 1, column: 1,
-            message: "fork pool degraded: #{count} file(s) re-analysed in-process " \
+            message: "#{backend} pool degraded: #{count} file(s) re-analysed in-process " \
                      "after a worker exited abnormally",
             severity: :warning, rule: "pool-degraded", source_family: :builtin
           )
@@ -482,6 +564,7 @@ module Rigor
         # per-file analysis runs on the coordinator, identical to the default sequential path.
         def analyze_files_sequentially_fallback(files, reason:)
           environment = build_runner_environment
+          snapshot_effect_annotation_carrier(environment.rbs_loader)
           diagnostics = files.flat_map { |path| @analyze_file.call(path, environment) }
           loader = environment.rbs_loader
           @snapshots.class_decl_paths = loader&.class_decl_paths || {}.freeze

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

@@ -3,10 +3,11 @@
 module Rigor
   module Analysis
     class Runner
-      # Mutable per-run holder for the four end-of-pass snapshots that the analysis paths compute as a side
+      # Mutable per-run holder for the end-of-pass snapshots that the analysis paths compute as a side
       # effect and the rest of the run reads back: the RBS `class_decl_paths` / `signature_paths` tables
-      # (consumed by {RunStats}), the synthesized-namespace name list, and the `conforms-to` scan results
-      # (consumed by the diagnostic aggregator).
+      # (consumed by {RunStats}), the synthesized-namespace name list, the `conforms-to` scan results
+      # (consumed by the diagnostic aggregator), and the effect-annotation carrier (#441 — consumed by
+      # {EffectAnnotationResidualPass} on the runs that never store the environment).
       #
       # The snapshots are written by whichever analysis path ran ({PoolCoordinator} sequential / fork-pool /
       # fallback) and read by the {Runner} and {DiagnosticAggregator}. A shared mutable holder keeps the
@@ -16,7 +17,7 @@ module Rigor
       class RunSnapshots
         attr_accessor :class_decl_paths, :signature_paths,
                       :synthesized_namespaces, :quarantined_signatures, :conformance_results,
-                      :env_build_failure
+                      :env_build_failure, :effect_annotation_carrier
 
         # Constructor defaults match the {Runner} constructor: the pre-seed values `build_run_stats` /
         # `pre_file_diagnostics` read before the first analysis path runs are frozen empties. The
@@ -29,6 +30,7 @@ module Rigor
           @quarantined_signatures = [].freeze
           @conformance_results = [].freeze
           @env_build_failure = nil
+          @effect_annotation_carrier = [].freeze
         end
 
         # Per-`#run` reset. Mirrors the original `#run` body, which reset these to NON-frozen empties (distinct
@@ -40,6 +42,7 @@ module Rigor
           @quarantined_signatures = []
           @conformance_results = []
           @env_build_failure = nil
+          @effect_annotation_carrier = [].freeze
         end
       end
     end