rigortype 0.0.8 → 0.0.9

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 StandardError
+          # Skip entries whose RBS type fails to translate; the cache
+          # stays robust to a broken signature rather than corrupting
+          # the whole table.
         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,53 @@
+# frozen_string_literal: true
+
+require "digest"
+
+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_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

@@ -30,10 +30,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 +101,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 +146,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 +169,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 +179,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 +212,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 +242,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)

data/lib/rigor/cli.rb

@@ -72,13 +72,19 @@ module Rigor
 
       cache_root = ".rigor/cache"
       handle_clear_cache(cache_root) if options.fetch(:clear_cache)
+      cache_store = options.fetch(:no_cache) ? nil : Cache::Store.new(root: cache_root)
 
       configuration = Configuration.load(options.fetch(:config))
       paths = @argv.empty? ? configuration.paths : @argv
-      result = Analysis::Runner.new(configuration: configuration, explain: options.fetch(:explain)).run(paths)
+      runner = Analysis::Runner.new(
+        configuration: configuration,
+        explain: options.fetch(:explain),
+        cache_store: cache_store
+      )
+      result = runner.run(paths)
 
       write_result(result, options.fetch(:format))
-      write_cache_stats(cache_root) if options.fetch(:cache_stats)
+      write_cache_stats(cache_root, runner.cache_store) if options.fetch(:cache_stats)
       result.success? ? 0 : 1
     end
 
@@ -88,7 +94,8 @@ module Rigor
         format: "text",
         explain: false,
         cache_stats: false,
-        clear_cache: false
+        clear_cache: false,
+        no_cache: false
       }
       parser = OptionParser.new do |opts|
         opts.banner = "Usage: rigor check [options] [paths]"
@@ -97,6 +104,7 @@ module Rigor
         opts.on("--explain", "Surface fail-soft fallback events as :info diagnostics") { options[:explain] = true }
         opts.on("--cache-stats", "Print on-disk cache inventory at end of run") { options[:cache_stats] = true }
         opts.on("--clear-cache", "Remove the .rigor/cache directory before running") { options[:clear_cache] = true }
+        opts.on("--no-cache", "Disable the persistent cache for this run") { options[:no_cache] = true }
       end
       parser.parse!(@argv)
       options
@@ -111,13 +119,18 @@ module Rigor
       end
     end
 
-    def write_cache_stats(cache_root)
+    def write_cache_stats(cache_root, runtime_store)
       inv = Cache::Store.disk_inventory(root: cache_root)
 
       @out.puts("")
       @out.puts("Cache (root: #{inv.fetch(:root)})")
       schema = inv.fetch(:schema_version)
       @out.puts("  schema_version: #{schema.nil? ? 'absent' : schema}")
+      write_disk_inventory(inv)
+      write_runtime_stats(runtime_store) if runtime_store
+    end
+
+    def write_disk_inventory(inv)
       if inv.fetch(:total_entries).zero?
         @out.puts("  (empty)")
         return
@@ -130,6 +143,25 @@ module Rigor
       end
     end
 
+    def write_runtime_stats(store)
+      stats = store.stats
+      hits = stats.fetch(:hits)
+      misses = stats.fetch(:misses)
+      writes = stats.fetch(:writes)
+      @out.puts("  this run: #{hits} #{plural(hits, 'hit')}, " \
+                "#{misses} #{plural(misses, 'miss', 'misses')}, " \
+                "#{writes} #{plural(writes, 'write')}")
+      stats.fetch(:by_producer).each do |id, counts|
+        @out.puts("    #{id}: #{counts.fetch(:hits)} #{plural(counts.fetch(:hits), 'hit')}, " \
+                  "#{counts.fetch(:misses)} #{plural(counts.fetch(:misses), 'miss', 'misses')}, " \
+                  "#{counts.fetch(:writes)} #{plural(counts.fetch(:writes), 'write')}")
+      end
+    end
+
+    def plural(count, singular, plural = "#{singular}s")
+      count == 1 ? singular : plural
+    end
+
     def format_bytes(bytes)
       return "#{bytes} B" if bytes < 1024
       return format("%.1f KiB", bytes / 1024.0) if bytes < 1024 * 1024

data/lib/rigor/environment/rbs_hierarchy.rb

@@ -45,15 +45,28 @@ module Rigor
         key = normalize_name(class_name)
         return @ancestor_names_cache[key] if @ancestor_names_cache.key?(key)
 
-        definition = loader.instance_definition(key)
         @ancestor_names_cache[key] =
-          if definition
-            definition.ancestors.ancestors.map { |ancestor| normalize_name(ancestor.name.to_s) }.uniq.freeze
+          if loader.cache_store
+            ancestor_table.fetch(key, [].freeze)
           else
-            [].freeze
+            compute_ancestor_names(key)
           end
+      end
+
+      def compute_ancestor_names(key)
+        definition = loader.instance_definition(key)
+        return [].freeze if definition.nil?
+
+        definition.ancestors.ancestors.map { |ancestor| normalize_name(ancestor.name.to_s) }.uniq.freeze
       rescue StandardError
-        @ancestor_names_cache[key] = [].freeze
+        [].freeze
+      end
+
+      def ancestor_table
+        @ancestor_table ||= begin
+          require_relative "../cache/rbs_class_ancestor_table"
+          Cache::RbsClassAncestorTable.fetch(loader: loader, store: loader.cache_store)
+        end
       end
 
       def normalize_name(name)