rigortype 0.4.6 → 0.4.7

data/lib/rigor/cache/incremental_snapshot.rb

@@ -8,6 +8,7 @@ require_relative "engine_source"
 require_relative "store"
 require_relative "../analysis/shadow_harness"
 require_relative "../analysis/run_cache_key"
+require_relative "../analysis/runner/run_level_facts"
 require_relative "../environment"
 require_relative "../analysis/path_expansion"
 require_relative "../rooted_glob"
@@ -195,20 +196,26 @@ module Rigor
       # 45: issue #1154 — each seed bundle's `global_write_census` also records the ivar writers the declared-parameter
       # credit reads (`[:ivar_set, name]`, `[:ivar_set_class, class]`, `[:own_write, class, name, path]`), which a
       # pre-45 bundle carries none of, so a warm run would credit an ivar write a cold run declines.
-      SCHEMA = 45
+      # 46: issue #2314 — each seed bundle's `global_write_census` also records the global writers
+      # (`[:global_writer, name, method]`) the statement walk reads past a call; a pre-46 bundle carries none, so a
+      # warm run would keep a global's binding a cold run forgets.
+      # 47: issues #2079 / #2170 — each seed bundle's `global_write_census` also records each instance-side ivar
+      # write's coarse value (`[:own_write_type, class, name, value, path]`), which the class-ivar census joins across
+      # files and along the chain; a pre-47 bundle carries none, so a warm run would keep a seed a cold run widens.
+      SCHEMA = 47
 
       # The persisted per-file state.
       # `cache` maps an analyzed file to its diagnostics.
-      # `sources` maps a consumer to the Set of source files it read from.
+      # `sources` maps a consumer to the source files it read from.
       # `digests` maps a file to its content digest at analysis time.
       # `analyzed` is the ordered analyzed-file list.
       # ADR-46 slice 4:
-      # `symbol_sources` maps a consumer to { source_path → Set<"ClassName#method"> }.
-      # `ancestry_sources` maps a consumer to Set<source_path> (class-ancestry deps).
+      # `symbol_sources` maps a consumer to { source_path → the "ClassName#method" names it read }.
+      # `ancestry_sources` maps a consumer to the source paths it read for class ancestry.
       # `symbol_fingerprints` maps a path to { "ClassName#method" => sha256_hex }.
       # ADR-46 slice 3:
-      # `missing` maps a consumer to Set<"kind:name"> it looked up and missed.
-      # `class_decls` maps a path to Set<qualified class name> it declares.
+      # `missing` maps a consumer to the "kind:name" keys it looked up and missed.
+      # `class_decls` maps a path to the qualified class names it declares.
       # Issue #644:
       # `constant_decls` maps a path to that file's constant PUBLICATION CENSUS,
       # `{qualified name => [literal] | :unpublishable}`. The descriptor is what the recheck diffs: a name's
@@ -279,12 +286,14 @@ module Rigor
         end
       end
 
-      # Issues #796 / #794 — the two run-level rows the snapshot carries. `definition_build_failures` is the
-      # reported per-class detail list ({Environment::RbsLoader#definition_build_failures}); `hkt_scan_failure`
-      # is the `[error_class, first_line, frame, stage]` tuple ({Rigor::Environment#hkt_scan_failure}), nil
-      # when the scan succeeded — which is why the presence of this object, not the tuple, is what says a
-      # replay is available.
-      RunLevelRows = Data.define(:definition_build_failures, :hkt_scan_failure)
+      # Issues #796 / #794 — the run-level rows the snapshot carries: one member per run-level fact declared
+      # `replay` ({Analysis::Runner::RunLevelFacts}, ADR-116 WD3). Today that is `definition_build_failures`,
+      # the reported per-class detail list ({Environment::RbsLoader#definition_build_failures}), and
+      # `hkt_scan_failure`, the `[error_class, first_line, frame, stage]` tuple
+      # ({Rigor::Environment#hkt_scan_failure}), nil when the scan succeeded — which is why the presence of
+      # this object, not the tuple, is what says a replay is available. Declaring another fact `replay`
+      # changes this shape, so it bumps {SCHEMA}.
+      RunLevelRows = Data.define(*Analysis::Runner::RunLevelFacts.replayable_names)
 
       # The global fingerprint that gates a snapshot load: a digest of the inputs whose change requires a full
       # rebuild — the engine version + schema, the engine's own SOURCE when the version does not pin it, the
