rigortype 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0aa63fadd57282a307bf4664cce576c1b955617b6643c64d436827595a751ccb
-  data.tar.gz: 4e7cc6e58c5fcb45eb201182cbb87f723a558972334add650aecdeb80ed7c502
+  metadata.gz: 38aa66f97f5bed742a36c156ceee7f13d3181597b74c32329b693b3c219852b3
+  data.tar.gz: 69af0ccbf42c2b890b78a558d574b49293ff6b4880875568137098624e66d3f8
 SHA512:
-  metadata.gz: 9972f4ac5258340ab534ce5bd3aad4dfda7f23e080013f0f3fdc96d4ea0fb45c458cfa3c68e14b5e2b7ffdf273e7fa81f76d7d80761cd0a5b3b6291f903a5157
-  data.tar.gz: 3009bf4ab97ee163ec05fc262bbdc130dc5e5ebf877bea9b1e220f0607251d96bf81ad10e1f6505d2f2999e8f12bb6bb823577dd142645295e2fdc2fc7d29fe2
+  metadata.gz: 8a9e0ee0461e2f0b2779981fa95758e0b7b5bd02668254dc1cb2d82002565b383d866534edff6e75c53aa0a9ae2fdb59832a35788ccfda3cb4558982bed61b15
+  data.tar.gz: 9699b63098d16e1959177684a849923384196f0dac55a532a3a0ecdff77d45c76230c3b72a273f59ec237059127007d7bb1ae01be9c9cf8b9613a02033b89bb5

data/lib/rigor/analysis/diagnostic.rb

@@ -3,7 +3,12 @@
 module Rigor
   module Analysis
     class Diagnostic
-      attr_reader :path, :line, :column, :message, :severity, :rule
+      # The default source family. Matches the existing analyzer-
+      # internal rule families; serialised as `"builtin"` and is the
+      # baseline against which non-default families are recognised.
+      DEFAULT_SOURCE_FAMILY = :builtin
+
+      attr_reader :path, :line, :column, :message, :severity, :rule, :source_family
 
       # `rule:` is the stable identifier (a kebab-case string)
       # of the diagnostic's source rule. It is used by the
@@ -12,8 +17,16 @@ module Rigor
       # category. Diagnostics not produced by `CheckRules`
       # (parse errors, path errors, internal analyzer errors)
       # may leave `rule` as nil and stay unsuppressible.
+      #
+      # `source_family:` names the producer of the rule. The default
+      # `:builtin` covers analyzer-internal rules; future families
+      # like `:rbs_extended`, `:generated`, or `"plugin.<id>"` (per
+      # ADR-2 § "Plugin Diagnostic Provenance") let consumers
+      # distinguish where a diagnostic originated without committing
+      # to the plugin API itself.
       # rubocop:disable Metrics/ParameterLists
-      def initialize(path:, line:, column:, message:, severity: :error, rule: nil)
+      def initialize(path:, line:, column:, message:, severity: :error, rule: nil,
+                     source_family: DEFAULT_SOURCE_FAMILY)
         # rubocop:enable Metrics/ParameterLists
         @path = path
         @line = line
@@ -21,12 +34,24 @@ module Rigor
         @message = message
         @severity = severity
         @rule = rule
+        @source_family = source_family
       end
 
       def error?
         severity == :error
       end
 
+      # The fully-qualified rule identifier — `<source_family>.<rule>`
+      # when the source is non-default, or just `<rule>` for the
+      # `:builtin` family. Returns nil when `rule` itself is nil
+      # (e.g. parse errors and internal-analyzer errors).
+      def qualified_rule
+        return nil if rule.nil?
+        return rule if source_family == DEFAULT_SOURCE_FAMILY
+
+        "#{source_family}.#{rule}"
+      end
+
       def to_h
         {
           "path" => path,
@@ -34,6 +59,7 @@ module Rigor
           "column" => column,
           "severity" => severity.to_s,
           "rule" => rule,
+          "source_family" => source_family.to_s,
           "message" => message
         }
       end

data/lib/rigor/cache/descriptor.rb

