rigortype 0.4.5 → 0.4.7

data/lib/rigor/analysis/run_disclosure_credit.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Analysis
+    # Issue #2020 — what one file's analysis contributed to the run-scoped plugin tables ({Plugin::Base#disclose_once}
+    # and {Plugin::Base#emit_once}), kept beside the file's cached answer so an `--incremental` recheck that serves
+    # the file without analysing it can still report the rows a cold run reports.
+    #
+    # A replayed row must go stale with the inputs it is about, and the reads those inputs came from are credited to
+    # one file at most: a plugin memoises the input (a locale index, a routes table), so the first file to trigger
+    # the read is the only one credited with it, and a read in `#prepare` is credited to none. So each record also
+    # carries, under `:reads`, every row the registering plugin's boundary holds once the file is analysed,
+    # `#prepare`'s included. {IncrementalSession} keeps those rows per `[plugin id, key]`, not per file: when one goes
+    # stale it re-analyses one registering file and drops the key's replays, rather than re-analysing every file that
+    # registered it. Only inputs read through the boundary are covered.
+    module RunDisclosureCredit
+      ATTRIBUTION_KEY = :rigor_run_disclosure_attribution
+      private_constant :ATTRIBUTION_KEY
+
+      module_function
+
+      # Runs the block with run-scoped registrations attributed and returns the file's records — each a run-disclosure
+      # record tagged with its `plugin_id` and carrying the registering plugin's boundary rows as `:reads`, one per
+      # `[plugin id, key]` — frozen and Marshal-clean. A thread variable, as {Plugin::IoBoundary.attributing} uses, so a
+      # registration from inside an `Enumerator` still lands.
+      def collect
+        registrations = []
+        previous = Thread.current.thread_variable_get(ATTRIBUTION_KEY)
+        Thread.current.thread_variable_set(ATTRIBUTION_KEY, registrations)
+        begin
+          yield
+        ensure
+          Thread.current.thread_variable_set(ATTRIBUTION_KEY, previous)
+        end
+        credit(registrations)
+      end
+
+      # Called by {Plugin::Base#disclose_once} and {Plugin::Base#emit_once} for every call, a repeat included.
+      def attribute(plugin, record)
+        Thread.current.thread_variable_get(ATTRIBUTION_KEY)&.push([plugin, record])
+        nil
+      end
+
+      def credit(registrations)
+        return [].freeze if registrations.empty?
+
+        reads = {}.compare_by_identity
+        records = registrations.map do |plugin, record|
+          rows = reads[plugin] ||= boundary_rows(plugin).freeze
+          record.merge(plugin_id: plugin_id(plugin), reads: rows).freeze
+        end
+        records.uniq { |record| identity(record) }.freeze
+      end
+
+      # The de-duplication identity a record shares with every other registration of its key.
+      def identity(record)
+        [record[:plugin_id], record[:key]]
+      end
+
+      # The record as the aggregator replays it, without the rows that decide whether it is stale.
+      def replayable(record)
+        record.except(:reads).freeze
+      end
+
+      # The boundary's file and listing rows, read without triggering its lazy initializer: a plugin that never
+      # built one read nothing through it.
+      def boundary_rows(plugin)
+        boundary = plugin.instance_variable_get(:@io_boundary) or return []
+        descriptor = boundary.cache_descriptor
+        descriptor.files + descriptor.globs
+      end
+
+      def plugin_id(plugin)
+        plugin.manifest.id
+      rescue StandardError
+        plugin.class.to_s
+      end
+    end
+  end
+end

