rigortype 0.4.0 → 0.4.1

data/lib/rigor/analysis/plugin_fact_fingerprint.rb

@@ -2,6 +2,7 @@
 
 require "digest"
 require_relative "runner"
+require_relative "../cache/value_digest"
 
 module Rigor
   module Analysis
@@ -98,9 +99,9 @@ module Rigor
       def digest_registry(registry)
         return Result.new(digest: nil, opaque_plugin_ids: [].freeze) if registry.nil? || registry.empty?
 
-        facts_by_plugin = facts_by_plugin(registry.plugins.first&.services&.fact_store)
-        parts = fact_parts(facts_by_plugin)
         opaque = []
+        facts_by_plugin = facts_by_plugin(registry, opaque)
+        parts = fact_parts(facts_by_plugin)
         registry.plugins.each { |plugin| collect_plugin_parts(plugin, facts_by_plugin, parts, opaque) }
         # Sort the parts so the digest is independent of plugin registration / iteration order.
         Result.new(
@@ -129,16 +130,25 @@ module Rigor
 
       # `{ plugin_id => ["name=digest", ...] }` for every ADR-9 published fact (channel a). A plugin that
       # published nothing does not appear.
-      def facts_by_plugin(fact_store)
+      #
+      # A fact the fingerprint cannot digest is an input it cannot see, so its publisher is opaque, whether or
+      # not the publisher contributes a type itself: other plugins read its facts. A fact store that cannot be
+      # read at all makes every plugin opaque. Both force the full run; dropping the facts instead would let a
+      # plugin with another surface reuse a snapshot its facts no longer match.
+      def facts_by_plugin(registry, opaque)
         result = Hash.new { |hash, key| hash[key] = [] }
-        return result if fact_store.nil?
-
-        fact_store.each_fact do |fact|
-          result[fact.plugin_id.to_s] << "#{fact.name}=#{digest_value(fact.value)}"
+        fact_store = registry.plugins.first&.services&.fact_store
+        fact_store&.each_fact do |fact|
+          plugin_id = fact.plugin_id.to_s
+          begin
+            result[plugin_id] << "#{fact.name}=#{digest_value(fact.value)}"
+          rescue StandardError
+            opaque << plugin_id
+          end
         end
         result
       rescue StandardError
-        # An unreadable fact store contributes nothing; opacity for contributing plugins is decided below.
+        registry.plugins.each { |plugin| opaque << safe_id(plugin) }
         Hash.new { |hash, key| hash[key] = [] }
       end
 
@@ -175,12 +185,13 @@ module Rigor
         true
       end
 
-      # A stable content digest of an arbitrary fact / producer value. Producer values are Marshal-clean by
-      # contract (the ADR-45 disk cache serialises them the same way), so this is the same round-trip the cache
-      # already relies on. A Marshal failure raises to the caller, which marks the plugin opaque (never a
-      # silent wrong-value digest).
+      # A digest of a fact / producer / hook value that depends on the value alone (issue #1574). A producer's
+      # value is computed on one run and served from its ADR-45 cache entry on the next; the two are equal but
+      # do not share the same objects, so a digest of their `Marshal.dump` bytes differed and invalidated the
+      # snapshot on every such switch. {Cache::ValueDigest} reads no identity. A value it cannot digest raises
+      # to the caller, which marks the plugin opaque (never a silent wrong-value digest).
       def digest_value(value)
-        Digest::SHA256.hexdigest(Marshal.dump(value))
+        Cache::ValueDigest.hexdigest(value)
       end
 
       def contributes_types?(plugin)

data/lib/rigor/analysis/reachability/scan_cache.rb

@@ -5,6 +5,7 @@ require "fileutils"
 require "zlib"
 
 require_relative "../../version"
+require_relative "../../cache/store"
 
 module Rigor
   module Analysis
@@ -94,7 +95,7 @@ module Rigor
           keep = @entries.merge(@live).select { |(_, path), _| File.exist?(path) }
           FileUtils.mkdir_p(File.dirname(@path))
           tmp = "#{@path}.#{Process.pid}.tmp"
-          File.binwrite(tmp, Zlib::Deflate.deflate(Marshal.dump([@header, keep])))
+          File.binwrite(tmp, Zlib::Deflate.deflate(Marshal.dump([@header, keep]), Cache::Store::DEFLATE_LEVEL))
           File.rename(tmp, @path)
           nil
         rescue StandardError

data/lib/rigor/analysis/run_cache_key.rb

@@ -21,6 +21,7 @@ require_relative "../environment/default_libraries"
 # lockfile paths without loading `rigor/environment` or the RBS machinery.
 require_relative "../environment/lockfile_resolver"
 require_relative "../environment/rbs_collection_discovery"
+require_relative "shadow_harness"
 
 module Rigor
   module Analysis
@@ -93,7 +94,7 @@ module Rigor
         Cache::Descriptor.new(
           gems: [Cache::RbsDescriptor.rbs_gem_entry],
           configs: rbs_config_entries + engine_source_entries + lockfile_entries(configuration) +
-                   template_unit_entries(template_units_digest) + [
+                   template_unit_entries(template_units_digest) + shadow_harness_entries + [
                      config_entry("configuration", Marshal.dump(configuration.to_h)),
                      config_entry("engine",
                                   "#{Rigor::VERSION}:#{Cache::Descriptor::SCHEMA_VERSION}:#{explain}"),
@@ -116,6 +117,15 @@ module Rigor
         digest.nil? ? [] : [config_entry("template-units", digest)]
       end
 
+      # ADR-116 WD5 — a run under `RIGOR_SHADOW_RULE_WALK` compares every table and rule collector with its
+      # legacy oracle, and a divergence is a row of the result. Keying on it keeps a warm hit from answering
+      # for a run the harness never checked, and a divergence row from replaying into a run without it. No
+      # slot with the harness off, so no existing key moves.
+      def shadow_harness_entries
+        identity = ShadowHarness.cache_identity
+        identity.nil? ? [] : [config_entry("shadow-harness", identity)]
+      end
+
       def engine_source_entries
         Cache::EngineSource.key_config_entries
       end
@@ -137,16 +147,25 @@ module Rigor
       # Content-only — the resolved PATH is deliberately not in the payload, so a checkout that moves (a CI
       # runner's workspace, a renamed directory) still hits with an identical lockfile.
       def lockfile_entries(configuration)
-        bundler = Environment::LockfileResolver.resolve_lockfile_path(
-          lockfile_path: configuration.bundler_lockfile, auto_detect: configuration.bundler_auto_detect
-        )
-        collection = Environment::RbsCollectionDiscovery.resolve_lockfile_path(
-          lockfile_path: configuration.rbs_collection_lockfile,
-          auto_detect: configuration.rbs_collection_auto_detect
-        )
+        bundler, collection = resolved_lockfile_paths(configuration)
         [lockfile_entry("bundler.lockfile", bundler), lockfile_entry("rbs_collection.lockfile", collection)]
       end
 
+      # The one resolution of the two dependency lockfiles — `[bundler, rbs_collection]`, each a Pathname or nil
+      # — shared by this key and by {Cache::IncrementalSnapshot.fingerprint} so the two caches identify the gem
+      # set by the same files (issue #1532): `bundler.lockfile:` / `rbs_collection.lockfile:` and auto-detection.
+      def resolved_lockfile_paths(configuration)
+        [
+          Environment::LockfileResolver.resolve_lockfile_path(
+            lockfile_path: configuration.bundler_lockfile, auto_detect: configuration.bundler_auto_detect
+          ),
+          Environment::RbsCollectionDiscovery.resolve_lockfile_path(
+            lockfile_path: configuration.rbs_collection_lockfile,
+            auto_detect: configuration.rbs_collection_auto_detect
+          )
+        ]
+      end
+
       # `nil` — no lockfile resolves — is itself part of the identity, so it carries its own sentinel rather
       # than dropping the slot: "absent" and "present but empty" must not key the same.
       ABSENT_LOCKFILE = "\0absent"

data/lib/rigor/analysis/run_stats.rb

@@ -95,12 +95,12 @@ module Rigor
       # with any of the signature path prefixes (after expansion to absolute paths); `bundled` is the
       # remainder.
       def self.partition_classes(class_decl_paths:, signature_paths:)
-        prefixes = Array(signature_paths).map { |p| File.expand_path(p.to_s) }
+        prefixes = Array(signature_paths).map { |p| File.absolute_path(p.to_s) }
         return [0, class_decl_paths.size] if prefixes.empty?
 
         project = 0
         class_decl_paths.each_value do |path|
-          expanded = File.expand_path(path)
+          expanded = File.absolute_path(path)
           project += 1 if prefixes.any? { |prefix| expanded.start_with?("#{prefix}/") || expanded == prefix }
         end
         [project, class_decl_paths.size - project]

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

@@ -965,7 +965,7 @@ module Rigor
 
         # Issue #959 — surfaces the {Plugin::IoBoundary} refusal history each loaded plugin accumulated over
         # the whole run (prepare AND every per-file call: `#io_boundary` is memoised per plugin instance, so
-        # one boundary sees both). `TrustPolicy#allow_read?` stays `File.expand_path`-only per ADR-2 — a
+        # one boundary sees both). `TrustPolicy#allow_read?` stays `File.absolute_path`-only per ADR-2 — a
         # project rooted under a symlink (macOS' `/tmp` → `/private/tmp` is the common case) can have every
         # plugin read fall outside its own read roots with nothing said about it. One `:info` row per plugin
         # that hit this, never one per path, naming the count and the first path so the row stays legible on

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

@@ -287,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
 

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

@@ -23,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
@@ -53,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_prepends,
-          :discovered_extends, :discovered_class_sources, :constant_values, :constant_sources, :constant_writes,
+          :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, :discovered_global_write_census
+          :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
@@ -172,7 +173,7 @@ module Rigor
             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),
@@ -186,7 +187,8 @@ module Rigor
             # `*_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
+            # 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
 
@@ -233,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
 
@@ -288,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,