rigortype 0.1.16 → 0.1.18

data/lib/rigor/analysis/self_call_resolution_recorder.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Analysis
+    # ADR-24 slice 4a — records every *implicit-self* method call the
+    # inference engine could not resolve to any method (RBS tier miss +
+    # user-class ancestor-walk miss + not a `Dynamic` receiver), captured
+    # at the single engine choke-point where such a call falls through to
+    # `Dynamic[top]` (`ExpressionTyper#call_type_for` → `fallback_for`).
+    #
+    # ## Why a recorder, not a check-rule
+    #
+    # Slice 4 attempt 1 reimplemented self-call resolution inside
+    # `CheckRules` and produced 135 false positives on Rigor's own `lib`
+    # ([ADR-24](../../../docs/adr/24-self-method-call-resolution.md)
+    # § "Slice 4"): the second, weaker resolution path could not see
+    # `module_function` siblings, `Data.define` / `Struct` accessors, or
+    # mixin-contributed methods that the *engine's* real resolution
+    # handles. Recording at the engine's own miss point reuses that real
+    # resolution — those methods resolve before the miss, so they never
+    # reach the recorder. This module is the ADR-46 / ADR-47 "collect at
+    # evaluation time, never recompute" lesson applied to self-calls.
+    #
+    # A later slice consumes the recorded misses behind a confidently-
+    # closed-class gate to emit `call.self-undefined-method`, behind its
+    # own external-corpus false-positive gate. This slice (4a) lands the
+    # plumbing OFF by default — {active?} is false on a normal run, so the
+    # instrumented choke-point pays a single integer read and records
+    # nothing. Recording is purely observational; it never changes a
+    # diagnostic.
+    #
+    # Modelled on {DependencyRecorder}: process-thread-local accumulator,
+    # a cheap disabled fast path, and a frozen snapshot for consumers.
+    module SelfCallResolutionRecorder
+      KEY = :__rigor_self_call_resolution_recorder__
+      private_constant :KEY
+
+      # One unresolved implicit-self call. `class_name` is the receiver's
+      # statically known class (the enclosing `self` type); `method_name`
+      # the called name; `node` the Prism `CallNode` (held in-memory so the
+      # `call.self-undefined-method` collector can resolve its scope from the
+      # scope index and apply the closed-class gate); `path` / `line` /
+      # `column` locate the call site for the diagnostic.
+      UnresolvedSelfCall = Data.define(:class_name, :method_name, :node, :path, :line, :column)
+
+      # Mutable per-consumer accumulator, frozen into a {Record} snapshot
+      # when {record_for} returns. Dedupes by the full call tuple so a
+      # method body re-typed under several call-site signatures records the
+      # miss once.
+      class Accumulator
+        attr_reader :consumer, :calls
+
+        def initialize(consumer)
+          @consumer = consumer
+          @calls = []
+          @seen = Set.new
+        end
+
+        def add(call)
+          return unless @seen.add?(call)
+
+          @calls << call
+        end
+
+        def snapshot
+          Record.new(consumer: consumer, calls: calls.dup.freeze)
+        end
+      end
+
+      Record = Data.define(:consumer, :calls)
+
+      # Module-level activation count so the disabled fast path ({active?})
+      # is a plain integer read rather than a `Thread.current` hash lookup —
+      # the instrumented choke-point is on the dispatch miss path, so a
+      # normal (non-recording) run must pay as little as possible.
+      @active_count = 0
+      @mutex = Mutex.new
+
+      module_function
+
+      # Activates recording for `consumer` (the path being analyzed) for the
+      # duration of the block and returns the frozen {Record}. Nests safely;
+      # restores the previous recorder on exit.
+      def record_for(consumer)
+        previous = Thread.current[KEY]
+        accumulator = Accumulator.new(consumer.to_s)
+        Thread.current[KEY] = accumulator
+        @mutex.synchronize { @active_count += 1 }
+        yield
+        accumulator.snapshot
+      ensure
+        Thread.current[KEY] = previous
+        @mutex.synchronize { @active_count -= 1 }
+      end
+
+      # Plain integer read (GVL-atomic) — no `Thread.current` lookup on the
+      # disabled fast path.
+      def active?
+        @active_count.positive?
+      end
+
+      # Records one unresolved implicit-self call. No-op when no consumer is
+      # active on this thread (another thread may have flipped {active?}).
+      def record(class_name:, method_name:, node:, path:, line:, column:)
+        accumulator = Thread.current[KEY]
+        return if accumulator.nil?
+
+        accumulator.add(
+          UnresolvedSelfCall.new(
+            class_name: class_name.to_s,
+            method_name: method_name.to_sym,
+            node: node,
+            path: path,
+            line: line,
+            column: column
+          )
+        )
+      end
+    end
+  end
+end