data/lib/rigor/analysis/run_disclosure_ledger.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require_relative "run_disclosure_credit"
+
+module Rigor
+  module Analysis
+    # Issue #2020 — the `--incremental` session's record of the run-scoped plugin rows ({Plugin::Base#disclose_once},
+    # {Plugin::Base#emit_once}) each analysed file's hooks registered, so a recheck can replay them for the files it
+    # serves from cache.
+    #
+    # - `files` maps a path to its records as the aggregator replays them, one per `[plugin id, key]` identity.
+    # - `reads` maps an identity to the registering plugin's boundary rows when it was last registered
+    #   ({RunDisclosureCredit}), `#prepare`'s reads included.
+    #
+    # Staleness is per identity, not per file. A plugin memoises the input a notice is about and re-registers the
+    # notice from every file's hook, so crediting the rows to every registering file would re-analyse all of them on
+    # any edit to an input the plugin read (one view edit re-analysed 400 of 400 files in an app with one i18n view
+    # row). Instead a recheck finds the identities whose rows went stale, re-analyses ONE live registering file for
+    # each (the first by path), and withholds those identities' replays. When that file registers the identity, every
+    # other holder takes its record. When it registers nothing — the edit took the notice out of its text, it no
+    # longer parses, the plugin raised — the recheck cannot tell whether the identity is gone, so it runs again with
+    # every other live holder of the identity analysed ({#unresolved_holders}), and the identity is dropped only if
+    # none of them registers it either.
+    #
+    # One shape stays unsound: a key whose registration or record depends both on an input the plugin read and on the
+    # registering file's own text. When the input changes and the chosen file still registers the key, the other
+    # holders take its record even where, re-analysed, they would register another record or none, until each is
+    # re-analysed itself. {Plugin::Base#disclose_once} asks a key not to vary between workers, which rules it out for a
+    # plugin that keeps the contract. Only inputs read through the plugin's boundary are tracked; state a plugin carries
+    # across files, or an input it reads around the boundary (`ENV`, a direct `File.read`), can leave a replayed row
+    # that never clears.
+    class RunDisclosureLedger
+      attr_reader :files, :reads
+
+      def initialize(files: {}, reads: {})
+        @files = files
+        @reads = reads
+      end
+
+      # The ledger a baseline builds from `fresh` (`{path => [record with :reads]}`, `Runner#analysis_disclosures`).
+      def self.from(fresh)
+        new.tap { |ledger| ledger.absorb(fresh, fresh.keys, Set.new) }
+      end
+
+      def self.load(data)
+        data.is_a?(Hash) ? new(files: data.fetch(:files, {}), reads: data.fetch(:reads, {})) : new
+      end
+
+      def to_h
+        { files: @files, reads: @reads }
+      end
+
+      # The identities with a boundary row that no longer validates under `fresh_row` (a row → Boolean predicate).
+      def stale_identities(&fresh_row)
+        verdicts = {}
+        @reads.each_with_object(Set.new) do |(identity, rows), stale|
+          stale << identity if rows.any? { |row| !verdicts.fetch(row) { verdicts[row] = fresh_row.call(row) } }
+        end
+      end
+
+      # One live registering file per stale identity, the first by path, skipping `removed`.
+      def refreshers(stale, removed)
+        return Set.new if stale.empty?
+
+        holders = {}
+        @files.each do |path, records|
+          next if removed.include?(path)
+
+          records.each do |record|
+            identity = RunDisclosureCredit.identity(record)
+            holders[identity] = [holders[identity], path].compact.min if stale.include?(identity)
+          end
+        end
+        holders.values.to_set
+      end
+
+      # The live holders, outside `analyzed`, of every `stale` identity no file in `analyzed` registered in `fresh`:
+      # the files that must be analysed when the chosen refresher registered nothing. Analysing every one of them
+      # settles the identity, since every holder has then decided it afresh.
+      def unresolved_holders(fresh, analyzed, stale, removed)
+        return Set.new if stale.empty?
+
+        registered = analyzed.flat_map do |path|
+          Array(fresh[path]).map { |record| RunDisclosureCredit.identity(record) }
+        end
+        unresolved = stale - registered
+        return Set.new if unresolved.empty?
+
+        @files.each_with_object(Set.new) do |(path, records), holders|
+          next if removed.include?(path) || analyzed.include?(path)
+
+          holders << path if records.any? { |record| unresolved.include?(RunDisclosureCredit.identity(record)) }
+        end
+      end
+
+      # The records to replay for `paths`, without the `stale` identities. Unpinned defence: a stale identity's replay
+      # cannot reach the output today, since a refresher that registers it wins over the replay and one that does not
+      # sends every holder into the second pass.
+      def served(paths, stale = Set.new)
+        @files.values_at(*paths).compact.flatten(1).reject do |record|
+          stale.include?(RunDisclosureCredit.identity(record))
+        end
+      end
+
+      # Folds a run's registrations in: every path in `analyzed` takes this run's records (or none), every identity
+      # this run registered takes this run's rows, and each `stale` identity is refreshed or dropped in the files the
+      # run did not analyse. Identities no file holds any more lose their rows.
+      def absorb(fresh, analyzed, stale)
+        registered = {}
+        analyzed.each do |path|
+          records = Array(fresh[path])
+          records.each { |record| registered[RunDisclosureCredit.identity(record)] ||= record }
+          store(path, records.map { |record| RunDisclosureCredit.replayable(record) })
+        end
+        registered.each { |identity, record| @reads[identity] = record[:reads] }
+        refresh_unanalysed(stale, registered, analyzed.to_set)
+        prune
+      end
+
+      def forget(path)
+        @files.delete(path)
+      end
+
+      private
+
+      def refresh_unanalysed(stale, registered, analyzed)
+        return if stale.empty?
+
+        @files.each_key.to_a.each do |path|
+          next if analyzed.include?(path)
+
+          store(path, @files[path].filter_map do |record|
+            identity = RunDisclosureCredit.identity(record)
+            next record unless stale.include?(identity)
+
+            registered[identity] && RunDisclosureCredit.replayable(registered[identity])
+          end)
+        end
+      end
+
+      def store(path, records)
+        records.empty? ? @files.delete(path) : @files[path] = records.freeze
+      end
+
+      # Unpinned hygiene: an identity no file holds is never replayed, so keeping its rows changes no answer; pruning
+      # them keeps a stale row from re-analysing a file for nothing and the snapshot from growing.
+      def prune
+        held = @files.each_value.flat_map do |records|
+          records.map { |record| RunDisclosureCredit.identity(record) }
+        end.to_set
+        @reads.select! { |identity, _| held.include?(identity) }
+      end
+    end
+  end
+end