@@ -0,0 +1,278 @@
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+
+module Rigor
+  module Cache
+    # Cache invalidation descriptor — the typed-slot schema fixed by
+    # [`docs/design/20260505-cache-slice-taxonomy.md`](../../../docs/design/20260505-cache-slice-taxonomy.md).
+    # Pure value object: no I/O, no global state, fully immutable
+    # after construction. The storage layer
+    # ([`Rigor::Cache::Store`](store.rb), v0.0.8 slice 2) consumes
+    # descriptors but does not extend them.
+    #
+    # The descriptor has four slots (`files`, `gems`, `plugins`,
+    # `configs`); every slot is an array of typed entries; an empty
+    # array means "no dependency in this slot". Composition unions
+    # by key per slot; conflicts on the comparison fields raise
+    # {Conflict}.
+    #
+    # See ADR-2 § "Registration, Configuration, and Caching" for
+    # the design rationale and ADR-6 for the storage backend
+    # decisions that consume this schema.
+    class Descriptor # rubocop:disable Metrics/ClassLength
+      # Bumped on incompatible schema changes. The storage layer
+      # mixes this into the cache key, so a bump implicitly
+      # invalidates every cached value.
+      SCHEMA_VERSION = 1
+
+      # Per-slot entry value objects. Constructors validate enums /
+      # required fields and freeze the resulting struct so no caller
+      # can mutate after the entry is in a Descriptor.
+
+      class FileEntry
+        VALID_COMPARATORS = %i[digest mtime exists].freeze
+
+        attr_reader :path, :comparator, :value
+
+        def initialize(path:, comparator:, value:)
+          unless VALID_COMPARATORS.include?(comparator)
+            raise ArgumentError,
+                  "FileEntry comparator must be one of #{VALID_COMPARATORS.inspect}, got #{comparator.inspect}"
+          end
+
+          @path = path.to_s.dup.freeze
+          @comparator = comparator
+          @value = value.to_s.dup.freeze
+          freeze
+        end
+
+        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
+        attr_reader :name, :requirement, :locked
+
+        def initialize(name:, requirement:, locked: nil)
+          @name = name.to_s.dup.freeze
+          @requirement = requirement.to_s.dup.freeze
+          @locked = locked.nil? ? nil : locked.to_s.dup.freeze
+          freeze
+        end
+
+        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
+        attr_reader :id, :version, :config_hash
+
+        def initialize(id:, version:, config_hash: nil)
+          @id = id.to_s.dup.freeze
+          @version = version.to_s.dup.freeze
+          @config_hash = config_hash.nil? ? nil : config_hash.to_s.dup.freeze
+          freeze
+        end
+
+        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
+        attr_reader :key, :value_hash
+
+        def initialize(key:, value_hash:)
+          @key = key.to_s.dup.freeze
+          @value_hash = value_hash.to_s.dup.freeze
+          freeze
+        end
+
+        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
+
+      # Raised when {.compose} encounters incompatible entries
+      # under the same key (file digest mismatch, gem-locked
+      # disagreement, …). Callers handle the exception by
+      # invalidating the cache slice rather than choosing one
+      # contribution silently.
+      class Conflict < StandardError; end
+
+      attr_reader :files, :gems, :plugins, :configs
+
+      def initialize(files: [], gems: [], plugins: [], configs: [])
+        @files = files.dup.freeze
+        @gems = gems.dup.freeze
+        @plugins = plugins.dup.freeze
+        @configs = configs.dup.freeze
+        freeze
+      end
+
+      # File-comparator strictness ordering. `:digest` is strictest
+      # (deterministic across machines); `:mtime` is cheaper but
+      # local; `:exists` is the weakest signal. When two
+      # contributors disagree on the comparator for the same
+      # `path`, the stricter one wins.
+      COMPARATOR_STRICTNESS = { digest: 2, mtime: 1, exists: 0 }.freeze
+      private_constant :COMPARATOR_STRICTNESS
+
+      # Composes any number of descriptors into a single descriptor
+      # whose slots are the union of the inputs' slots. Conflicts
+      # raise {Conflict}; idempotent contributions (same key, same
+      # value) collapse to a single entry.
+      def self.compose(*descriptors)
+        return new if descriptors.empty?
+
+        files = compose_files(descriptors.flat_map(&:files))
+        gems = compose_by_key(descriptors.flat_map(&:gems), :name)
+        plugins = compose_by_key(descriptors.flat_map(&:plugins), :id)
+        configs = compose_by_key(descriptors.flat_map(&:configs), :key)
+        new(files: files, gems: gems, plugins: plugins, configs: configs)
+      end
+
+      # @param producer_id [String]
+      # @param params [Hash] inputs the producer was called with
+      # @return [String] hex SHA-256 cache key for the value
+      def cache_key_for(producer_id:, params: {})
+        payload = {
+          "schema_version" => SCHEMA_VERSION,
+          "producer_id" => producer_id.to_s,
+          "params" => self.class.canonicalize_value(params),
+          "descriptor" => to_canonical_hash
+        }
+        Digest::SHA256.hexdigest(JSON.generate(payload))
+      end
+
+      # Canonical UTF-8 JSON serialisation. Slots appear in
+      # lexicographic order; entries are sorted by their key field
+      # so two equivalent descriptors produce identical bytes.
+      def to_canonical_bytes
+        JSON.generate(to_canonical_hash).b
+      end
+
+      def to_canonical_hash
+        {
+          "configs" => sort_entries(configs, "key").map(&:to_h),
+          "files" => sort_entries(files, "path").map(&:to_h),
+          "gems" => sort_entries(gems, "name").map(&:to_h),
+          "plugins" => sort_entries(plugins, "id").map(&:to_h)
+        }
+      end
+
+      def ==(other)
+        other.is_a?(Descriptor) &&
+          to_canonical_bytes == other.to_canonical_bytes
+      end
+      alias eql? ==
+
+      def hash
+        to_canonical_bytes.hash
+      end
+
+      class << self
+        # Recursively coerces a Ruby value into a JSON-canonical
+        # structure: hash keys are stringified and sorted; arrays
+        # preserve order; symbols stringify; everything else is
+        # JSON-renderable.
+        def canonicalize_value(value)
+          case value
+          when Hash
+            value.to_a.map { |k, v| [k.to_s, canonicalize_value(v)] }.sort_by(&:first).to_h
+          when Array
+            value.map { |v| canonicalize_value(v) }
+          when Symbol
+            value.to_s
+          else
+            value
+          end
+        end
+      end
+
+      private
+
+      def sort_entries(entries, key)
+        entries.sort_by { |e| e.to_h.fetch(key).to_s }
+      end
+
+      def self.compose_by_key(entries, key)
+        grouped = entries.group_by { |e| e.public_send(key) }
+        grouped.map do |_k, group|
+          unique = group.uniq
+          if unique.size == 1
+            unique.first
+          else
+            raise Conflict,
+                  "cache descriptor conflict on #{key}=#{group.first.public_send(key).inspect}: " \
+                  "got #{unique.size} incompatible entries"
+          end
+        end
+      end
+      private_class_method :compose_by_key
+
+      def self.compose_files(entries)
+        grouped = entries.group_by(&:path)
+        grouped.map do |path, group|
+          merge_file_group(path, group)
+        end
+      end
+      private_class_method :compose_files
+
+      def self.merge_file_group(path, group)
+        strictest_rank = group.map { |e| COMPARATOR_STRICTNESS.fetch(e.comparator) }.max
+        strictest = group.select { |e| COMPARATOR_STRICTNESS.fetch(e.comparator) == strictest_rank }
+        values = strictest.map(&:value).uniq
+        unless values.size == 1
+          raise Conflict,
+                "cache descriptor conflict on file=#{path.inspect}: " \
+                "got #{values.size} disagreeing values under the stricter comparator"
+        end
+
+        strictest.first
+      end
+      private_class_method :merge_file_group
+    end
+  end
+end

