rigortype 0.1.17 → 0.1.18

data/lib/rigor/analysis/worker_session.rb

@@ -39,12 +39,19 @@ module Rigor
     # - `plugin_blueprints` — Phase 3a
     #   (`Array<Plugin::Blueprint>` is `Ractor.shareable?`).
     # - `explain` — Boolean.
-    # - `synthetic_method_index` / `project_patched_methods` —
-    #   optional (default `nil`). NOT `Ractor.shareable?`, so the
-    #   Ractor pool path leaves them unset; the fork backend
+    # - `synthetic_method_index` / `project_patched_methods` /
+    #   `project_scope_seed` — optional (default `nil` / `{}`). NOT
+    #   `Ractor.shareable?` (the seed tables carry Prism def nodes),
+    #   so the Ractor pool path leaves them unset; the fork backend
     #   (ADR-15 Amendment), which builds the session pre-fork on the
     #   parent, threads the runner's project-scan results through so
     #   per-file inference matches the sequential path exactly.
+    #   `project_scope_seed` is `Runner#project_scope_seed_tables` —
+    #   the cross-file discovery tables `seed_project_scope` applies
+    #   to every per-file scope on the sequential path; without it a
+    #   worker cannot resolve calls to methods defined in OTHER
+    #   project files and emits `call.undefined-method` false
+    #   positives the sequential path does not.
     #
     # Internally the session OWNS (and never shares):
     #
@@ -97,13 +104,14 @@ module Rigor
       def initialize(configuration:, cache_store: nil, # rubocop:disable Metrics/MethodLength,Metrics/ParameterLists
                      plugin_blueprints: [], explain: false, buffer: nil,
                      synthetic_method_index: nil, project_patched_methods: nil,
-                     source_files: [])
+                     project_scope_seed: {}, source_files: [])
         @configuration = configuration
         @cache_store = cache_store
         @explain = explain
         @buffer = buffer
         @synthetic_method_index = synthetic_method_index
         @project_patched_methods = project_patched_methods
+        @project_scope_seed = project_scope_seed || {}
         # ADR-32 WD4 — full project file list (frozen
         # Array<String>) for env-build-time invocation of any
         # loaded plugin's `source_rbs_synthesizer` callable.
@@ -165,7 +173,7 @@ module Rigor
           return parse_diagnostics(path, parse_result)
         end
 