data/lib/rigor/analysis/worker_session.rb

@@ -39,12 +39,19 @@ module Rigor
     # - `plugin_blueprints` — Phase 3a
     #   (`Array<Plugin::Blueprint>` is `Ractor.shareable?`).
     # - `explain` — Boolean.
-    # - `synthetic_method_index` / `project_patched_methods` —
-    #   optional (default `nil`). NOT `Ractor.shareable?`, so the
-    #   Ractor pool path leaves them unset; the fork backend
+    # - `synthetic_method_index` / `project_patched_methods` /
+    #   `project_scope_seed` — optional (default `nil` / `{}`). NOT
+    #   `Ractor.shareable?` (the seed tables carry Prism def nodes),
+    #   so the Ractor pool path leaves them unset; the fork backend
     #   (ADR-15 Amendment), which builds the session pre-fork on the
     #   parent, threads the runner's project-scan results through so
     #   per-file inference matches the sequential path exactly.
+    #   `project_scope_seed` is `Runner#project_scope_seed_tables` —
+    #   the cross-file discovery tables `seed_project_scope` applies
+    #   to every per-file scope on the sequential path; without it a
+    #   worker cannot resolve calls to methods defined in OTHER
+    #   project files and emits `call.undefined-method` false
+    #   positives the sequential path does not.
     #
     # Internally the session OWNS (and never shares):
     #
@@ -97,13 +104,14 @@ module Rigor
       def initialize(configuration:, cache_store: nil, # rubocop:disable Metrics/MethodLength,Metrics/ParameterLists
                      plugin_blueprints: [], explain: false, buffer: nil,
                      synthetic_method_index: nil, project_patched_methods: nil,
-                     source_files: [])
+                     project_scope_seed: {}, source_files: [])
         @configuration = configuration
         @cache_store = cache_store
         @explain = explain
         @buffer = buffer
         @synthetic_method_index = synthetic_method_index
         @project_patched_methods = project_patched_methods
+        @project_scope_seed = project_scope_seed || {}
         # ADR-32 WD4 — full project file list (frozen
         # Array<String>) for env-build-time invocation of any
         # loaded plugin's `source_rbs_synthesizer` callable.
@@ -165,7 +173,7 @@ module Rigor
           return parse_diagnostics(path, parse_result)
         end
 