data/lib/rigor/cache/rbs_constant_table.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Rigor
+  module Cache
+    # Cache producer that materialises every RBS-declared constant
+    # to its translated `Rigor::Type` form and stores the result as
+    # a `Hash<String, Rigor::Type>` keyed by canonical constant name.
+    # This is the v0.0.8 first cached producer per ADR-6 § 7; it
+    # caches a post-translation artefact so the cache value is
+    # `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.
+    class RbsConstantTable
+      PRODUCER_ID = "rbs.constant_type_table"
+
+      # @param loader [Rigor::Environment::RbsLoader]
+      # @param store [Rigor::Cache::Store]
+      # @return [Hash{String => Rigor::Type}]
+      def self.fetch(loader:, store:)
+        descriptor = build_descriptor(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?
+        end
+      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
+    end
+  end
+end

data/lib/rigor/cache/store.rb

@@ -0,0 +1,261 @@
+# frozen_string_literal: true
+
+require "digest"
+require "fileutils"
+require "json"
+require "securerandom"
+
+module Rigor
+  module Cache
+    # Filesystem-backed cache store. Schema, layout, file format,
+    # atomicity, and locking are fixed by [ADR-6](../../../docs/adr/6-cache-persistence-backend.md);
+    # callers see the [`Rigor::Cache::Descriptor`](descriptor.rb)
+    # value object plus this class' `#fetch_or_compute` entry point
+    # and nothing else.
+    #
+    # Read failures (missing file, bad magic, format-version mismatch,
+    # corrupt SHA-256 trailer, unmarshal-able payload) are silently
+    # treated as cache misses; the producer block reruns and the
+    # next write replaces the bad entry. The trailing SHA-256 catches
+    # accidental corruption (partial writes, FS errors); it is **not**
+    # a security boundary, per ADR-2's trusted-gem trust model.
+    class Store # rubocop:disable Metrics/ClassLength
+      # Header literal: 5-byte ASCII magic, 1-byte separator, 1-byte
+      # format version. Bumped on incompatible on-disk format changes
+      # (independent of {Descriptor::SCHEMA_VERSION}, which covers
+      # the descriptor schema rather than the byte layout).
+      HEADER = "RIGOR\x00\x01".b.freeze
+
+      VALID_PRODUCER_ID = /\A[a-z][a-z0-9._-]*\z/
+
+      def initialize(root:)
+        @root = root.to_s.dup.freeze
+      end
+
+      attr_reader :root
+
+      # 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
+      # depending on in-process counters (which only reflect the
+      # current run).
+      #
+      # @return [Hash] `{ root:, schema_version:, total_entries:,
+      #   total_bytes:, producers: [{ id:, entries:, bytes: }, ...] }`.
+      #   When the root does not exist or has no schema-version
+      #   marker, `schema_version` is nil and the producer list is
+      #   empty.
+      def self.disk_inventory(root:)
+        root_s = root.to_s
+        marker = File.join(root_s, "schema_version.txt")
+        schema = File.file?(marker) ? File.read(marker).strip : nil
+
+        producers = collect_producers(root_s)
+        total_entries = producers.sum { |p| p[:entries] }
+        total_bytes = producers.sum { |p| p[:bytes] }
+
+        {
+          root: root_s,
+          schema_version: schema,
+          total_entries: total_entries,
+          total_bytes: total_bytes,
+          producers: producers
+        }
+      end
+
+      def self.collect_producers(root)
+        return [] unless File.directory?(root)
+
+        Dir.children(root).sort.filter_map do |child|
+          subdir = File.join(root, child)
+          next nil unless File.directory?(subdir)
+
+          entries = Dir.glob(File.join(subdir, "**", "*.entry"))
+          next nil if entries.empty?
+
+          { id: child, entries: entries.size, bytes: entries.sum { |e| File.size(e) } }
+        end
+      end
+      private_class_method :collect_producers
+
+      # @param producer_id [String] stable cache namespace; only
+      #   `[a-z][a-z0-9._-]*` is accepted.
+      # @param params [Hash] producer inputs; mixed into the cache key
+      #   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).
+      # @return the cached value (loaded from disk on hit; produced by
+      #   the block on miss).
+      def fetch_or_compute(producer_id:, params:, descriptor:, &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?
+
+        value = block.call
+        write_entry(path, descriptor, value)
+        value
+      end
+
+      private
+
+      Entry = Data.define(:descriptor_bytes, :value)
+      private_constant :Entry
+
+      def validate_producer_id!(producer_id)
+        return if producer_id.is_a?(String) && producer_id.match?(VALID_PRODUCER_ID)
+
+        raise ArgumentError,
+              "producer_id must match #{VALID_PRODUCER_ID.inspect}, got #{producer_id.inspect}"
+      end
+
+      def entry_path(producer_id, key)
+        File.join(@root, producer_id, key[0, 2], "#{key[2..]}.entry")
+      end
+
+      # 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)
+        return nil unless File.file?(path)
+
+        bytes = File.binread(path)
+        return nil unless envelope_valid?(bytes)
+
+        body = bytes.byteslice(HEADER.bytesize, bytes.bytesize - HEADER.bytesize - 32)
+        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)
+
+        Entry.new(descriptor_bytes, value)
+      end
+
+      # Validates the magic + format-version header and the trailing
+      # SHA-256 over everything before the trailer.
+      def envelope_valid?(bytes)
+        return false if bytes.bytesize < HEADER.bytesize + 32
+        return false unless bytes.byteslice(0, HEADER.bytesize) == HEADER
+
+        trailer = bytes.byteslice(bytes.bytesize - 32, 32)
+        Digest::SHA256.digest(bytes.byteslice(0, bytes.bytesize - 32)) == trailer
+      end
+
+      # Splits the body into (descriptor_bytes, value_bytes). Returns
+      # `[nil, nil]` on a malformed varint or length-overrun.
+      def parse_body(body)
+        offset = 0
+        descriptor_len, offset = read_varint(body, offset)
+        return [nil, nil] if descriptor_len.nil? || offset + descriptor_len > body.bytesize
+
+        descriptor_bytes = body.byteslice(offset, descriptor_len)
+        offset += descriptor_len
+
+        value_len, offset = read_varint(body, offset)
+        return [nil, nil] if value_len.nil? || offset + value_len != body.bytesize
+
+        value_bytes = body.byteslice(offset, value_len)
+        [descriptor_bytes, value_bytes]
+      end
+
+      MARSHAL_LOAD_FAILED = Object.new.freeze
+      private_constant :MARSHAL_LOAD_FAILED
+
+      def safe_marshal_load(bytes)
+        Marshal.load(bytes) # rubocop:disable Security/MarshalLoad
+      rescue StandardError
+        MARSHAL_LOAD_FAILED
+      end
+
+      def write_entry(path, descriptor, value)
+        FileUtils.mkdir_p(File.dirname(path))
+
+        descriptor_bytes = descriptor.to_canonical_bytes
+        value_bytes = Marshal.dump(value).b
+
+        body = +"".b
+        body << HEADER
+        write_varint(body, descriptor_bytes.bytesize)
+        body << descriptor_bytes
+        write_varint(body, value_bytes.bytesize)
+        body << value_bytes
+        body << Digest::SHA256.digest(body)
+
+        atomically_replace(path, body)
+      end
+
+      def atomically_replace(path, body)
+        File.open(path, File::RDWR | File::CREAT, 0o644) do |lock_fd|
+          lock_fd.flock(File::LOCK_EX)
+          tmp = "#{path}.tmp.#{Process.pid}.#{SecureRandom.hex(4)}"
+          File.open(tmp, "wb") do |f|
+            f.write(body)
+            f.fsync
+          end
+          File.rename(tmp, path)
+        end
+      end
+
+      def ensure_schema_version!
+        FileUtils.mkdir_p(@root)
+        marker = File.join(@root, "schema_version.txt")
+        current = Descriptor::SCHEMA_VERSION.to_s
+
+        if File.file?(marker)
+          on_disk = File.read(marker).strip
+          return if on_disk == current
+
+          clear_cache_root!
+        end
+
+        FileUtils.mkdir_p(@root)
+        File.write(marker, "#{current}\n")
+      end
+
+      def clear_cache_root!
+        Dir.children(@root).each do |entry|
+          FileUtils.rm_rf(File.join(@root, entry))
+        end
+      end
+
+      # LEB128 unsigned varint encoder/decoder. Lengths fit easily in
+      # five bytes (cap at 2^35); the cache layer never writes a value
+      # larger than that in practice.
+      def write_varint(bytes, value)
+        raise ArgumentError, "varint must be non-negative" if value.negative?
+
+        loop do
+          if value < 0x80
+            bytes << [value].pack("C")
+            return
+          end
+
+          bytes << [(value & 0x7F) | 0x80].pack("C")
+          value >>= 7
+        end
+      end
+
+      def read_varint(bytes, offset)
+        result = 0
+        shift = 0
+        loop do
+          return [nil, offset] if offset >= bytes.bytesize
+
+          byte = bytes.getbyte(offset)
+          offset += 1
+          result |= (byte & 0x7F) << shift
+          return [result, offset] if byte < 0x80
+
+          shift += 7
+          return [nil, offset] if shift > 35
+        end
+      end
+    end
+  end
+end

data/lib/rigor/cli.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "fileutils"
 require "json"
 require "optionparser"
 require "yaml"
@@ -65,27 +66,75 @@ module Rigor
 
     def run_check
       require_relative "analysis/runner"
+      require_relative "cache/store"
 
+      options = parse_check_options
+
+      cache_root = ".rigor/cache"
+      handle_clear_cache(cache_root) if options.fetch(:clear_cache)
+
+      configuration = Configuration.load(options.fetch(:config))
+      paths = @argv.empty? ? configuration.paths : @argv
+      result = Analysis::Runner.new(configuration: configuration, explain: options.fetch(:explain)).run(paths)
+
+      write_result(result, options.fetch(:format))
+      write_cache_stats(cache_root) if options.fetch(:cache_stats)
+      result.success? ? 0 : 1
+    end
+
+    def parse_check_options
       options = {
         config: Configuration::DEFAULT_PATH,
         format: "text",
-        explain: false
+        explain: false,
+        cache_stats: false,
+        clear_cache: false
       }
-
       parser = OptionParser.new do |opts|
         opts.banner = "Usage: rigor check [options] [paths]"
         opts.on("--config=PATH", "Path to the Rigor configuration file") { |value| options[:config] = value }
         opts.on("--format=FORMAT", "Output format: text or json") { |value| options[:format] = value }
         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 }
       end
       parser.parse!(@argv)
