rigortype 0.4.5 → 0.4.6

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/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,12 +90,13 @@ 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
@@ -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/diagnostic_aggregator.rb

@@ -58,7 +58,7 @@ module Rigor
                        definition_build_failures_snapshot:, hkt_scan_failure_snapshot:,
                        conformance_results_snapshot:, signature_standdowns_snapshot: -> { [] },
                        vendored_standdowns_snapshot: -> { [] }, pooled_run_disclosures: -> { [] },
-                       pooled_trust_refusals: -> { [] })
+                       served_run_disclosures: -> { [] }, pooled_trust_refusals: -> { [] })
           @configuration = configuration
           @rbs_extended_reporter = rbs_extended_reporter
           @boundary_cross_reporter = boundary_cross_reporter
@@ -79,6 +79,8 @@ module Rigor
           # Issue #1051 — reader for the pool coordinator's de-duplicated run-scoped disclosure table.
           # Empty on a sequential run, where `plugin_registry`'s own instances are the ones that registered.
           @pooled_run_disclosures_reader = pooled_run_disclosures
+          # Issue #2020 — reader for the rows an incremental recheck replays for the files it served unanalysed.
+          @served_run_disclosures_reader = served_run_disclosures
           # Issue #1900 — reader for the pool coordinator's summed trust-refusal table. Empty on a
           # sequential run, where `plugin_registry`'s own boundaries made every read.
           @pooled_trust_refusals_reader = pooled_trust_refusals
@@ -1116,12 +1118,14 @@ module Rigor
         end
 
         # Issue #1051 — the run-scoped plugin disclosures ({Plugin::Base#disclose_once}), the run's
-        # project-global notices about its own inputs. Two sources feed one table:
+        # project-global notices about its own inputs. Three sources feed one table:
         #
         # - the coordinator-side registry, which is where a SEQUENTIAL run's `#prepare` and per-file hooks
         #   ran; and
         # - `pooled_run_disclosures`, the pool coordinator's already-de-duplicated collection from the
-        #   pre-fork parent session and every worker payload.
+        #   pre-fork parent session and every worker payload; and
+        # - `served_run_disclosures` (#2020), the rows an incremental recheck replays for the files it served
+        #   from cache, since their per-file hooks did not run.
         #
         # Both are keyed `[plugin id, key]` and the first registration of a pair wins, so a run emits one
         # row per pair no matter how many plugin instances (workers) reached it — the #1051 bug, where a
@@ -1183,6 +1187,10 @@ module Rigor
           rescue StandardError
             next
           end
+          # Issue #2020 — last, so a row this run registered afresh wins over the replay of the same key.
+          Array(@served_run_disclosures_reader.call).each do |record|
+            records[[record[:plugin_id], record[:key]]] ||= record
+          end
           records.values
         end
 

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

@@ -118,6 +118,12 @@ module Rigor
           @collected_analysis_reads ||= {}
         end
 
+        # Issue #2020 — the per-file run-scoped registrations the fork pool's workers recorded, folded into
+        # `Runner#analysis_disclosures` beside {#collected_analysis_reads}.
+        def collected_analysis_disclosures
+          @collected_analysis_disclosures ||= {}
+        end
+
         # 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.
@@ -914,7 +920,10 @@ module Rigor
             merge_run_disclosures(session.drain_run_disclosures)
             # 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.
-            collect_dependencies(session.drain_dependencies, session.drain_analysis_reads) if @record_dependencies
+            if @record_dependencies
+              collect_dependencies(session.drain_dependencies, session.drain_analysis_reads,
+                                   session.drain_analysis_disclosures)
+            end
             @collected_effects.merge!(session.drain_effects) if @record_effects
           end
 
