rigortype 0.0.8 → 0.1.0

data/lib/rigor/cache/rbs_class_type_param_names.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "rbs_descriptor"
+
+module Rigor
+  module Cache
+    # Cache producer that materialises every loaded class's
+    # RBS-declared type-parameter names as a Marshal-clean
+    # `Hash<String, Array<Symbol>>` keyed by top-level-stripped
+    # class name (e.g. `"Array"` → `[:Elem]`, `"Hash"` →
+    # `[:K, :V]`). Producer id `"rbs.class_type_param_names"`.
+    #
+    # The dispatcher reads type-parameter names every time it
+    # builds a substitution map from a receiver's `type_args`
+    # into a method's return type — it is one of the hottest
+    # reflection lookups during analysis. Building one entry
+    # requires a full `RBS::DefinitionBuilder#build_instance`
+    # over that class, the same expensive operation
+    # {RbsClassAncestorTable} caches; the two producers share
+    # the build cost when populated together.
+    #
+    # Cache descriptor shape is shared with every other cache
+    # producer that depends on the RBS environment — see
+    # {RbsDescriptor.build}.
+    class RbsClassTypeParamNames
+      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|
+          key = name.delete_prefix("::")
+          params = type_params_for(loader, key)
+          table[key] = params unless params.nil?
+        end
+        table
+      end
+
+      def self.type_params_for(loader, class_name)
+        definition = loader.instance_definition(class_name)
+        return nil if definition.nil?
+
+        definition.type_params.dup.freeze
+      rescue ::RBS::BaseError
+        nil
+      end
+
+      private_class_method :compute, :type_params_for
+    end
+  end
+end

data/lib/rigor/cache/rbs_constant_table.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "digest"
+require_relative "rbs_descriptor"
 
 module Rigor
   module Cache
@@ -12,16 +12,9 @@ module Rigor
     # `Marshal`-clean (RBS-native objects carry `RBS::Location`,
     # which lacks `_dump_data`).
     #
-    # Cache descriptor:
-    #
-    # - `gems`: the `rbs` gem (with the locked version) so a gem
-    #   upgrade invalidates the table — bundled core + stdlib
-    #   signatures live inside the gem.
-    # - `files`: the digest of every `.rbs` file under the loader's
-    #   `signature_paths` (project-supplied signatures that the
-    #   gem's locked version cannot cover).
-    # - `configs`: the SHA-256 of the loader's libraries list so
-    #   adding/removing a stdlib library invalidates.
+    # Cache descriptor shape is shared with every other cache
+    # producer that depends on the RBS environment — see
+    # {RbsDescriptor.build} for the slot definitions.
     class RbsConstantTable
       PRODUCER_ID = "rbs.constant_type_table"
 
@@ -29,55 +22,26 @@ module Rigor
       # @param store [Rigor::Cache::Store]
       # @return [Hash{String => Rigor::Type}]
       def self.fetch(loader:, store:)
-        descriptor = build_descriptor(loader)
+        descriptor = RbsDescriptor.build(loader)
         store.fetch_or_compute(producer_id: PRODUCER_ID, params: {}, descriptor: descriptor) do
           compute(loader)
         end
       end
 
-      def self.build_descriptor(loader)
-        Descriptor.new(
-          gems: [rbs_gem_entry],
-          files: file_entries(loader),
-          configs: [libraries_entry(loader)]
-        )
-      end
-
       def self.compute(loader)
-        loader.constant_names.each_with_object({}) do |name, table|
-          translated = loader.constant_type(name)
-          table[name] = translated unless translated.nil?
+        table = {}
+        loader.each_constant_decl do |name, entry|
+          translated = Inference::RbsTypeTranslator.translate(entry.decl.type)
+          table[name] = translated unless translated.is_a?(Type::Bot)
+        rescue ::RBS::BaseError
+          # Skip entries whose RBS type fails to translate; the cache
+          # stays robust to a broken signature rather than corrupting
+          # the whole table. Analyzer-internal errors propagate.
         end
+        table
       end
 
