rigortype 0.4.6 → 0.4.8

data/lib/rigor/analysis/run_cache_key.rb

@@ -99,7 +99,8 @@ module Rigor
           gems: [Cache::RbsDescriptor.rbs_gem_entry],
           dependencies: dependency_source_entries(configuration),
           configs: rbs_config_entries + engine_source_entries + lockfile_entries(configuration) +
-                   template_unit_entries(template_units_digest) + shadow_harness_entries + [
+                   collection_setup_hint_entries(configuration) + 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}"),
@@ -179,6 +180,24 @@ module Rigor
         [lockfile_entry("bundler.lockfile", bundler), lockfile_entry("rbs_collection.lockfile", collection)]
       end
 
+      # Issue #3030 — the `rbs.coverage.collection-not-installed` hint is a run-level row read off the working
+      # directory (an `rbs_collection.yaml`, a gem_rbs_collection `_test/` layout), which neither the lockfile slot
+      # nor the configuration covers: without this slot a warm run replayed the hint after the file went, or
+      # missed it after the file came. No slot when there is no hint, so every other project keeps its key.
+      def collection_setup_hint_entries(configuration)
+        hint = collection_setup_hint(configuration)
+        hint.nil? ? [] : [config_entry("rbs_collection.setup_hint", hint.to_s)]
+      end
+
+      # The hint {Analysis::Runner::DiagnosticAggregator} reports, read the same way. Shared with
+      # {Cache::IncrementalSnapshot.fingerprint}.
+      def collection_setup_hint(configuration)
+        Environment::RbsCollectionDiscovery.missing_lockfile_hint(
+          lockfile_path: configuration.rbs_collection_lockfile,
+          auto_detect: configuration.rbs_collection_auto_detect
+        )
+      end
+
       # ADR-10 slice 3, issue #1814 — the `dependencies.source_inference` gems' `(name, version, mode)` rows, which the
       # walker's output depends on and no lockfile digest covers when the project has none or the gem sits beside the
       # bundle. Shared by this key and by {Cache::IncrementalSnapshot.fingerprint}, as the lockfiles are. A project
@@ -216,12 +235,17 @@ module Rigor
 
       # The `rbs.libraries` config slot reconstructed from configuration alone — byte-identical to the
       # loader's `RbsDescriptor.libraries_entry(loader.libraries)` because `Environment.for_project` merges
-      # exactly `DEFAULT_LIBRARIES + config.libraries` (uniq) into `loader.libraries`, plus the
+      # exactly {Environment::BaseLibraries.resolve} — `DEFAULT_LIBRARIES + config.libraries` + the collection lockfile
+      # stdlib entries (issue #2946), uniq — into `loader.libraries`, plus the
       # `Environment::RequiredFeatures` tokens the run's source activates (issue #1700). Those are left out
       # here: reading every source file would cost the boot-slimming probe the time it exists to save, and a
       # project that requires a gated feature then only misses this probe, never hits a wrong slot.
       def libraries_config_entries(configuration)
-        merged = (Environment::DEFAULT_LIBRARIES + configuration.libraries.map(&:to_s)).uniq
+        merged = Environment::BaseLibraries.resolve(
+          configuration.libraries,
+          rbs_collection_lockfile: configuration.rbs_collection_lockfile,
+          rbs_collection_auto_detect: configuration.rbs_collection_auto_detect
+        )
         [Cache::RbsDescriptor.libraries_entry(merged)]
       end
     end

data/lib/rigor/analysis/run_disclosure_credit.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../typing_state"
+
 module Rigor
   module Analysis
     # Issue #2020 — what one file's analysis contributed to the run-scoped plugin tables ({Plugin::Base#disclose_once}
@@ -17,16 +19,27 @@ module Rigor
       ATTRIBUTION_KEY = :rigor_run_disclosure_attribution
       private_constant :ATTRIBUTION_KEY
 
+      # ADR-129 WD3 / #2814 — the registrations sink is a Resource: a `type_of` memo hit that served an answer without
+      # re-running the plugin hook would not append the registration the miss appended, so every {.attribute} refuses
+      # each open capture. Its storage stays the thread variable above (ADR-129 WD5 shape 2); this slot declares its
+      # kind.
+      SINK = TypingState.resource(
+        :run_disclosure_attribution,
+        reason: "every run-scoped plugin registration appends to the collecting sink, which a memo hit would not replay"
+      )
+      private_constant :SINK
+
       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.