@@ -952,6 +961,7 @@ module Rigor
           payload = { results: results, reporters: session.drain_reporters,
                       dependencies: session.drain_dependencies,
                       analysis_reads: session.drain_analysis_reads,
+                      analysis_disclosures: session.drain_analysis_disclosures,
                       disclosures: session.drain_run_disclosures,
                       refusals: session.drain_trust_refusals }
           # ADR-103 WD13 — the effects slot exists only on a collecting run, so a normal `--workers N` run
@@ -991,7 +1001,8 @@ module Rigor
               refusals = payload.fetch(:refusals, [])
               refusals_by_slice ? refusals_by_slice[child[:index]] = refusals : merge_trust_refusals(refusals)
               if @record_dependencies
-                collect_dependencies(payload.fetch(:dependencies, {}), payload.fetch(:analysis_reads, {}))
+                collect_dependencies(payload.fetch(:dependencies, {}), payload.fetch(:analysis_reads, {}),
+                                     payload.fetch(:analysis_disclosures, {}))
               end
               @collected_effects.merge!(payload.fetch(:effects, {})) if @record_effects
             else
@@ -1001,10 +1012,12 @@ module Rigor
           degraded
         end
 
-        # ADR-46 / issue #1553 — fold one worker's dependency records and per-file plugin reads.
-        def collect_dependencies(dependencies, analysis_reads)
+        # ADR-46 / issues #1553, #2020 — fold one worker's dependency records, per-file plugin reads and per-file
+        # run-scoped registrations.
+        def collect_dependencies(dependencies, analysis_reads, analysis_disclosures)
           @collected_dependencies.merge!(dependencies)
           collected_analysis_reads.merge!(analysis_reads)
+          collected_analysis_disclosures.merge!(analysis_disclosures)
         end
 
         # @return the child's `{results:, reporters:}` payload, or nil when the child exited

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

@@ -11,6 +11,8 @@ require_relative "../project_scan"
 require_relative "../worker_session"
 require_relative "../template_units"
 require_relative "../template_unit_collector"
+require_relative "../../project_environment"
+require_relative "scan_environment"
 
 module Rigor
   module Analysis
@@ -100,7 +102,7 @@ module Rigor
           synthetic_method_index = Inference::SyntheticMethodScanner.scan(
             plugin_registry: plugin_registry,
             paths: expansion.fetch(:files),
-            environment: nil,
+            environment: scan_environment(plugin_registry, dependency_source_index, expansion),
             fact_store: shared_fact_store(plugin_registry),
             buffer: @buffer
           )
@@ -135,7 +137,9 @@ module Rigor
         # collectors walk the tree, and the AST is dropped before the next file (peak RSS stays flat).
         def discover(expansion:)
           build_discovery(
-            Inference::ScopeIndexer.discovered_project_index_for_paths(expansion.fetch(:files), buffer: @buffer)
+            Inference::ScopeIndexer.discovered_project_index_for_paths(
+              expansion.fetch(:files), buffer: @buffer, uncertain: uncertain_paths(expansion)
+            )
           )
         end
 
@@ -145,11 +149,18 @@ module Rigor
         # (`seed_bundles` empty) this is `#discover` plus a fresh bundle set — the discovery index is identical.
         def discover_from_bundles(expansion:, seed_bundles:)
           index = Inference::ScopeIndexer.discovered_project_index_incremental(
-            expansion.fetch(:files), seed_bundles: seed_bundles, buffer: @buffer
+            expansion.fetch(:files), seed_bundles: seed_bundles, buffer: @buffer, uncertain: uncertain_paths(expansion)
           )
           [build_discovery(index), index.fetch(:bundles)]
         end
 
+        # Issue #2021 — the files only the `require_relative` walk added ({Runner#required_outside_paths}): their
+        # declarations resolve constants and their methods exist, but every method contribution is `possible`, so no
+        # return type, arity or visibility is read from them.
+        def uncertain_paths(expansion)
+          expansion.fetch(:uncertain, Inference::ScopeIndexer::EMPTY_PATH_SET)
+        end
+
         # Builds the {Discovery} bundle from a `{ classes:, def_index: }` index hash (shared by the plain and
         # seed-bundle discovery paths).
         def build_discovery(index)