-      def self.rbs_gem_entry
-        Descriptor::GemEntry.new(name: "rbs", requirement: ">= 0", locked: ::RBS::VERSION.to_s)
-      end
-
-      def self.file_entries(loader)
-        loader.signature_paths.flat_map do |root|
-          next [] unless root.directory?
-
-          Dir.glob(root.join("**", "*.rbs")).map do |path|
-            Descriptor::FileEntry.new(
-              path: path,
-              comparator: :digest,
-              value: Digest::SHA256.file(path).hexdigest
-            )
-          end
-        end
-      end
-
-      def self.libraries_entry(loader)
-        sorted = loader.libraries.map(&:to_s).sort
-        Descriptor::ConfigEntry.new(
-          key: "rbs.libraries",
-          value_hash: Digest::SHA256.hexdigest(sorted.join("\n"))
-        )
-      end
-
-      private_class_method :build_descriptor, :compute,
-                           :rbs_gem_entry, :file_entries, :libraries_entry
+      private_class_method :compute
     end
   end
 end

data/lib/rigor/cache/rbs_descriptor.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "digest"
+
+require_relative "descriptor"
+
+module Rigor
+  module Cache
+    # Shared descriptor builder for cache producers that depend on the
+    # RBS environment (constant table, known-class set, future
+    # Marshal-clean reflection artefacts). Every consumer attaches the
+    # same three slots, so factoring the construction here keeps the
+    # producers small and ensures invalidation behaves identically
+    # across them.
+    module RbsDescriptor
+      # @param loader [Rigor::Environment::RbsLoader]
+      # @return [Rigor::Cache::Descriptor]
+      def self.build(loader)
+        Descriptor.new(
+          gems: [rbs_gem_entry],
+          files: file_entries(loader),
+          configs: [libraries_entry(loader)]
+        )
+      end
+
+      def self.rbs_gem_entry
+        Descriptor::GemEntry.new(name: "rbs", requirement: ">= 0", locked: ::RBS::VERSION.to_s)
+      end
+
+      def self.file_entries(loader)
+        loader.signature_paths.flat_map do |root|
+          next [] unless root.directory?
+
+          Dir.glob(root.join("**", "*.rbs")).map do |path|
+            Descriptor::FileEntry.new(
+              path: path,
+              comparator: :digest,
+              value: Digest::SHA256.file(path).hexdigest
+            )
+          end
+        end
+      end
+
+      def self.libraries_entry(loader)
+        sorted = loader.libraries.map(&:to_s).sort
+        Descriptor::ConfigEntry.new(
+          key: "rbs.libraries",
+          value_hash: Digest::SHA256.hexdigest(sorted.join("\n"))
+        )
+      end
+
+      private_class_method :rbs_gem_entry, :file_entries, :libraries_entry
+    end
+  end
+end

data/lib/rigor/cache/rbs_environment.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "rbs_descriptor"
+require_relative "rbs_environment_marshal_patch"
+
+module Rigor
+  module Cache
+    # Cache producer that materialises the entire
+    # `RBS::Environment` (the loader's `build_env` result) and
+    # round-trips it through `Marshal` against the patched
+    # `RBS::Location` (see {RbsEnvironmentMarshalPatch}).
+    #
+    # Cold runs pay the full
+    # `RBS::EnvironmentLoader#load + RBS::Environment.from_loader
+    # + resolve_type_names` cost once; warm runs (and a separate
+    # loader sharing the same Store) load the marshalled blob and
+    # skip the parse / resolve stages entirely. The
+    # `RbsConstantTable`, `RbsKnownClassNames`,
+    # `RbsClassAncestorTable`, and `RbsClassTypeParamNames`
+    # caches still live alongside this producer — their cached
+    # values are reached without re-touching env, but when an
+    # uncached lookup happens (`instance_method`,
+    # `singleton_method`, …) the env produced here is what
+    # answers it.
+    #
+    # Cache descriptor shape is shared with every other cache
+    # producer that depends on the RBS environment — see
+    # {RbsDescriptor.build}.
+    class RbsEnvironment
+      PRODUCER_ID = "rbs.environment"
+
+      # @param loader [Rigor::Environment::RbsLoader]
+      # @param store [Rigor::Cache::Store]
+      # @return [::RBS::Environment]
+      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)
+        Rigor::Environment::RbsLoader.build_env_for(
+          libraries: loader.libraries,
+          signature_paths: loader.signature_paths
+        )
+      end
+
+      private_class_method :compute
+    end
+  end
+end