+      options
+    end
 
-      configuration = Configuration.load(options.fetch(:config))
-      paths = @argv.empty? ? configuration.paths : @argv
-      result = Analysis::Runner.new(configuration: configuration, explain: options.fetch(:explain)).run(paths)
+    def handle_clear_cache(cache_root)
+      if File.directory?(cache_root)
+        FileUtils.rm_rf(cache_root)
+        @out.puts("Cleared cache: #{cache_root}")
+      else
+        @out.puts("Cache already empty: #{cache_root}")
+      end
+    end
 
-      write_result(result, options.fetch(:format))
-      result.success? ? 0 : 1
+    def write_cache_stats(cache_root)
+      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}")
+      if inv.fetch(:total_entries).zero?
+        @out.puts("  (empty)")
+        return
+      end
+
+      @out.puts("  #{inv.fetch(:total_entries)} entries, #{format_bytes(inv.fetch(:total_bytes))}")
+      inv.fetch(:producers).each do |producer|
+        bytes = format_bytes(producer.fetch(:bytes))
+        @out.puts("    #{producer.fetch(:id)}: #{producer.fetch(:entries)} entries, #{bytes}")
+      end
+    end
+
+    def format_bytes(bytes)
+      return "#{bytes} B" if bytes < 1024
+      return format("%.1f KiB", bytes / 1024.0) if bytes < 1024 * 1024
+
+      format("%.1f MiB", bytes / (1024.0 * 1024.0))
     end
 
     def run_init

