rigortype 0.3.1 → 0.3.3

data/lib/rigor/cache/incremental_snapshot.rb

@@ -4,6 +4,8 @@ require "fileutils"
 require "digest"
 require "zlib"
 
+require_relative "engine_source"
+
 module Rigor
   module Cache
     # ADR-46 — disk persistence for the incremental analyzer's per-file state, so a `--incremental` session
@@ -14,8 +16,16 @@ module Rigor
     # this snapshot is loaded UNCONDITIONALLY when the global fingerprint matches — the per-file digests
     # *inside* it drive the incremental re-analysis decision; they do not gate the load. The fingerprint
     # captures the inputs whose change requires a full rebuild — the resolved configuration, the RBS
-    # environment, the engine version — but NOT the analyzed source contents. A fingerprint mismatch (config /
-    # gem / version change) drops the snapshot and forces a full re-analysis, the conservative direction.
+    # environment, the engine version and (on a checkout) the engine's own source — but NOT the analyzed
+    # source contents. A fingerprint mismatch (config / gem / version / engine change) drops the snapshot and
+    # forces a full re-analysis, the conservative direction.
+    #
+    # An engine change drops the WHOLE snapshot rather than part of it, which is a soundness point before it
+    # is a simplicity one: every section here except `digests` is a value the analyzer computed, so a changed
+    # engine can move any of it — including the dependency edges, where a new engine recording an edge the old
+    # one missed would let a recheck skip the very file that needed re-analysing. Retaining the one
+    # engine-independent section would not pay either: `digests` is 2.5% of a 2.5 MB snapshot of this repo,
+    # and re-deriving it is a file-digest walk costing ~0.2% of the full run it would be saving.
     #
     # Every operation is fault-tolerant: a missing, unreadable, schema-mismatched, fingerprint-mismatched, or
     # corrupt snapshot loads as nil (→ a cold full run), and a write failure is swallowed (→ the next run is
@@ -38,8 +48,11 @@ module Rigor
       # bundle (the per-def parameter-shape / visibility / ancestry surface the declaration-stability gate
       # compares) and WD2 adds `return_summaries` (per-def observed-key return descriptors + mutation-effect
       # sets the behavioural-stability gate compares); a pre-10 blob mismatches the SCHEMA gate and loads as
-      # nil (a clean cold rebuild — no migration).
-      SCHEMA = 10
+      # nil (a clean cold rebuild — no migration). 11: ADR-67 WD6c lift adds `param_table` (the inferred-param
+      # seed table the run's diagnostics were computed under, diffed on the next recheck to invalidate a
+      # callee whose seeds moved because a caller changed); a pre-11 blob mismatches the SCHEMA gate and
+      # loads as nil (a clean cold rebuild — no migration).
+      SCHEMA = 11
 
       # The persisted per-file state.
       # `cache` maps an analyzed file to its diagnostics.
@@ -68,20 +81,35 @@ module Rigor
       # (Marshal-clean type tuples), their `describe(:short)` return descriptors, and the content-mutated
       # parameter positions. A recheck re-evaluates a declaration-stable changed callee at these keys and,
       # when every return + the effects are unchanged, skips its symbol dependents.
+      # ADR-67 WD6c lift:
+      # `param_table` is the `parameter_inference:` seed table (`[class, method, kind] => {param => Type}`)
+      # the run that wrote the snapshot seeded its analysis from — `{}` when the gate is off. A recheck
+      # recomputes the table fresh (the pre-pass is whole-project by design) and diffs it against this copy;
+      # a changed entry invalidates the callee's file and its symbol dependents. The types are Marshal-clean
+      # by the session's per-entry filter; a dropped entry re-checks its callee, the conservative direction.
       Payload = Data.define(:cache, :sources, :digests, :analyzed,
                             :symbol_sources, :ancestry_sources, :symbol_fingerprints,
                             :missing, :class_decls, :seed_bundles, :plugin_fact_digest,
-                            :return_summaries)
+                            :return_summaries, :param_table)
 
       # The global fingerprint that gates a snapshot load: a digest of the inputs whose change requires a full