@@ -324,6 +333,7 @@ module Rigor
           "sig:#{digest_signature_paths(project_sig_roots(configuration))}",
           "pre_eval:#{digest_pre_eval(configuration.pre_eval)}"
         ]
+        parts.concat(core_root_parts(configuration))
         parts.concat(dependency_source_parts(configuration))
         identity = EngineSource.process_identity
         parts << "engine-source:#{identity}" if identity
@@ -347,6 +357,15 @@ module Rigor
         nil
       end
 
+      # Issue #2517 — a selected core is read like the project's own `sig/`, so an edit in place to one of its files
+      # must drop the snapshot (and the language server's session, which keys on this fingerprint). No part for the
+      # default core, so every other project's fingerprint is as it was.
+      def self.core_root_parts(configuration)
+        core_root = configuration.core_root
+        core_root.nil? ? [] : ["core:#{digest_signature_paths([core_root])}"]
+      end
+      private_class_method :core_root_parts
+
       def self.required_features(configuration, roots)
         files = Analysis::PathExpansion.ruby_files(roots, configuration.exclude_patterns,
                                                    base: configuration.exclude_base)

data/lib/rigor/cache/rbs_cache_producer.rb

@@ -6,8 +6,8 @@ module Rigor
   module Cache
     # Base for the RBS-derived cache producers.
     #
-    # Every producer (`RbsKnownClassNames`, `RbsConstantTable`, `RbsEnvironment`, the ancestor / type-param /
-    # definition tables, …) repeated the identical `fetch` wiring: build the RBS descriptor, then
+    # Every producer (`RbsKnownClassNames`, `RbsConstantTable`, `RbsEnvironment`, the ancestor / type-param
+    # tables, …) repeated the identical `fetch` wiring: build the RBS descriptor, then
     # `store.fetch_or_compute` under the producer's id, yielding to the producer's `compute`. Only the
     # `PRODUCER_ID` constant and the `compute(loader)` body actually differ between producers.
     #

data/lib/rigor/cache/rbs_class_ancestor_table.rb

@@ -6,7 +6,7 @@ require_relative "rbs_cache_producer"
 module Rigor
   module Cache
     # Cache producer that materialises the RBS-declared ancestor chain of every loaded class / module into a
-    # Marshal-clean `Hash<String, Array<String>>`. Ancestor names are top-level-stripped (e.g. `"Integer"` not
+    # Marshal-clean table. Ancestor names are top-level-stripped (e.g. `"Integer"` not
     # `"::Integer"`) to match `Environment::RbsHierarchy#normalize_name`.
     #
     # The hierarchy is the substrate behind every `class_ordering` query, which is itself a hot path on the

data/lib/rigor/cache/rbs_class_type_param_names.rb

@@ -6,8 +6,8 @@ require_relative "rbs_cache_producer"
 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"`.
+    # Marshal-clean table keyed by top-level-stripped class name (e.g. `"Array"` →
+    # `[:Elem]`, `"Hash"` → `[:K, :V]`).
     #
     # 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.

data/lib/rigor/cache/rbs_constant_table.rb

@@ -6,7 +6,7 @@ require_relative "rbs_cache_producer"
 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
+    # stores the result as a table 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`).
     #

data/lib/rigor/cache/rbs_descriptor.rb

@@ -77,9 +77,57 @@ module Rigor
       # reconstructs {.config_entries} without loading a plugin, so an entry there that it cannot rebuild
       # would turn the warm fast lane into a permanent miss on every project that enables a bundled plugin.
       def self.env_only_config_entries(loader)
-        [deferred_signature_paths_entry(loader)].compact
+        [deferred_signature_paths_entry(loader), project_signature_paths_entry(loader), core_root_entry(loader)].compact
       end
 