data/lib/rigor/environment/rbs_loader.rb

@@ -144,6 +144,17 @@ module Rigor
         @hierarchy.class_ordering(lhs, rhs)
       end
 
+      # @return [Array<String>] every RBS-declared constant name
+      #   (top-level prefixed, e.g., `"::Math::PI"`) currently loaded
+      #   into the environment. Used by the cache producer that
+      #   materialises the constant-type table; ordinary callers
+      #   should keep using {#constant_type} for point lookups.
+      def constant_names
+        env.constant_decls.keys.map(&:to_s)
+      rescue StandardError
+        []
+      end
+
       # Slice A constant-value lookup. Returns the translated
       # `Rigor::Type` for a non-class constant declaration
       # (`BUCKETS: Array[Symbol]`, `DEFAULT_PATH: String`, ...) or

data/lib/rigor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rigor
-  VERSION = "0.0.7"
+  VERSION = "0.0.8"
 end

data/lib/rigor.rb

@@ -19,6 +19,9 @@ require_relative "rigor/inference/closure_escape_analyzer"
 require_relative "rigor/inference/statement_evaluator"
 require_relative "rigor/scope"
 require_relative "rigor/reflection"
+require_relative "rigor/cache/descriptor"
+require_relative "rigor/cache/store"
+require_relative "rigor/cache/rbs_constant_table"
 require_relative "rigor/source"
 require_relative "rigor/inference/scope_indexer"
 require_relative "rigor/inference/coverage_scanner"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rigortype
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - Rigor contributors
@@ -185,6 +185,9 @@ files:
 - lib/rigor/ast.rb
 - lib/rigor/ast/type_node.rb
 - lib/rigor/builtins/imported_refinements.rb
+- lib/rigor/cache/descriptor.rb
+- lib/rigor/cache/rbs_constant_table.rb
+- lib/rigor/cache/store.rb
 - lib/rigor/cli.rb
 - lib/rigor/cli/type_of_command.rb
 - lib/rigor/cli/type_of_renderer.rb