data/lib/rigor/cache/rbs_environment_marshal_patch.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "rbs"
+
+# Adds `_dump` / `_load` to {RBS::Location} so an
+# `RBS::Environment` (and its transitive AST nodes, all of
+# which carry Locations) round-trips through `Marshal`. The
+# rbs gem's C-extension `RBS::Location` ships without the
+# Marshal hooks; until rbs grows them upstream this patch is
+# the minimal monkey-patch the v0.0.9 RBS::Environment cache
+# relies on.
+#
+# Patch policy (purely additive):
+#
+# - `_dump` returns an empty string. The cached env loses
+#   per-node source-position info, but Rigor does not consult
+#   `RBS::Location` from any analysis code path (every
+#   diagnostic uses Prism's own location), so the loss is
+#   inert in practice.
+# - `_load` reconstructs a sentinel Location backed by an
+#   empty `<cached>` Buffer. Code paths that DID consult
+#   Location after a cache hit see a benign zero-range value
+#   rather than crashing.
+#
+# Idempotent: the guard checks `method_defined?(:_dump)` so
+# requiring this file twice (or against an upstream rbs that
+# adds Marshal hooks itself) is a no-op.
+module RBS
+  class Location
+    unless method_defined?(:_dump)
+      def _dump(_)
+        ""
+      end
+
+      def self._load(_)
+        new(buffer: ::RBS::Buffer.new(name: "<cached>", content: ""), start_pos: 0, end_pos: 0)
+      end
+    end
+  end
+end

data/lib/rigor/cache/rbs_instance_definitions.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "rbs_descriptor"
+require_relative "rbs_environment_marshal_patch"
+
+module Rigor
+  module Cache
+    # Cache producer that materialises the full
+    # `Hash<String, RBS::Definition>` for instance-side class
+    # definitions in the RBS environment, in a single cache
+    # entry. Mirrors the {RbsConstantTable} layout.
+    #
+    # ADR-7 § "Slice 6-D" carry-over and dogfooding feedback:
+    # the earlier per-class cache layout (one entry per class,
+    # ~1300 files) made warm runs *slower* than `--no-cache`
+    # because each `instance_definition` call paid disk-open +
+    # `Marshal.load` overhead and the in-memory
+    # `RBS::DefinitionBuilder.build_instance` was actually fast
+    # given a cached `RBS::Environment`. The single-blob layout
+    # collapses that to one `Marshal.load` per process; warm runs
+    # now match `--no-cache` timing while preserving the
+    # cross-process invalidation story.
+    #
+    # Marshal-cleanness of `RBS::Definition` is enabled by the
+    # v0.0.9 C2 `RBS::Location` patch.
+    class RbsInstanceDefinitions
+      PRODUCER_ID = "rbs.instance_definitions"
+
+      # @param loader [Rigor::Environment::RbsLoader]
+      # @param store [Rigor::Cache::Store]
+      # @return [Hash{String => RBS::Definition}]
+      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|
+          definition = loader.uncached_instance_definition(name)
+          table[name] = definition if definition
+        end
+        table
+      end
+
+      private_class_method :compute
+    end
+
+    # Singleton-side equivalent of {RbsInstanceDefinitions}.
+    # Caches the full `Hash<String, RBS::Definition>` for the
+    # singleton class of every RBS-known class.
+    class RbsSingletonDefinitions
+      PRODUCER_ID = "rbs.singleton_definitions"
+
+      # @param loader [Rigor::Environment::RbsLoader]
+      # @param store [Rigor::Cache::Store]
+      # @return [Hash{String => RBS::Definition}]
+      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|
+          definition = loader.uncached_singleton_definition(name)
+          table[name] = definition if definition
+        end
+        table
+      end
+
+      private_class_method :compute
+    end
+  end
+end