-        scope = Scope.empty(environment: @environment, source_path: path)
+        scope = seed_project_scope(Scope.empty(environment: @environment, source_path: path))
         index = Inference::ScopeIndexer.index(parse_result.value, default_scope: scope)
         diagnostics = CheckRules.diagnose(
           path: path,
@@ -200,6 +208,17 @@ module Rigor
 
       private
 
+      # Mirrors {Runner#seed_project_scope}: applies the cross-file
+      # pre-pass discovery tables the constructor received (fork
+      # backend only — see the class comment) to a fresh per-file
+      # scope, so worker-side inference resolves project-internal
+      # cross-file calls exactly like the sequential path.
+      def seed_project_scope(scope)
+        return scope if @project_scope_seed.empty?
+
+        scope.with_discovery(scope.discovery.with(**@project_scope_seed))
+      end
+
       # See {Runner#parse_source}. Same contract: if `@buffer`
       # binds `path` to a physical file, read the physical bytes
       # but stamp the parse buffer's `filepath:` as the LOGICAL
@@ -278,14 +297,34 @@ module Rigor
       def plugin_emitted_diagnostics(path, root, scope)
         return [] if @plugin_registry.empty?
 
+        # ADR-52 WD4 — single engine-owned node-rule walk per file; the
+        # results are bucketed per plugin (registry order) so emission
+        # stays plugin-major and byte-identical with the per-plugin walk.
+        node_results = node_rule_results_by_plugin(path, root, scope)
+
         @plugin_registry.plugins.flat_map do |plugin|
-          collect_plugin_diagnostics(plugin, path, root, scope)
+          collect_plugin_diagnostics(plugin, path, root, scope, node_results[plugin])
         end
       end
 
-      def collect_plugin_diagnostics(plugin, path, root, scope)
+      def node_rule_results_by_plugin(path, root, scope)
+        walk = @plugin_registry.node_rule_walk
+        return {}.compare_by_identity if walk.empty?
+
+        results = walk.diagnostics_for_file(path: path, scope: scope, root: root)
+        results.each_with_object({}.compare_by_identity) do |result, by_plugin|
+          by_plugin[result.plugin] = result
+        end
+      end
+
+      def collect_plugin_diagnostics(plugin, path, root, scope, node_result)
         raw = Array(plugin.diagnostics_for_file(path: path, scope: scope, root: root))
-        raw += plugin.node_rule_diagnostics(path: path, scope: scope, root: root)
+        # A node-rule context/rule raise isolates the whole plugin's
+        # node-rule contribution, matching the old combined per-plugin
+        # rescue (which discarded `diagnostics_for_file` output too).
+        raise node_result.error if node_result&.error
+
+        raw += node_result.diagnostics if node_result
         raw.map { |diagnostic| stamp_plugin_diagnostic(diagnostic, plugin.manifest.id) }
       rescue StandardError => e
         [plugin_runtime_error_diagnostic(path, plugin, e)]

data/lib/rigor/cache/incremental_snapshot.rb

@@ -2,6 +2,7 @@
 
 require "fileutils"
 require "digest"
+require "zlib"
 
 module Rigor
   module Cache
@@ -28,8 +29,12 @@ module Rigor
     # is cold). A cache must never break a run (the ADR-45 invariant).
     class IncrementalSnapshot
       # Bump when the on-disk shape changes so stale snapshots are ignored
-      # rather than mis-deserialized.
-      SCHEMA = 4
+      # rather than mis-deserialized. 5: the blob is zlib-deflated
+      # (ADR-54 WD2 parity with `Store` entries — the snapshot is the
+      # one cache artefact that does not go through `Store`); a raw
+      # pre-5 blob fails the inflate and loads as nil, the usual
+      # fault-tolerant cold-run path.
+      SCHEMA = 5
 
       # The persisted per-file state.
       # `cache` maps an analyzed file to its diagnostics.
@@ -103,7 +108,7 @@ module Rigor
       # The stored {Payload}, or nil when absent / unreadable / schema or
       # fingerprint mismatch / corrupt. Never raises.
       def load(fingerprint:)
-        data = Marshal.load(File.binread(@path)) # rubocop:disable Security/MarshalLoad
+        data = Marshal.load(Zlib::Inflate.inflate(File.binread(@path))) # rubocop:disable Security/MarshalLoad
         return nil unless data.is_a?(Hash) && data[:schema] == SCHEMA && data[:fingerprint] == fingerprint
 
         Payload.new(
@@ -125,7 +130,7 @@ module Rigor
       # raises).
       def save(fingerprint:, payload:)
         FileUtils.mkdir_p(File.dirname(@path))
-        blob = Marshal.dump(
+        raw = Marshal.dump(
           schema: SCHEMA, fingerprint: fingerprint,
           cache: payload.cache, sources: payload.sources,
           digests: payload.digests, analyzed: payload.analyzed,
@@ -135,6 +140,7 @@ module Rigor
           missing: payload.missing,
           class_decls: payload.class_decls
         )
+        blob = Zlib::Deflate.deflate(raw)
         tmp = "#{@path}.#{Process.pid}.tmp"
         File.binwrite(tmp, blob)
         File.rename(tmp, @path)

data/lib/rigor/cache/rbs_cache_producer.rb

@@ -20,7 +20,11 @@ module Rigor
     # structural contract.
     class RbsCacheProducer
       def self.fetch(loader:, store:)
-        descriptor = RbsDescriptor.build(loader)
+        # ADR-54 WD4 — the descriptor is identical for every producer
+        # consulting the same loader (same sig files, same libraries),
+        # so the loader memoises one build per process instead of
+        # re-digesting every .rbs file once per producer.
+        descriptor = loader.rbs_cache_descriptor
         store.fetch_or_compute(producer_id: self::PRODUCER_ID, params: {}, descriptor: descriptor) do
           compute(loader)
         end

data/lib/rigor/cache/store.rb

@@ -5,6 +5,7 @@ require "fileutils"
 require "json"
 require "monitor"
 require "securerandom"
+require "zlib"
 
 require_relative "descriptor"
 
@@ -17,17 +18,27 @@ module Rigor
     # and nothing else.
     #
     # Read failures (missing file, bad magic, format-version mismatch,
-    # corrupt SHA-256 trailer, unmarshal-able payload) are silently
-    # treated as cache misses; the producer block reruns and the
-    # next write replaces the bad entry. The trailing SHA-256 catches
-    # accidental corruption (partial writes, FS errors); it is **not**
-    # a security boundary, per ADR-2's trusted-gem trust model.
+    # corrupt SHA-256 trailer, un-inflatable or unmarshal-able payload)
+    # are silently treated as cache misses; the producer block reruns
+    # and the next write replaces the bad entry. The trailing SHA-256
+    # catches accidental corruption (partial writes, FS errors); it is
+    # **not** a security boundary, per ADR-2's trusted-gem trust model.
     class Store # rubocop:disable Metrics/ClassLength
+      # On-disk byte-layout version. Bumped on incompatible format
+      # changes (independent of {Descriptor::SCHEMA_VERSION}, which
+      # covers the descriptor schema rather than the byte layout).
+      # v2 (ADR-54 WD2): the value payload is zlib-deflated on write
+      # and inflated on read — Marshal blobs compress to 13–16 % at
+      # an inflate cost an order of magnitude below their
+      # `Marshal.load`. v1 entries fail the header check and read as
+      # silent misses; the `schema_version.txt` marker additionally
+      # carries this version, so the first writable run after a bump
+      # clears the root and reclaims the unreadable bytes.
+      FORMAT_VERSION = 2
+
       # Header literal: 5-byte ASCII magic, 1-byte separator, 1-byte
-      # format version. Bumped on incompatible on-disk format changes
-      # (independent of {Descriptor::SCHEMA_VERSION}, which covers
-      # the descriptor schema rather than the byte layout).
-      HEADER = "RIGOR\x00\x01".b.freeze
+      # format version.
+      HEADER = "RIGOR\x00#{FORMAT_VERSION.chr}".b.freeze
 
       VALID_PRODUCER_ID = /\A[a-z][a-z0-9._-]*\z/
 
@@ -48,6 +59,7 @@ module Rigor
         @root = root.to_s.dup.freeze
         @read_only = read_only
         @max_bytes = max_bytes&.then { |n| Integer(n) }
+        @schema_version_ensured = false
         @hits = 0
         @misses = 0
         @writes = 0
@@ -107,6 +119,18 @@ module Rigor
       #   When the root does not exist or has no schema-version
       #   marker, `schema_version` is nil and the producer list is
       #   empty.
+      # The `schema_version.txt` marker content. Covers BOTH
+      # invalidation axes: the descriptor schema and the on-disk byte
+      # layout ({FORMAT_VERSION}, ADR-54). A format bump leaves the
+      # old entries permanently unreadable (header mismatch → miss)
+      # but, alone, would never reclaim their bytes — they can sit
+      # below the eviction cap forever. Folding the format version
+      # into the marker routes the bump through the established
+      # clear-the-root path instead.
+      def self.schema_marker_value
+        "#{Descriptor::SCHEMA_VERSION}.#{FORMAT_VERSION}"
+      end
+
       def self.disk_inventory(root:)
         root_s = root.to_s
         marker = File.join(root_s, "schema_version.txt")
@@ -348,11 +372,15 @@ module Rigor
       LOAD_FAILED = Object.new.freeze
       private_constant :LOAD_FAILED
 
+      # Inflates the stored value payload (ADR-54 WD2), then hands the
+      # raw bytes to the deserialiser. Any failure — corrupt deflate
+      # stream included — reads as a miss.
       def safe_load(bytes, deserialize)
+        raw = Zlib::Inflate.inflate(bytes)
         if deserialize
-          deserialize.call(bytes)
+          deserialize.call(raw)
         else
-          Marshal.load(bytes) # rubocop:disable Security/MarshalLoad
+          Marshal.load(raw) # rubocop:disable Security/MarshalLoad
         end
       rescue StandardError
         LOAD_FAILED
@@ -362,7 +390,7 @@ module Rigor
         FileUtils.mkdir_p(File.dirname(path))
 
         descriptor_bytes = descriptor.to_canonical_bytes
-        value_bytes = serialize_value(value, serialize)
+        value_bytes = Zlib::Deflate.deflate(serialize_value(value, serialize))
 
         body = +"".b
         body << HEADER
@@ -408,10 +436,15 @@ module Rigor
         # never collides with a read under the old). The next
         # writable run will repair the cache.
         return if @read_only
+        # The marker is process-stable; one check per Store is
+        # enough (a benign double-check under a thread race just
+        # repeats idempotent work).
+        return if @schema_version_ensured
 
+        @schema_version_ensured = true
         FileUtils.mkdir_p(@root)
         marker = File.join(@root, "schema_version.txt")
-        current = Descriptor::SCHEMA_VERSION.to_s
+        current = self.class.schema_marker_value
 
         if File.file?(marker)
           on_disk = File.read(marker).strip