rigortype 0.0.6 → 0.0.8

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/inference/expression_typer.rb

@@ -52,6 +52,12 @@ module Rigor
         # Literals
         Prism::IntegerNode => :type_of_literal_value,
         Prism::FloatNode => :type_of_literal_value,
+        # `1i` / `2.5ri` lift via `node.value` which is already a
+        # `Complex` Ruby value; same for `1r` / `1.5r` whose
+        # value is a `Rational`. `Type::Constant` accepts both
+        # via `SCALAR_CLASSES`.
+        Prism::ImaginaryNode => :type_of_literal_value,
+        Prism::RationalNode => :type_of_literal_value,
         Prism::SymbolNode => :symbol_type_for,
         Prism::StringNode => :string_type_for,
         Prism::TrueNode => :type_of_true,
@@ -401,7 +407,13 @@ module Rigor
       # so callers stay backward compatible.
       def type_of_hash(node)
         elements = node.respond_to?(:elements) ? node.elements : []
-        return Type::Combinator.nominal_of(Hash) if elements.empty?
+        # v0.0.7 — `{}` resolves to the empty `HashShape{}` carrier
+        # rather than `Nominal[Hash]`, mirroring the v0.0.6 empty-
+        # array literal change. Both forms erase to plain `Hash`,
+        # but `HashShape{}` pins the literal's known size (zero)
+        # so HashShape projections (`empty?`, `first`, `count`,
+        # …) fold against it.
+        return Type::Combinator.hash_shape_of({}) if elements.empty?
 
         shape = static_hash_shape_for(elements)
         return shape if shape
@@ -691,7 +703,18 @@ module Rigor
         Type::Combinator.constant_of(Range.new(left, right, node.exclude_end?))
       end
 
-      def type_of_regexp(_node)
+      # v0.0.7 — non-interpolated regex literals lift to
+      # `Constant<Regexp>` so `Constant<String>#scan(/regex/)`
+      # / `#match(/regex/)` etc. can fold through the catalog
+      # tier. Interpolated regexes (`/foo#{x}/`) reach the
+      # second `Prism::InterpolatedRegularExpressionNode` arm
+      # which keeps the conservative `Nominal[Regexp]` answer.
+      def type_of_regexp(node)
+        return Type::Combinator.nominal_of(Regexp) unless node.is_a?(Prism::RegularExpressionNode)
+
+        regex = Regexp.new(node.unescaped, node.options)
+        Type::Combinator.constant_of(regex)
+      rescue StandardError
         Type::Combinator.nominal_of(Regexp)
       end