-        scope = Scope.empty(environment: @environment, source_path: path)
+        scope = seed_project_scope(Scope.empty(environment: @environment, source_path: path))
         index = Inference::ScopeIndexer.index(parse_result.value, default_scope: scope)
         diagnostics = CheckRules.diagnose(
           path: path,
@@ -200,6 +208,17 @@ module Rigor
 
       private
 
+      # Mirrors {Runner#seed_project_scope}: applies the cross-file
+      # pre-pass discovery tables the constructor received (fork
+      # backend only — see the class comment) to a fresh per-file
+      # scope, so worker-side inference resolves project-internal
+      # cross-file calls exactly like the sequential path.
+      def seed_project_scope(scope)
+        return scope if @project_scope_seed.empty?
+
+        scope.with_discovery(scope.discovery.with(**@project_scope_seed))
+      end
+
       # See {Runner#parse_source}. Same contract: if `@buffer`
       # binds `path` to a physical file, read the physical bytes
       # but stamp the parse buffer's `filepath:` as the LOGICAL
@@ -278,14 +297,34 @@ module Rigor
       def plugin_emitted_diagnostics(path, root, scope)
         return [] if @plugin_registry.empty?
 
+        # ADR-52 WD4 — single engine-owned node-rule walk per file; the
+        # results are bucketed per plugin (registry order) so emission
+        # stays plugin-major and byte-identical with the per-plugin walk.
+        node_results = node_rule_results_by_plugin(path, root, scope)
+
         @plugin_registry.plugins.flat_map do |plugin|
-          collect_plugin_diagnostics(plugin, path, root, scope)
+          collect_plugin_diagnostics(plugin, path, root, scope, node_results[plugin])
         end
       end
 
-      def collect_plugin_diagnostics(plugin, path, root, scope)
+      def node_rule_results_by_plugin(path, root, scope)
+        walk = @plugin_registry.node_rule_walk
+        return {}.compare_by_identity if walk.empty?
+
+        results = walk.diagnostics_for_file(path: path, scope: scope, root: root)
+        results.each_with_object({}.compare_by_identity) do |result, by_plugin|
+          by_plugin[result.plugin] = result
+        end
+      end
+
+      def collect_plugin_diagnostics(plugin, path, root, scope, node_result)
         raw = Array(plugin.diagnostics_for_file(path: path, scope: scope, root: root))
-        raw += plugin.node_rule_diagnostics(path: path, scope: scope, root: root)
+        # A node-rule context/rule raise isolates the whole plugin's
+        # node-rule contribution, matching the old combined per-plugin
+        # rescue (which discarded `diagnostics_for_file` output too).
+        raise node_result.error if node_result&.error
+
+        raw += node_result.diagnostics if node_result
         raw.map { |diagnostic| stamp_plugin_diagnostic(diagnostic, plugin.manifest.id) }
       rescue StandardError => e
         [plugin_runtime_error_diagnostic(path, plugin, e)]

data/lib/rigor/builtins/static_return_refinements.rb

@@ -134,8 +134,14 @@ module Rigor
       # @return [Array<String>] the candidate owner class names
       #   for a bare method-name lookup. Empty when no override
       #   names this method.
+      NO_OWNERS = [].freeze
+      private_constant :NO_OWNERS
+
+      # Consulted on every dispatch (`try_static_refinement`); the miss
+      # case is overwhelmingly common, so share one frozen empty array
+      # instead of allocating a fresh `[]` per non-refined method.
       def self.owners_for(method_name)
-        OWNERS_BY_METHOD[method_name.to_sym] || []
+        OWNERS_BY_METHOD[method_name.to_sym] || NO_OWNERS
       end
     end
   end

data/lib/rigor/cache/descriptor.rb

@@ -2,6 +2,7 @@
 
 require "digest"
 require "json"
+require_relative "../value_semantics"
 
 module Rigor
   module Cache
@@ -38,10 +39,14 @@ module Rigor
       # can mutate after the entry is in a Descriptor.
 
       class FileEntry
+        include Rigor::ValueSemantics
+
         VALID_COMPARATORS = %i[digest mtime exists].freeze
 
         attr_reader :path, :comparator, :value
 
+        value_fields :path, :comparator, :value
+
         def initialize(path:, comparator:, value:)
           unless VALID_COMPARATORS.include?(comparator)
             raise ArgumentError,
@@ -57,20 +62,15 @@ module Rigor
         def to_h
           { "path" => path, "comparator" => comparator.to_s, "value" => value }
         end
-
-        def ==(other)
-          other.is_a?(FileEntry) && other.path == path && other.comparator == comparator && other.value == value
-        end
-        alias eql? ==
-
-        def hash
-          [self.class, path, comparator, value].hash
-        end
       end
 
       class GemEntry
+        include Rigor::ValueSemantics
+
         attr_reader :name, :requirement, :locked
 
+        value_fields :name, :requirement, :locked
+
         def initialize(name:, requirement:, locked: nil)
           @name = name.to_s.dup.freeze
           @requirement = requirement.to_s.dup.freeze
@@ -81,20 +81,15 @@ module Rigor
         def to_h
           { "name" => name, "requirement" => requirement, "locked" => locked }
         end
-
-        def ==(other)
-          other.is_a?(GemEntry) && other.name == name && other.requirement == requirement && other.locked == locked
-        end
-        alias eql? ==
-
-        def hash
-          [self.class, name, requirement, locked].hash
-        end
       end
 
       class PluginEntry
+        include Rigor::ValueSemantics
+
         attr_reader :id, :version, :config_hash
 
+        value_fields :id, :version, :config_hash
+
         def initialize(id:, version:, config_hash: nil)
           @id = id.to_s.dup.freeze
           @version = version.to_s.dup.freeze
@@ -105,21 +100,15 @@ module Rigor
         def to_h
           { "id" => id, "version" => version, "config_hash" => config_hash }
         end
-
-        def ==(other)
-          other.is_a?(PluginEntry) &&
-            other.id == id && other.version == version && other.config_hash == config_hash
-        end
-        alias eql? ==
-
-        def hash
-          [self.class, id, version, config_hash].hash
-        end
       end
 
       class ConfigEntry
+        include Rigor::ValueSemantics
+
         attr_reader :key, :value_hash
 
+        value_fields :key, :value_hash
+
         def initialize(key:, value_hash:)
           @key = key.to_s.dup.freeze
           @value_hash = value_hash.to_s.dup.freeze
@@ -129,15 +118,6 @@ module Rigor
         def to_h
           { "key" => key, "value_hash" => value_hash }
         end
-
-        def ==(other)
-          other.is_a?(ConfigEntry) && other.key == key && other.value_hash == value_hash
-        end
-        alias eql? ==
-
-        def hash
-          [self.class, key, value_hash].hash
-        end
       end
 
       # Per-(gem, version, mode) row carrying the cache slice
@@ -155,10 +135,14 @@ module Rigor
       # the inferred shapes depend on whether RBS overrides the
       # walk.
       class DependencyEntry
+        include Rigor::ValueSemantics
+
         VALID_MODES = %i[disabled when_missing full].freeze
 
         attr_reader :gem_name, :gem_version, :mode
 
+        value_fields :gem_name, :gem_version, :mode
+
         def initialize(gem_name:, gem_version:, mode:)
           unless VALID_MODES.include?(mode)
             raise ArgumentError,
@@ -174,18 +158,6 @@ module Rigor
         def to_h
           { "gem_name" => gem_name, "gem_version" => gem_version, "mode" => mode.to_s }
         end
-
-        def ==(other)
-          other.is_a?(DependencyEntry) &&
-            other.gem_name == gem_name &&
-            other.gem_version == gem_version &&
-            other.mode == mode
-        end
-        alias eql? ==
-
-        def hash
-          [self.class, gem_name, gem_version, mode].hash
-        end
       end
 
       # Raised when {.compose} encounters incompatible entries
@@ -206,6 +178,20 @@ module Rigor
         freeze
       end
 
+      # ADR-45 — re-validates this descriptor's recorded {FileEntry}s
+      # against the current filesystem. Used by the record-and-validate
+      # run-result cache: a value cached alongside its dependency
+      # descriptor is fresh iff every recorded file still matches. Only
+      # `files` are checked — non-file inputs (config / gems / version)
+      # belong in the cache *key*, not the validated dependency set — so
+      # a descriptor carrying any non-file slot is never considered fresh
+      # (it was built wrong for this use).
+      def fresh?
+        return false unless gems.empty? && plugins.empty? && configs.empty? && dependencies.empty?
+
+        files.all? { |entry| file_entry_fresh?(entry) }
+      end
+
       # File-comparator strictness ordering. `:digest` is strictest
       # (deterministic across machines); `:mtime` is cheaper but
       # local; `:exists` is the weakest signal. When two
@@ -290,6 +276,21 @@ module Rigor
 
       private
 
+      def file_entry_fresh?(entry)
+        case entry.comparator
+        when :digest
+          File.file?(entry.path) && Digest::SHA256.file(entry.path).hexdigest == entry.value
+        when :mtime
+          File.exist?(entry.path) && File.mtime(entry.path).to_i.to_s == entry.value
+        when :exists
+          File.exist?(entry.path).to_s == entry.value
+        else
+          false
+        end
+      rescue StandardError
+        false
+      end
+
       def sort_entries(entries, key)
         entries.sort_by { |e| e.to_h.fetch(key).to_s }
       end

data/lib/rigor/cache/incremental_snapshot.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "digest"
+require "zlib"
+
+module Rigor
+  module Cache
+    # ADR-46 — disk persistence for the incremental analyzer's per-file
+    # state, so a `--incremental` session survives across processes (one
+    # `rigor check` invocation reads the prior run's per-file diagnostics +
+    # dependency graph, re-analyzes only the changed closure, and serves the
+    # rest from disk).
+    #
+    # Unlike ADR-45's whole-run cache (record-and-validate ONE entry,
+    # invalidated by any analyzed-file change), 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.
+    #
+    # 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 cold). A cache must never break a run (the ADR-45 invariant).
+    class IncrementalSnapshot
+      # Bump when the on-disk shape changes so stale snapshots are ignored
+      # rather than mis-deserialized. 5: the blob is zlib-deflated
+      # (ADR-54 WD2 parity with `Store` entries — the snapshot is the
+      # one cache artefact that does not go through `Store`); a raw
+      # pre-5 blob fails the inflate and loads as nil, the usual
+      # fault-tolerant cold-run path.
+      SCHEMA = 5
+
+      # The persisted per-file state.
+      # `cache` maps an analyzed file to its diagnostics.
+      # `sources` maps a consumer to the Set of source files it read from.
+      # `digests` maps a file to its content digest at analysis time.
+      # `analyzed` is the ordered analyzed-file list.
+      # ADR-46 slice 4:
+      # `symbol_sources` maps a consumer to { source_path → Set<"ClassName#method"> }.
+      # `ancestry_sources` maps a consumer to Set<source_path> (class-ancestry deps).
+      # `symbol_fingerprints` maps a path to { "ClassName#method" => sha256_hex }.
+      # ADR-46 slice 3:
+      # `missing` maps a consumer to Set<"kind:name"> it looked up and missed.
+      # `class_decls` maps a path to Set<qualified class name> it declares.
+      Payload = Data.define(:cache, :sources, :digests, :analyzed,
+                            :symbol_sources, :ancestry_sources, :symbol_fingerprints,
+                            :missing, :class_decls)
+
+      # 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.
+      def self.fingerprint(configuration:, roots:)
+        parts = [
+          "engine:#{Rigor::VERSION}:#{SCHEMA}",
+          "config:#{Digest::SHA256.hexdigest(Marshal.dump(configuration.to_h))}",
+          "roots:#{Array(roots).map(&:to_s).sort.join("\n")}",
+          "gems:#{digest_file_if_present('Gemfile.lock')}",
+          "rbs_collection:#{digest_file_if_present('rbs_collection.lock.yaml')}",
+          "sig:#{digest_signature_paths(configuration.signature_paths)}"
+        ]
+        Digest::SHA256.hexdigest(parts.join("\x00"))
+      rescue StandardError
+        nil
+      end
+
+      def self.digest_file_if_present(path)
+        File.file?(path) ? Digest::SHA256.file(path).hexdigest : "absent"
+      end
+      private_class_method :digest_file_if_present
+
+      # Content-digest every `.rbs` under the configured signature paths
+      # (sorted for determinism) so a project RBS edit invalidates the
+      # snapshot. Sig trees are small; content (not mtime) keeps it stable
+      # across checkouts.
+      def self.digest_signature_paths(signature_paths)
+        globbed = Array(signature_paths).flat_map do |entry|
+          File.directory?(entry) ? Dir.glob(File.join(entry, "**", "*.rbs")) : [entry]
+        end
+        files = globbed.select { |path| File.file?(path) }.sort
+        digest = Digest::SHA256.new
+        files.each { |path| digest << path << "\0" << Digest::SHA256.file(path).hexdigest << "\0" }
+        digest.hexdigest
+      end
+      private_class_method :digest_signature_paths
+
+      def initialize(root:)
+        @path = File.join(root.to_s, "incremental", "snapshot.bin")
+      end
+
+      attr_reader :path
+
+      # The stored {Payload}, or nil when absent / unreadable / schema or
+      # fingerprint mismatch / corrupt. Never raises.
+      def load(fingerprint:)
+        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
+
+        Payload.new(
+          cache: data[:cache], sources: data[:sources],
+          digests: data[:digests], analyzed: data[:analyzed],
+          symbol_sources: data[:symbol_sources] || {},
+          ancestry_sources: data[:ancestry_sources] || {},
+          symbol_fingerprints: data[:symbol_fingerprints] || {},
+          missing: data[:missing] || {},
+          class_decls: data[:class_decls] || {}
+        )
+      rescue StandardError
+        nil
+      end
+
+      # 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).
+      def save(fingerprint:, payload:)
+        FileUtils.mkdir_p(File.dirname(@path))
+        raw = Marshal.dump(
+          schema: SCHEMA, fingerprint: fingerprint,
+          cache: payload.cache, sources: payload.sources,
+          digests: payload.digests, analyzed: payload.analyzed,
+          symbol_sources: payload.symbol_sources,
+          ancestry_sources: payload.ancestry_sources,
+          symbol_fingerprints: payload.symbol_fingerprints,
+          missing: payload.missing,
+          class_decls: payload.class_decls
+        )
+        blob = Zlib::Deflate.deflate(raw)
+        tmp = "#{@path}.#{Process.pid}.tmp"
+        File.binwrite(tmp, blob)
+        File.rename(tmp, @path)
+        true
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

data/lib/rigor/cache/rbs_cache_producer.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "rbs_descriptor"
+
+module Rigor
+  module Cache
+    # Base for the RBS-derived cache producers.
+    #
+    # Every producer (`RbsKnownClassNames`, `RbsConstantTable`,
+    # `RbsEnvironment`, the ancestor / type-param / definition tables, …)
+    # repeated the identical `fetch` wiring: build the RBS descriptor,
+    # then `store.fetch_or_compute` under the producer's id, yielding to
+    # the producer's `compute`. Only the `PRODUCER_ID` constant and the
+    # `compute(loader)` body actually differ between producers.
+    #
+    # Subclasses declare `PRODUCER_ID` and a (private) `self.compute`;
+    # this base owns `fetch`. `self::PRODUCER_ID` resolves the constant on
+    # the concrete subclass, and `compute(loader)` dispatches to its
+    # private class method. See the `_CacheProducer` RBS interface for the
+    # structural contract.
+    class RbsCacheProducer
+      def self.fetch(loader:, store:)
+        # ADR-54 WD4 — the descriptor is identical for every producer
+        # consulting the same loader (same sig files, same libraries),
+        # so the loader memoises one build per process instead of
+        # re-digesting every .rbs file once per producer.
+        descriptor = loader.rbs_cache_descriptor
+        store.fetch_or_compute(producer_id: self::PRODUCER_ID, params: {}, descriptor: descriptor) do
+          compute(loader)
+        end
+      end
+    end
+  end
+end

data/lib/rigor/cache/rbs_class_ancestor_table.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "rbs_descriptor"
+require_relative "rbs_cache_producer"
 
 module Rigor
   module Cache
@@ -22,19 +23,12 @@ module Rigor
     # Cache descriptor shape is shared with every other cache
     # producer that depends on the RBS environment — see
     # {RbsDescriptor.build}.
-    class RbsClassAncestorTable
+    class RbsClassAncestorTable < RbsCacheProducer
       PRODUCER_ID = "rbs.class_ancestor_table"
 
       # @param loader [Rigor::Environment::RbsLoader]
       # @param store [Rigor::Cache::Store]
       # @return [Hash{String => Array<String>}]
-      def self.fetch(loader:, store:)
-        descriptor = RbsDescriptor.build(loader)
-        store.fetch_or_compute(producer_id: PRODUCER_ID, params: {}, descriptor: descriptor) do
-          compute(loader)
-        end
-      end
-
       def self.compute(loader)
         table = {}
         loader.each_known_class_name do |name|

data/lib/rigor/cache/rbs_class_type_param_names.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "rbs_descriptor"
+require_relative "rbs_cache_producer"
 
 module Rigor
   module Cache
@@ -22,19 +23,12 @@ module Rigor
     # Cache descriptor shape is shared with every other cache
     # producer that depends on the RBS environment — see
     # {RbsDescriptor.build}.
-    class RbsClassTypeParamNames
+    class RbsClassTypeParamNames < RbsCacheProducer
       PRODUCER_ID = "rbs.class_type_param_names"
 
       # @param loader [Rigor::Environment::RbsLoader]
       # @param store [Rigor::Cache::Store]
       # @return [Hash{String => Array<Symbol>}]
-      def self.fetch(loader:, store:)
-        descriptor = RbsDescriptor.build(loader)
-        store.fetch_or_compute(producer_id: PRODUCER_ID, params: {}, descriptor: descriptor) do
-          compute(loader)
-        end
-      end
-
       def self.compute(loader)
         table = {}
         loader.each_known_class_name do |name|