+      # Issue #2517 — which directory the env loaded core from. The selected core's files are digested by
+      # {.file_entries} too, so this row is the identity of the choice and those rows its contents: switching
+      # between two roots with byte-identical files still re-keys. Absent for the default core, whose identity
+      # is the `rbs` gem row, so every project without the setting keeps its key.
+      def self.core_root_entry(loader)
+        core_root = selected_core_root(loader)
+        return nil if core_root.nil?
+
+        Descriptor::ConfigEntry.new(key: "rbs.core_root", value_hash: Digest::SHA256.hexdigest(core_root.to_s))
+      end
+
+      private_class_method :core_root_entry
+
+      # The loader's issue #2517 core root as a Pathname, or nil for the default core.
+      def self.selected_core_root(loader)
+        core_root = loader.respond_to?(:core_root) ? loader.core_root : nil
+        core_root.nil? ? nil : Pathname(core_root)
+      end
+
+      private_class_method :selected_core_root
+
+      # {.selected_core_root} as the signature roots it adds: none for the default core.
+      def self.core_root_dirs(loader)
+        core_root = selected_core_root(loader)
+        core_root.nil? ? [] : [core_root]
+      end
+
+      private_class_method :core_root_dirs
+
+      # Issue #2422 — which of the loader's `signature_paths:` are the project's own changes the env built from
+      # byte-identical files: a bundled plugin's method composes with another source's as an overload, but stands
+      # down to the project's own. Only read when a plugin defers signatures, so a project without one keeps its
+      # key.
+      def self.project_signature_paths_entry(loader)
+        return nil unless loader.respond_to?(:project_signature_paths) && loader.respond_to?(:deferred_signature_paths)
+        return nil if Array(loader.deferred_signature_paths).empty?
+
+        own = Array(loader.project_signature_paths).map(&:to_s).sort
+        return nil if own.empty?
+
+        Descriptor::ConfigEntry.new(
+          key: "rbs.project_signature_paths",
+          value_hash: Digest::SHA256.hexdigest(own.join("\n"))
+        )
+      end
+
+      private_class_method :project_signature_paths_entry
+
       def self.deferred_signature_paths_entry(loader)
         return nil unless loader.respond_to?(:deferred_signature_paths)
 
@@ -104,7 +152,9 @@ module Rigor
       #   value must be deterministic; `:stat` (ADR-87 WD1) for the validation-only run-dependency descriptor
       #   ({RunDescriptor#files}), where the stat tier short-circuits the SHA-256 on an unmoved file.
       def self.file_entries(loader, comparator: :digest)
-        roots = loader.signature_paths +
+        # Issue #2517 — a selected core is project input like `signature_paths:`, not the engine-versioned `rbs`
+        # gem tree, so an edit in place must move the key.
+        roots = core_root_dirs(loader) + loader.signature_paths +
                 Rigor::Environment::RbsLoader.vendored_gem_sig_paths +
                 Rigor::Environment::RbsLoader.core_overlay_sig_paths +
                 Rigor::Environment::RbsLoader.capability_role_sig_paths
@@ -149,7 +199,8 @@ module Rigor
       def self.glob_entries(loader)
         # Deduplicated by path: a root reachable twice (an explicit `signature_paths:` entry that is also a
         # bundled plugin's `sig/`, #610) would otherwise contribute two rows whose stat signatures race.
-        loader.signature_paths.uniq(&:to_s).filter_map do |root|
+        # Issue #2517 — and the selected core's root, where a file appearing is as much a new input.
+        (core_root_dirs(loader) + loader.signature_paths).uniq(&:to_s).filter_map do |root|
           next unless root.directory?
 
           Descriptor::GlobEntry.compute(root: root.to_s, pattern: File.join("**", "*.rbs"), mode: :names)

data/lib/rigor/cache/rbs_environment.rb

@@ -33,7 +33,10 @@ module Rigor
           signature_paths: loader.signature_paths,
           virtual_rbs: loader.respond_to?(:virtual_rbs) ? loader.virtual_rbs : [],
           deferred_signature_paths:
-            loader.respond_to?(:deferred_signature_paths) ? loader.deferred_signature_paths : []
+            loader.respond_to?(:deferred_signature_paths) ? loader.deferred_signature_paths : [],
+          project_signature_paths:
+            loader.respond_to?(:project_signature_paths) ? loader.project_signature_paths : [],
+          core_root: loader.respond_to?(:core_root) ? loader.core_root : nil
         )
       end
 