+      # registration from inside an `Enumerator` still lands, carrying the installing fiber's typing state as
+      # {Plugin::IoBoundary.attributing} does.
       def collect
         registrations = []
         previous = Thread.current.thread_variable_get(ATTRIBUTION_KEY)
-        Thread.current.thread_variable_set(ATTRIBUTION_KEY, registrations)
+        Thread.current.thread_variable_set(ATTRIBUTION_KEY, [registrations, TypingState.current].freeze)
         begin
           yield
         ensure
@@ -35,9 +48,16 @@ module Rigor
         credit(registrations)
       end
 
-      # Called by {Plugin::Base#disclose_once} and {Plugin::Base#emit_once} for every call, a repeat included.
+      # Called by {Plugin::Base#disclose_once} and {Plugin::Base#emit_once} for every call, a repeat included. Touches
+      # {SINK} on the calling fiber's typing state and on the installing fiber's (ADR-129 WD3, #2814).
       def attribute(plugin, record)
-        Thread.current.thread_variable_get(ATTRIBUTION_KEY)&.push([plugin, record])
+        state = TypingState.current
+        state.touch(SINK)
+        registrations, owner = Thread.current.thread_variable_get(ATTRIBUTION_KEY)
+        return nil if registrations.nil?
+
+        owner.touch(SINK)
+        registrations.push([plugin, record])
         nil
       end
 
@@ -63,9 +83,9 @@ module Rigor
       end
 
       # The boundary's file and listing rows, read without triggering its lazy initializer: a plugin that never
-      # built one read nothing through it.
+      # built one read nothing through it. {Plugin::Base#built_io_boundary} is private to the engine, so it is sent.
       def boundary_rows(plugin)
-        boundary = plugin.instance_variable_get(:@io_boundary) or return []
+        boundary = plugin.__send__(:built_io_boundary) or return []
         descriptor = boundary.cache_descriptor
         descriptor.files + descriptor.globs
       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

@@ -4,6 +4,7 @@ require "tmpdir"
 
 require_relative "../../environment"
 require_relative "../../runtime/jit"
+require_relative "../../type_of_memo"
 
 module Rigor
   module Analysis
@@ -101,8 +102,8 @@ module Rigor
           @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.
@@ -164,10 +165,13 @@ module Rigor
         # `exit!` skips `at_exit` / stdio flush; the payload is already durable on disk by then.
         def run_fork_worker(slice, out_path)
           Runtime::Jit.rearm_after_fork
+          TypeOfMemo.forked
           results = slice.to_h { |binding, index| [index, run_one(binding)] }
           File.binwrite(out_path, Marshal.dump(results))
+          TypeOfMemo.write_report
           exit!(0)
         rescue StandardError
+          TypeOfMemo.write_report
           exit!(1)
         end
 

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

@@ -8,25 +8,25 @@ module Rigor
       # The declaration, not the method: this is a fact about what the author wrote, and the fix is on
       # that line. A `.rbs` position is the right answer here even though its sibling deliberately avoids
       # one (the `rbs_extended.unsatisfied-conformance` precedent) — there is no Ruby `def` that could
-      # carry the typo. A value written in configuration has no location at all and lands at
-      # `.rigor.yml:1`, the `rbs.coverage.quarantined-signature` precedent.
+      # carry the typo. A value written in configuration has no location at all and lands at the loaded
+      # configuration file's `1:1` (`.rigor.yml` when none was loaded — #2742), the
+      # `rbs.coverage.quarantined-signature` precedent.
       # A declaration's `location` is already the position a reader can open, `.rbs` and rbs-inline
       # alike: the synthesized-buffer line is re-anchored onto the Ruby file where the envelope is
       # built ({Rigor::Effects::InlineAnchor}, #432), so this module only has to split it. Doing the
       # re-anchoring here as well used to be the fix, and it could not tell two identically-spelled
       # annotations in one file apart — every finding in it landed on the first.
       module DeclarationPosition
-        CONFIG_PATH = ".rigor.yml"
-
         module_function
 
-        # @return `[path, line]`
-        def of(finding)
+        # @param config_path — the path a config-value finding lands at ({Rigor::Configuration#config_display_path}).
+        # @return the path and the one-based line of the finding
+        def of(finding, config_path)
           location = finding.location
-          return [CONFIG_PATH, 1] if location.nil?
+          return [config_path, 1] if location.nil?
 
           path, _, raw_line = location.rpartition(":")
-          return [CONFIG_PATH, 1] if path.empty?
+          return [config_path, 1] if path.empty?
 
           line = raw_line.to_i
           [path, line.positive? ? line : 1]