-      # rebuild — the engine version + schema, the resolved configuration, the analysis **roots** (the path
-      # arguments, e.g. `["lib"]`, NOT the expanded file list — so a snapshot is keyed to an invocation's roots
-      # but adding / removing a file under them is handled incrementally by the session, not a full rebuild),
-      # the resolved gem set (`Gemfile.lock` / `rbs_collection`), and the project's own RBS (`signature_paths`
-      # file contents). Built WITHOUT constructing the RBS environment so the warm path can gate the load
-      # cheaply, before the costly env build. The `--verify-incremental` gate is the safety net for any
-      # under-capture (it would surface as an incremental-vs-full mismatch). Returns nil on any error → the
-      # caller falls back to a non-persisted run.
+      # rebuild — the engine version + schema, the engine's own SOURCE when the version does not pin it, the
+      # resolved configuration, the analysis **roots** (the path arguments, e.g. `["lib"]`, NOT the expanded
+      # file list — so a snapshot is keyed to an invocation's roots but adding / removing a file under them is
+      # handled incrementally by the session, not a full rebuild), the resolved gem set (`Gemfile.lock` /
+      # `rbs_collection`), and the project's own RBS (`signature_paths` file contents). Built WITHOUT
+      # constructing the RBS environment so the warm path can gate the load cheaply, before the costly env
+      # build. The `--verify-incremental` gate is the safety net for any under-capture (it would surface as an
+      # incremental-vs-full mismatch). Returns nil on any error → the caller falls back to a non-persisted run.
+      #
+      # Issue #285, wired here by #289 — every value in this snapshot is something the ANALYZER computed, so
+      # `Rigor::VERSION` alone is not enough to identify what produced it. A version pins the engine's bytes
+      # for a RubyGems install and for nothing else, so on a checkout a warm recheck served diagnostics a
+      # pre-edit analyzer had computed: editing `lib/rigor/inference/*.rb` moved no ANALYZED file, the changed
+      # set came back empty, and 357 unchanged files replayed their old answers.
+      # {EngineSource.process_identity} closes it, and answers nil for a version-pinned tree — which adds no
+      # part, so a released gem's fingerprint is byte-identical to the pre-#289 one and its warm snapshots
+      # survive the upgrade untouched.
       def self.fingerprint(configuration:, roots:)
         parts = [
           "engine:#{Rigor::VERSION}:#{SCHEMA}",
@@ -91,8 +119,15 @@ module Rigor
           "rbs_collection:#{digest_file_if_present('rbs_collection.lock.yaml')}",
           "sig:#{digest_signature_paths(configuration.signature_paths)}"
         ]
+        identity = EngineSource.process_identity
+        parts << "engine-source:#{identity}" if identity
         Digest::SHA256.hexdigest(parts.join("\x00"))
       rescue StandardError
+        # {EngineSource::Unavailable} lands here too, and nil is the answer it requires rather than one it
+        # merely tolerates: an engine we cannot identify must DISABLE the snapshot, never fall back to the
+        # version-only key that is the blind spot above. Nil does disable it on both sides —
+        # {Analysis::IncrementalSession} guards the load AND the save on the fingerprint, so nothing stale is
+        # read and no nil-keyed blob is written for the next equally-unidentifiable run to match against.
         nil
       end
 
@@ -124,9 +159,42 @@ module Rigor
       # The stored {Payload}, or nil when absent / unreadable / schema or fingerprint mismatch / corrupt.
       # Never raises.
       def load(fingerprint:)