@@ -294,6 +305,37 @@ module Rigor
 
         private
 
+        # Issue #476 — the environment the Tier B (trait registry) half of the synthetic-method scan reads, or
+        # nil when no loaded plugin registers a trait registry (the scan then has no use for one, and Tier C's
+        # template and nested-class lanes behave exactly as they did). The view is lazy ({ScanEnvironment}): it
+        # builds an {Environment} on the first question a matching call site asks. That environment is built
+        # WITHOUT `synthetic_method_index:` — the index is this scan's output and only the run's real
+        # environment stores it; the loader never reads it — and without the diagnostic reporters, which the
+        # run's real environment attaches (a second set here would double-report). Every input that decides
+        # what the loader resolves (libraries, signature paths, plugin signatures, the bundle / collection
+        # axes, required features) is the one the real build passes, so the module a trait names resolves to
+        # the same RBS the dispatcher later promotes against.
+        def scan_environment(plugin_registry, dependency_source_index, expansion)
+          return nil if plugin_registry.nil? || plugin_registry.empty?
+          return nil unless plugin_registry.plugins.any? { |plugin| plugin.manifest.trait_registries.any? }
+
+          files = expansion.fetch(:files)
+          ScanEnvironment.new do
+            Environment.for_project(
+              libraries: @configuration.libraries,
+              signature_paths: @configuration.signature_paths,
+              cache_store: @cache_store,
+              plugin_registry: plugin_registry,
+              dependency_source_index: dependency_source_index,
+              source_files: files,
+              required_features: ProjectEnvironment.required_features(
+                @configuration, files, sources: ProjectEnvironment.buffer_sources(@buffer)
+              ),
+              **ProjectEnvironment.dependency_discovery_options(@configuration)
+            )
+          end
+        end
+
         def trust_refusals(registry, baseline)
           registry.plugins.filter_map do |plugin|
             summary = plugin.io_boundary.refusal_summary

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Analysis
+    class Runner
+      # Issue #476 — the read-only, lazily built view of the project's RBS universe that the ADR-16 Tier B
+      # (trait registry) half of {Inference::SyntheticMethodScanner} reads.
+      #
+      # The scanner needs exactly two answers from an environment: `#rbs_loader` (to explode a trait module such
+      # as `Devise::Models::Recoverable` into its instance-method names) and `#class_ordering` (to decide
+      # whether a project class descends from an RBS-known `receiver_constraint` such as
+      # `ActiveRecord::Base`). Neither reads the synthetic-method index — `Environment.for_project` only stores
+      # that index, the RBS loader never consults it — so the chicken-and-egg the issue describes (the env
+      # consumes the scan's output) does not reach the loader: the view builds an environment WITHOUT the
+      # index, the scan runs against it, and the run's real environment is built afterwards WITH the index.
+      #
+      # The build is deferred to the first question. A scan whose trait registries never match a call site
+      # (no `devise` call in any class body) never asks, so it never pays the environment build. The build is
+      # fail-soft: a raise leaves the view answering "unknown", which is what the nil environment answered
+      # before — Tier B emits nothing rather than aborting the pre-pass.
+      class ScanEnvironment
+        # @param builder — called at most once, returns the {Rigor::Environment} (without a synthetic index).
+        def initialize(&builder)
+          @builder = builder
+          @built = false
+          @environment = nil
+        end
+
+        def rbs_loader
+          environment&.rbs_loader
+        end
+
+        def class_ordering(lhs, rhs)
+          env = environment
+          env.nil? ? :unknown : env.class_ordering(lhs, rhs)
+        end
+
+        private
+
+        def environment
+          return @environment if @built
+
+          @built = true
+          @environment = @builder.call
+        rescue StandardError
+          @environment = nil
+        end
+      end
+    end
+  end
+end