data/lib/rigor/cache/rbs_known_class_names.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "rbs_descriptor"
+
+module Rigor
+  module Cache
+    # Cache producer that materialises the set of every RBS-declared
+    # class / module / alias name (top-level prefixed, e.g.
+    # `"::Math"`) currently loaded into the environment. Marshal-
+    # clean — the cache value is a `Set<String>`.
+    #
+    # The set lets `RbsLoader#class_known?` answer point lookups in
+    # O(1) without re-parsing the name on each call, and lets a warm
+    # process skip the env walk entirely (the env still has to be
+    # built to enumerate decls on cold misses; subsequent processes
+    # sharing the Store load the set straight from disk).
+    #
+    # Cache descriptor shape is shared with {RbsConstantTable} via
+    # {RbsDescriptor.build}; a single signature change or rbs gem
+    # bump invalidates both producers in lockstep.
+    class RbsKnownClassNames
+      PRODUCER_ID = "rbs.known_class_names"
+
+      # @param loader [Rigor::Environment::RbsLoader]
+      # @param store [Rigor::Cache::Store]
+      # @return [Set<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)
+        names = Set.new
+        loader.each_known_class_name { |name| names << name }
+        names
+      end
+
+      private_class_method :compute
+    end
+  end
+end

data/lib/rigor/cache/store.rb

@@ -5,6 +5,8 @@ require "fileutils"
 require "json"
 require "securerandom"
 
+require_relative "descriptor"
+
 module Rigor
   module Cache
     # Filesystem-backed cache store. Schema, layout, file format,
@@ -30,10 +32,27 @@ module Rigor
 
       def initialize(root:)
         @root = root.to_s.dup.freeze
+        @hits = 0
+        @misses = 0
+        @writes = 0
+        @by_producer = Hash.new { |h, k| h[k] = { hits: 0, misses: 0, writes: 0 } }
       end
 
       attr_reader :root
 
+      # Returns a frozen snapshot of this Store's per-run hit / miss /
+      # write counters. The bookkeeping is in-memory only — every new
+      # `Store.new` starts at zero — so the counters reflect activity
+      # against this specific instance rather than the on-disk cache
+      # state. Disk-level state is reported separately by
+      # {.disk_inventory}.
+      #
+      # @return [Hash] `{ hits:, misses:, writes:, by_producer: { id => { hits:, misses:, writes: } } }`
+      def stats
+        per_producer = @by_producer.transform_values { |counts| counts.dup.freeze }.freeze
+        { hits: @hits, misses: @misses, writes: @writes, by_producer: per_producer }.freeze
+      end
+
       # Walks the on-disk cache rooted at `root` and reports a
       # producer-level inventory. Used by `rigor check --cache-stats`
       # to surface cache size and per-producer entry counts without
@@ -84,21 +103,43 @@ module Rigor
       #   via {Descriptor#cache_key_for}.
       # @param descriptor [Rigor::Cache::Descriptor] the invalidation
       #   descriptor for the value being cached.
-      # @yieldreturn the value to cache (must be `Marshal.dump`-able).
+      # @param serialize [#call, nil] optional callable that turns the
+      #   producer's return value into a binary `String`. Defaults to
+      #   `Marshal.dump(value).b`. Producers whose return values are
+      #   not `Marshal`-clean (RBS-native objects with `RBS::Location`
+      #   members, raw `IO`, …) MUST provide a serialiser. The pair
+      #   `(serialize, deserialize)` MUST round-trip — a producer that
+      #   reads with one strategy and writes with another corrupts
+      #   its own cache slice.
+      # @param deserialize [#call, nil] optional callable that turns
+      #   bytes back into the producer's value. Defaults to
+      #   `Marshal.load`. Any exception (`StandardError`) raised by
+      #   the deserialiser is treated as a cache miss — the entry is
+      #   considered corrupt, the producer block reruns, and the
+      #   next write overwrites it. This is consistent with the
+      #   fault-tolerance contract for the default `Marshal.load`
+      #   path.
+      # @yieldreturn the value to cache.
       # @return the cached value (loaded from disk on hit; produced by
       #   the block on miss).