+        data = read_data
+        return nil unless data && data[:fingerprint] == fingerprint
+
+        payload_from(data)
+      end
+
+      # Issue #134 slice 2 — the same load against SEVERAL acceptable fingerprints, reading the blob once.
+      # A reader that did not itself write the snapshot cannot know which analysis ROOTS it was written under
+      # (`rigor check --incremental lib` and a bare `rigor check --incremental` produce different fingerprints
+      # for the same project), and `#load` would have to re-inflate + re-unmarshal the whole blob per candidate.
+      # The fingerprint that matched is returned alongside the payload so the caller can mix it into ITS own
+      # cache key — the snapshot's identity is exactly what "these dependency edges came from that world" means.
+      #
+      # @param fingerprints [Array<String>] candidates, most-specific first.
+      # @return [Array(String, Payload), nil] `[matched fingerprint, payload]`, or nil on any miss.
+      def load_any(fingerprints:)
+        data = read_data
+        return nil if data.nil?
+
+        matched = Array(fingerprints).compact.find { |candidate| data[:fingerprint] == candidate }
+        return nil if matched.nil?
+
+        [matched, payload_from(data)]
+      end
+
+      # The raw stored Hash when it is present, readable, and schema-current; nil otherwise. Never raises —
+      # a missing, corrupt, or stale-schema snapshot is a cold run, not an error (the ADR-45 invariant).
+      def read_data
         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
+        data.is_a?(Hash) && data[:schema] == SCHEMA ? data : nil
+      rescue StandardError
+        nil
+      end
+      private :read_data
 
+      def payload_from(data)
         Payload.new(
           cache: data[:cache], sources: data[:sources],
           digests: data[:digests], analyzed: data[:analyzed],
@@ -137,11 +205,11 @@ module Rigor
           class_decls: data[:class_decls] || {},
           seed_bundles: data[:seed_bundles] || {},
           plugin_fact_digest: data[:plugin_fact_digest],
-          return_summaries: data[:return_summaries] || {}
+          return_summaries: data[:return_summaries] || {},
+          param_table: data[:param_table] || {}
         )
-      rescue StandardError
-        nil
       end
+      private :payload_from
 
       # Persist `payload` under `fingerprint`. Writes via a temp file + atomic rename so a concurrent reader
       # never sees a half-written snapshot. Returns true on success, false on any failure (never raises).
@@ -158,7 +226,8 @@ module Rigor
           class_decls: payload.class_decls,
           seed_bundles: payload.seed_bundles,
           plugin_fact_digest: payload.plugin_fact_digest,
-          return_summaries: payload.return_summaries
+          return_summaries: payload.return_summaries,
+          param_table: payload.param_table
         )
         blob = Zlib::Deflate.deflate(raw)
         tmp = "#{@path}.#{Process.pid}.tmp"

data/lib/rigor/cli/check_command.rb

@@ -48,9 +48,6 @@ module Rigor
 
         configuration = load_check_configuration(options)
         configuration = apply_bleeding_edge_override(configuration, options)
-        conflict = parameter_inference_incremental_conflict(configuration, options)
-        return conflict unless conflict.nil?
-
         config_warnings = warn_unresolved_config(configuration)
         cache_root = configuration.cache_path
         handle_clear_cache(cache_root) if options.fetch(:clear_cache)
@@ -62,7 +59,7 @@ module Rigor
         return finalize_cache_hit(probed, configuration, options, config_warnings) unless probed.nil?
 
         load_check_dependencies