data/lib/rigor/cache/rbs_environment_marshal_patch.rb

@@ -53,8 +53,8 @@ require_relative "annotation_location"
 #   differently, and only the latter reaches `marshal_load`), so without the bump a stale blob would keep
 #   reporting the moved position indefinitely.
 #
-# 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.
+# Idempotent: each hook is defined only when `method_defined?` reports it missing, so requiring this file twice
+# (or against an upstream rbs that adds Marshal hooks itself) is a no-op.
 #
 # `RBS::TypeName` / `RBS::Namespace` carry a second, subtler Marshal hazard, introduced by rbs 4.1's
 # flyweight interning (ruby/rbs#2957): both memoise their `#hash` into an `@hash` ivar, and that value is

data/lib/rigor/cache/rbs_known_class_names.rb

@@ -7,7 +7,7 @@ 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>`.
+    # Set of names.
     #
     # 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

data/lib/rigor/cache/store.rb

@@ -135,14 +135,6 @@ module Rigor
         end
       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 depending on
-      # in-process counters (which only reflect the current run).
-      #
-      # @return `{ 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.
-      #
       # The `schema_version.txt` marker content. Covers BOTH invalidation axes: the descriptor schema and the
       # on-disk byte layout ({FORMAT_VERSION}, ADR-54). A format bump leaves the old entries permanently
       # unreadable (header mismatch → miss) but, alone, would never reclaim their bytes — they can sit below
@@ -152,6 +144,13 @@ module Rigor
         "#{PAYLOAD_ABI_VERSION}.#{Descriptor::SCHEMA_VERSION}.#{FORMAT_VERSION}"
       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 depending on
+      # in-process counters (which only reflect the current run).
+      #
+      # @return `{ 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")
@@ -360,7 +359,8 @@ module Rigor
       # size-based LRU pass below stays gated on `max_bytes:` being configured: it walks all remaining
       # `.entry` files, sorts by mtime ascending (oldest = least recently used), and unlinks from the oldest
       # until the total is at or below the cap. Touch-on-disk-read ({read_entry}) is the cross-process LRU
-      # signal: every disk hit (not in-process-memo hit) updates the mtime so recently-read entries survive
+      # signal: a disk hit (not an in-process-memo hit) updates the mtime when `max_bytes:` is set, so
+      # recently-read entries survive
       # the eviction pass. Any FS error is swallowed — eviction must never break a run.
       def evict!
         return if @read_only
@@ -591,7 +591,8 @@ module Rigor
       # — one check per Store is enough; a benign double-check under a thread race would just repeat
       # idempotent work.
       #
-      # A writable store clears the cache root and rewrites the marker on a stale/missing marker, then reports
+      # A writable store clears the cache root and rewrites the marker on a stale marker (a missing or empty
+      # one is rewritten without clearing), then reports
       # available. A read-only store never touches the root — no mkdir, no marker write, no destructive clear
       # — so it reports available ONLY when the on-disk marker already matches current exactly; a stale or
       # missing marker (e.g. a Rigor upgrade with no writable run yet, as in LSP / editor mode) reports

data/lib/rigor/ci_detector.rb

@@ -20,7 +20,7 @@ module Rigor
   # non-CLI consumers exist: {Configuration#cache_validation_strict?} resolves the `auto` cache-validation default
   # through it (a fresh CI checkout regenerates every stat tuple, so ADR-87's stat tier cannot work there).
   # Detection is fully testable; callers pass `ENV`.
-  # `RIGOR_CI_DETECT=0` (or `false`/`no`) disables it globally — the seam the spec suite uses for determinism.
+  # `RIGOR_CI_DETECT=0` (or `false`/`no`/`off`) disables it globally — the seam the spec suite uses for determinism.
   module CiDetector
     Platform = Struct.new(:id, :name, :format, :tier, keyword_init: true) do
       def native_stdout? = tier == :native_stdout

data/lib/rigor/cli/annotate_command.rb

@@ -16,6 +16,7 @@ require_relative "../inference/statement_evaluator"
 require_relative "prism_colorizer"
 require_relative "command"
 require_relative "../project_environment"
+require_relative "json_document"
 
 module Rigor
   class CLI
@@ -32,10 +33,12 @@ module Rigor
     class AnnotateCommand < Command
       USAGE = "Usage: rigor annotate [options] FILE"
 
-      # Trailing `#=> …` annotation comment. Matched and stripped before re-annotating so re-running is idempotent —
-      # this follows xmpfilter's convention of owning the `#=>` marker, and also absorbs the older `#=> dump_type:
-      # <type>` spelling (idempotency across re-runs). The leading `\s` requirement keeps a `#=>` inside a string
-      # literal (no preceding whitespace ambiguity aside) from matching mid-expression.
+      # Trailing `#=> …` annotation comment, matched and stripped before re-annotating so re-running is idempotent.
+      # Follows xmpfilter's convention of owning the `#=>` marker, and also absorbs the older `#=> dump_type: <type>`
+      # spelling.
+      # Strips the first `#=>` that is preceded by whitespace and followed by whitespace or the end of the line,
+      # together with that preceding whitespace, through the end of the line. A string literal is not special-cased,
+      # since the pattern does not parse Ruby; `a#=>b` and `x #=>y` are left alone.
       ANNOTATION_PATTERN = /\s+#=>(?:\s.*)?\z/
 
       # Arguments for highlighting through `bat`: the annotated text arrives on stdin, so the language must be explicit;
@@ -59,19 +62,13 @@ module Rigor
         execute(file, options)
       end
 
-      private
-
-      def parse_options
-        # Default: colour a tty, unless `NO_COLOR` opts out. An explicit `--color` / `--no-color` overrides both.
-        options = { config: nil, color: @out.tty? && !no_color_env?, bat: nil, format: :text }
-
-        parser = OptionParser.new do |opts|
+      # The parser this command parses with, built without parsing anything: the catalogue reads the
+      # flags and formats from it (ADR-126 WD3). `options` is only written by the switches' blocks.
+      def option_parser(options = {})
+        OptionParser.new do |opts|
           opts.banner = USAGE
           Options.add_config(opts, options)
-          opts.on("--format=FORMAT", %w[text json],
-                  "Output format: text (default) or json (a { line => type } map)") do |value|
-            options[:format] = value.to_sym
-          end
+          Options.add_format(opts, options, "Output format: text (default) or json (a { line => type } map)")
           opts.on("--[no-]color",
                   "Force or disable ANSI colour (default: auto-detect a tty; honours NO_COLOR)") do |value|
             options[:color] = value
@@ -81,7 +78,15 @@ module Rigor
             options[:bat] = value
           end
         end
-        parser.parse!(@argv)
+      end
+
+      private
+
+      def parse_options
+        # Default: colour a tty, unless `NO_COLOR` opts out. An explicit `--color` / `--no-color` overrides both.
+        options = { config: nil, color: @out.tty? && !no_color_env?, bat: nil, format: "text" }
+
+        option_parser(options).parse!(@argv)
 
         options
       end
@@ -118,7 +123,7 @@ module Rigor
         line_types = LineTypeCollector.new(scope_index).collect(parse_result.value)
 
         case options.fetch(:format)
-        when :json
+        when "json"
           emit_json(line_types)
         else
           @out.puts(render(annotate(source, line_types), color: options.fetch(:color), bat: options.fetch(:bat)))
@@ -132,7 +137,7 @@ module Rigor
       # object keys).
       def emit_json(line_types)
         annotations = line_types.keys.sort.to_h { |line| [line.to_s, line_types[line].describe(:short)] }
-        @out.puts(JSON.generate({ "annotations" => annotations }))
+        @out.puts(JSON.generate(JsonDocument.stamp({ "annotations" => annotations })))
       end
 
       # The plugin-aware environment for the annotated file, so a `#=> <type>` matches what `rigor check`
@@ -225,7 +230,7 @@ module Rigor
         @scope_index = scope_index
       end
 
-      # @return 1-indexed line => type.
+      # @return map of 1-indexed line number to type.
       def collect(program)
         by_line = {}
         each_statement(program) do |statement|