-      def fetch_or_compute(producer_id:, params:, descriptor:, &block)
+      def fetch_or_compute(producer_id:, params:, descriptor:,
+                           serialize: nil, deserialize: nil, &block)
         validate_producer_id!(producer_id)
         ensure_schema_version!
 
         key = descriptor.cache_key_for(producer_id: producer_id, params: params)
         path = entry_path(producer_id, key)
 
-        cached = read_entry(path)
-        return cached.value unless cached.nil?
+        cached = read_entry(path, deserialize: deserialize)
+        unless cached.nil?
+          record(:hits, producer_id)
+          return cached.value
+        end
 
+        record(:misses, producer_id)
         value = block.call
-        write_entry(path, descriptor, value)
+        write_entry(path, descriptor, value, serialize: serialize)
+        record(:writes, producer_id)
         value
       end
 
@@ -107,6 +148,15 @@ module Rigor
       Entry = Data.define(:descriptor_bytes, :value)
       private_constant :Entry
 
+      def record(counter, producer_id)
+        case counter
+        when :hits then @hits += 1
+        when :misses then @misses += 1
+        when :writes then @writes += 1
+        end
+        @by_producer[producer_id][counter] += 1
+      end
+
       def validate_producer_id!(producer_id)
         return if producer_id.is_a?(String) && producer_id.match?(VALID_PRODUCER_ID)
 
@@ -121,7 +171,7 @@ module Rigor
       # Reads and validates one entry file. Any failure (missing,
       # short, bad magic, bad version, bad checksum, unmarshal-able)
       # returns nil so the caller treats it as a cache miss.
-      def read_entry(path)
+      def read_entry(path, deserialize: nil)
         return nil unless File.file?(path)
 
         bytes = File.binread(path)
@@ -131,8 +181,8 @@ module Rigor
         descriptor_bytes, value_bytes = parse_body(body)
         return nil if descriptor_bytes.nil?
 
-        value = safe_marshal_load(value_bytes)
-        return nil if value.equal?(MARSHAL_LOAD_FAILED)
+        value = safe_load(value_bytes, deserialize)
+        return nil if value.equal?(LOAD_FAILED)
 
         Entry.new(descriptor_bytes, value)
       end
@@ -164,20 +214,24 @@ module Rigor
         [descriptor_bytes, value_bytes]
       end
 
-      MARSHAL_LOAD_FAILED = Object.new.freeze
-      private_constant :MARSHAL_LOAD_FAILED
+      LOAD_FAILED = Object.new.freeze
+      private_constant :LOAD_FAILED
 
-      def safe_marshal_load(bytes)
-        Marshal.load(bytes) # rubocop:disable Security/MarshalLoad
+      def safe_load(bytes, deserialize)
+        if deserialize
+          deserialize.call(bytes)
+        else
+          Marshal.load(bytes) # rubocop:disable Security/MarshalLoad
+        end
       rescue StandardError
-        MARSHAL_LOAD_FAILED
+        LOAD_FAILED
       end
 
-      def write_entry(path, descriptor, value)
+      def write_entry(path, descriptor, value, serialize: nil)
         FileUtils.mkdir_p(File.dirname(path))
 
         descriptor_bytes = descriptor.to_canonical_bytes
-        value_bytes = Marshal.dump(value).b
+        value_bytes = serialize_value(value, serialize)
 
         body = +"".b
         body << HEADER
@@ -190,6 +244,18 @@ module Rigor
         atomically_replace(path, body)
       end
 
+      def serialize_value(value, serialize)
+        return Marshal.dump(value).b if serialize.nil?
+
+        bytes = serialize.call(value)
+        unless bytes.is_a?(String)
+          raise TypeError,
+                "custom serialize must return a String, got #{bytes.class}"
+        end
+
+        bytes.b
+      end
+
       def atomically_replace(path, body)
         File.open(path, File::RDWR | File::CREAT, 0o644) do |lock_fd|
           lock_fd.flock(File::LOCK_EX)