-        special = dispatch_special_check_mode(configuration, options, cache_root)
+        special = dispatch_special_check_mode(configuration, options, cache_root, buffer)
         return special unless special.nil?
 
         invocation = invoke_check(
@@ -143,30 +140,24 @@ module Rigor
         exit_code
       end
 
-      # ADR-67 WD6c — `parameter_inference:` and the ADR-46 incremental modes are mutually exclusive in slice 1.
-      # The parameter table introduces cross-file edges (a caller's argument types drive a callee's body
-      # diagnostics) that the per-file dependency recorder does not yet carry, so a cached file whose parameter
-      # seeds changed would serve a stale result. Refuse with a message naming the ADR-46 gap rather than
-      # silently producing unsound incremental diagnostics; the edge wiring is the named follow-up. Returns the
-      # usage exit code on a conflict, or nil to proceed. `--verify-incremental` (the acceptance gate that runs
-      # incremental analysis) is caught here too.
-      def parameter_inference_incremental_conflict(configuration, options)
-        return nil unless configuration.parameter_inference
-        return nil unless options.fetch(:incremental) || options.fetch(:verify_incremental)
-
-        flag = options.fetch(:incremental) ? "--incremental" : "--verify-incremental"
-        @err.puts("rigor: parameter_inference: cannot combine with #{flag} — the call-site parameter table " \
-                  "introduces cross-file caller→callee edges the ADR-46 incremental dependency graph does not " \
-                  "yet record, so a cached file could serve a stale diagnostic. Run a full check (drop " \
-                  "#{flag}), or disable parameter_inference: for this run.")
-        CLI::EXIT_USAGE
-      end
-
       # ADR-46 — the two incremental-analysis check modes both fully handle the run and return an exit code (so `run`
       # short-circuits); returns nil for an ordinary check.
-      def dispatch_special_check_mode(configuration, options, cache_root)
-        return run_verify_incremental(configuration, options, cache_root) if options.fetch(:verify_incremental)
-        return run_incremental_check(configuration, options, cache_root) if options.fetch(:incremental)
+      # A nil return means "not a special mode" — `run` continues with the ordinary check. Editor mode option B
+      # also returns nil when it declines (no reusable snapshot), so the run falls back to single-file scope.
+      def dispatch_special_check_mode(configuration, options, cache_root, buffer)
+        if options.fetch(:verify_incremental)
+          # The gate compares an incremental recheck against a full-run oracle, and a buffer makes the two
+          # disagree by construction (the oracle reads the file on disk). Refusing beats the silent wrong
+          # answer both incremental modes gave a buffer before #146.
+          if buffer
+            @err.puts("rigor: --verify-incremental cannot run against an editor buffer " \
+                      "(--tmp-file / --instead-of); it compares against a full analysis of the files on disk.")
+            return CLI::EXIT_USAGE
+          end
+
+          return run_verify_incremental(configuration, options, cache_root)
+        end
+        return run_incremental_check(configuration, options, cache_root, buffer) if options.fetch(:incremental)
 
         nil
       end
@@ -212,7 +203,7 @@ module Rigor
       # run (plus their dependents), serving the rest from the snapshot; on a miss runs a full baseline. Persists the
       # updated snapshot for the next invocation. Diagnostics are identical to a full run (the `--verify-incremental`
       # gate enforces this); the win is skipping per-file inference for unchanged files.
-      def run_incremental_check(configuration, options, cache_root)
+      def run_incremental_check(configuration, options, cache_root, buffer = nil)
         require_relative "check_runner_factory"
         paths = @argv.empty? ? nil : @argv
         fingerprint = Cache::IncrementalSnapshot.fingerprint(
@@ -226,9 +217,12 @@ module Rigor
           # ADR-46 — thread the same worker-count precedence the standard `check` path uses
           # (CLI `--workers` > `RIGOR_RACTOR_WORKERS` > `parallel.workers:` > 0) so the recheck's closure
           # re-analysis parallelises; the fork pool marshals dependency records back so the graph is sound.
-          workers: CheckRunnerFactory.resolve_workers(options, configuration)
+          workers: CheckRunnerFactory.resolve_workers(options, configuration),
+          buffer: buffer
         )
 
+        return run_editor_mode_option_b(session, snapshot, fingerprint, configuration, options) if buffer
+
         diagnostics, warm = session.run_incremental(snapshot: snapshot, fingerprint: fingerprint)
         # The banner's file count comes from the session's analyzed set (cold analyses all; a warm recheck's
         # `@analyzed` advances to the current file set), so a dedicated probe Runner + `Dir.glob` is no longer
@@ -244,6 +238,33 @@ module Rigor
         result.success? ? 0 : 1
       end
 
+      # Editor mode option B (#146) — `--incremental` plus an editor buffer. The whole project is in scope with
+      # the buffer substituted for one file: the buffer's logical path and its dependents re-analyse, every
+      # other file is served from the snapshot. Before this, the two flags together silently ignored the
+      # buffer and analysed the file on disk, which is a wrong answer rather than a missing feature.
+      #
+      # The session never saves — the buffer's bytes exist only in the editor — so there is no warm state to
+      # build up. That is why a snapshot it cannot reuse means falling back to option A (single-file scope,
+      # the pre-#146 behaviour) instead of running a baseline that would repeat on the next keystroke. The
+      # note tells the user how to get option B: warm the snapshot with a plain `rigor check --incremental`.
+      def run_editor_mode_option_b(session, snapshot, fingerprint, configuration, options)
+        result = session.run_buffer_recheck(snapshot: snapshot, fingerprint: fingerprint)
+        if result.nil?
+          @err.puts("rigor: --incremental has no reusable snapshot for this project; analysing the buffer " \
+                    "alone (run `rigor check --incremental` once to enable whole-project editor mode).")
+          return nil
+        end
+
+        @err.puts("rigor: --incremental editor mode — re-analysed #{result.affected.size} file(s), " \
+                  "#{result.reused.size} served from cache")
+        emit_incremental_fact_surface_notes(session)
+        filtered = apply_baseline_filter(
+          Analysis::Result.new(diagnostics: result.diagnostics, stats: nil), configuration, options
+        )
+        write_result(filtered, options.fetch(:format))
+        filtered.success? ? 0 : 1
+      end
+
       # ADR-88 WD1 — a one-line stderr note when the plugin fact surface (an ADR-9 fact, an ADR-60 producer
       # value, or an `incremental_state_fingerprint` hook) forced a full run: either it CHANGED since the
       # snapshot (a Sorbet sig edit, a schema change) or a contributing plugin declares NO fingerprint surface

data/lib/rigor/cli/coverage_command.rb

@@ -27,6 +27,7 @@ require_relative "fused_protection_report"
 require_relative "fused_protection_renderer"
 require_relative "coverage_mutation"
 require_relative "protection_fork_scan"
+require_relative "mutation_fork_scan"
 require_relative "check_runner_factory"
 require_relative "command"
 
@@ -90,7 +91,7 @@ module Rigor
       def parse_options
         options = { format: "text", threshold: nil, config: nil, protection: false, mutation: false,
                     with_tests: false, test_command: DEFAULT_TEST_COMMAND, include_dynamic: false,
-                    limit: nil, seed: 1, workers: nil }
+                    limit: nil, seed: 1, workers: nil, no_cache: false }
         OptionParser.new { |opts| define_options(opts, options) }.parse!(@argv)
         options
       end