data/lib/rigor/analysis/run_stats.rb

@@ -21,7 +21,7 @@ module Rigor
     #
     # Stats collection is intentionally cheap: wall + RSS are single syscalls, target file count is already
     # in `expand_paths`, gem source-walk uses `Index#class_to_gem.size`, and the RBS class breakdown walks
-    # `class_decl_paths` (a frozen `Hash<String, String>` populated once per environment by the RBS loader;
+    # `class_decl_paths` (a frozen class-name to source-path table populated once per environment by the RBS loader;
     # ~1000-2000 entries × one `String#start_with?`).
     class RunStats
       attr_reader :wall_seconds,
@@ -112,7 +112,7 @@ module Rigor
       # misleading breakdown row.
       CACHED_SENTINEL = "<cached>"
 
-      # Computes `(project_sig, bundled)` counts from a frozen `Hash<class_name => source_path>` snapshot and
+      # Computes `(project_sig, bundled)` counts from a frozen class-name to source-path snapshot and
       # the configured `signature_paths`. `project_sig` is the count of classes whose source path begins
       # with any of the signature path prefixes (after expansion to absolute paths); `bundled` is the
       # remainder.

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

@@ -79,6 +79,8 @@ module Rigor
         #   (`ProjectContext#environment`) every job's Runner reuses instead of rebuilding.
         # @param prebuilt — the warm, shared pre-pass snapshot
         #   (`ProjectContext#project_scan`) every job's Runner adopts instead of re-scanning.
+        # @param discovery_seed_for — issue #2147 — a callable returning the cross-file discovery seed for one
+        #   binding (`ProjectContext#discovery_seed_for`), or nil for none.
         # @param workers — pool size. `#analyze` degrades to sequential in-process execution — one
         #   job at a time, no `fork` — when fewer than 2 bindings are submitted, fewer than `min_batch_size`
         #   bindings are submitted, `workers` is not positive, `fork` is unavailable on this platform, or
@@ -88,18 +90,19 @@ module Rigor
         # @param min_batch_size — see {DEFAULT_MIN_BATCH_SIZE}. Exposed as a constructor param
         #   (rather than read from the env internally) purely for spec control; production callers get the
         #   resolved default.
-        def initialize(configuration:, cache_store:, environment:, prebuilt:, workers:,
+        def initialize(configuration:, cache_store:, environment:, prebuilt:, workers:, discovery_seed_for: nil,
                        min_batch_size: self.class.resolve_min_batch_size)
           @configuration = configuration
           @cache_store = cache_store
           @environment = environment
           @prebuilt = prebuilt
+          @discovery_seed_for = discovery_seed_for
           @workers = workers
           @min_batch_size = min_batch_size
         end
 
-        # Runs one `Runner#run([binding.logical_path])` per binding and returns `Array<Array<Diagnostic>>` —
-        # one diagnostics array per input binding, IN INPUT ORDER. The parent always absorbs worker results
+        # Runs one `Runner#run([binding.logical_path])` per binding and returns one diagnostics array per
+        # input binding, IN INPUT ORDER. The parent always absorbs worker results
         # re-indexed by POSITION, never keyed on path, so two bindings that happen to share a logical path
         # (should not occur — one dirty buffer per URI — but is not assumed away) can never collide or
         # silently overwrite one another.
@@ -123,7 +126,8 @@ module Rigor
         def run_one(binding)
           Runner.new(
             configuration: @configuration, cache_store: @cache_store, collect_stats: false,
-            buffer: binding, prebuilt: @prebuilt, environment: @environment
+            buffer: binding, prebuilt: @prebuilt, environment: @environment,
+            discovery_seed: @discovery_seed_for&.call(binding)
           ).run([binding.logical_path]).diagnostics
         end
 

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

@@ -20,7 +20,7 @@ module Rigor
 
         module_function
 
-        # @return `[path, line]`
+        # @return the path and the one-based line of the finding
         def of(finding)
           location = finding.location
           return [CONFIG_PATH, 1] if location.nil?