@@ -103,7 +104,8 @@ module Rigor
           options[:protection] = true
         end
         define_mutation_options(opts, options)
-        opts.on("--workers=N", Integer, "With --protection: fork N workers over the scanned files " \
+        opts.on("--workers=N", Integer, "With --protection (with or without --mutation, but not --with-tests, " \
+                                        "which must stay sequential): fork N workers over the scanned files " \
                                         "(default: config parallel.workers / RIGOR_RACTOR_WORKERS / 0)") do |v|
           options[:workers] = v
         end
@@ -135,6 +137,12 @@ module Rigor
           options[:limit] = v
         end
         opts.on("--seed=N", Integer, "RNG seed for --limit sampling (default 1)") { |v| options[:seed] = v }
+        opts.on("--no-cache", "With --mutation: measure every file from scratch, neither reading nor writing " \
+                              "the per-file mutation-result cache (#134 slice 2). The cold arm of the " \
+                              "warm==cold gate; unrelated caches (RBS environment, plugin producers) are " \
+                              "untouched.") do
+          options[:no_cache] = true
+        end
       end
 
       def mutation_misuse_error
@@ -204,6 +212,11 @@ module Rigor
       #
       # Both span the scanned `paths` only (no whole-project pre-pass) — a site that gains neither is classified exactly
       # as before.
+      #
+      # Tier 2's analogue is {Protection::DiscoverySeed} (#253, #260): the same idea over a *fuller* table set,
+      # because Tier 2 must also let its kill oracle resolve the method on the receiver, not merely name its
+      # class. Tier 1 seeds unconditionally because it only reclassifies sites it already counted; Tier 2 adds
+      # sites to a denominator `--threshold` gates CI on, which is why only the latter is gated on a feature id.
       def scope_with_inferred_params(paths, configuration, environment, workers)
         base = Scope.empty(environment: environment)
         seed = {}