rigortype 0.4.6 → 0.4.7

data/lib/rigor/analysis/fact_store.rb

@@ -139,9 +139,9 @@ module Rigor
         unique.freeze
       end
 
-      # `fact.target` is `Target | Array[Target]` per the carrier contract. Branching with an early return on
-      # the `Array` arm lets type narrowing collapse the post-return value to the bare `Target` case, so the
-      # wrapped tuple is `[Target]` and the union of return paths is exactly `Array[Target]`.
+      # `fact.target` is a Target or an Array of them, per the carrier contract. The early return on the Array arm
+      # lets type narrowing collapse the post-return value to the bare Target case, so the wrapped one-element
+      # Array is what the return paths join into.
       def fact_targets(fact)
         target = fact.target
         return target if target.is_a?(Array)

data/lib/rigor/analysis/incremental_run_slot/write_guard.rb

@@ -261,8 +261,8 @@ module Rigor
           end
         end
 
-        # A lockfile is read for its bytes: one absent at the mark must still be absent, one present must still be
-        # there with its change time before the mark.
+        # A lockfile is compared by its presence and change time: one absent at the mark must still be absent, one
+        # present must still be there with a change time before the mark.
         def lockfile_changed?(path)
           return File.exist?(path) unless present_at_mark?(path)
 

data/lib/rigor/analysis/incremental_run_slot.rb

@@ -54,8 +54,8 @@ module Rigor
       # a compaction pass — the incremental path never runs one.
       GENERATION_CAP = RunCacheKey::GENERATION_CAP
 
-      # The stored value. `baseline` and `pinned` (each a {Cache::Descriptor}) and `reads` (`{path =>
-      # Cache::Descriptor}`) are the chain the next writer carries forward, kept apart from the rest of the
+      # The stored value. `baseline` and `pinned` (each a {Cache::Descriptor}) and `reads` (keyed by
+      # path) are the chain the next writer carries forward, kept apart from the rest of the
       # dependency descriptor so it knows which rows are which; their entries are the same objects the descriptor
       # holds, so `Marshal` writes them once. `baseline` and `pinned` hold the rows the last full run recorded for
       # inputs the incremental path does not re-derive on a recheck (the signature tree, the

data/lib/rigor/analysis/incremental_session.rb

@@ -27,10 +27,8 @@ module Rigor
     #
     # The invariant the verify harness (and the spec) assert: `#recheck`'s merged diagnostics are
     # byte-identical to a full `--no-cache` re-analysis of the edited tree, in the same order (#1524; the gate
-    # itself compares sorted sets). This is the `--verify-incremental` acceptance gate, here without disk
-    # persistence or CLI wiring (the cache is in-process). It models the body tier only: an edit that adds /
-    # removes / moves a *file* is outside the analyzed set it maintains and falls to a fresh {#baseline} (the
-    # structural tier is a later slice).
+    # itself compares sorted sets). The `--verify-incremental` gate runs this engine; `#run_incremental` adds the
+    # snapshot persistence that `--incremental` uses.
     # The class-length budget is relaxed: this is one cohesive orchestrator of the incremental state
     # (per-file diagnostics cache, the file-level / symbol-level / negative dependency graphs, and the ADR-85
     # seed bundles), clearer read together than split across micro-classes that would all share the same ivars.
@@ -101,8 +99,8 @@ module Rigor
         # ADR-85 WD2 — per-file discovery seed bundles keyed by logical path. A cold baseline builds them; a
         # warm recheck folds them (re-walking only changed files) and refreshes the set. Ride the snapshot.
         @seed_bundles = {}
-        @cache = {}              # analyzed path => [Diagnostic]
-        @sources = {}            # analyzed path => Set<source path it read from>
+        @cache = {}              # analyzed path => its diagnostics
+        @sources = {}            # analyzed path => the source paths it read from
         @digests = {}            # analyzed path => ADR-87 packed stat-digest entry at last analysis
         # Issue #1583 — discovered-not-analysed path => the same packed entry, for a run over path arguments that
         # #684 widened to the configured `paths:`. Empty on every run over the configured paths.
@@ -110,18 +108,18 @@ module Rigor
         @analyzed = []           # the project files analyzed last round
         @dependents = {}         # inverted @sources (file-level)
         # ADR-46 slice 4 — symbol-granularity tracking.
-        @symbol_sources = {}     # consumer => { source_path => Set<"ClassName#method"> }
-        @ancestry_sources = {}   # consumer => Set<source_path> (class-ancestry deps)
+        @symbol_sources = {}     # consumer => { source_path => the "ClassName#method" symbols it read }
+        @ancestry_sources = {}   # consumer => source paths (class-ancestry deps)
         @symbol_fingerprints = {}  # path => { "ClassName#method" => sha256_hex }
-        @symbol_dependents = {}    # [source, symbol] => Set<consumer>
-        @ancestry_dependents = {}  # source => Set<consumer> (inverted ancestry_sources)
+        @symbol_dependents = {}    # [source, symbol] => consumers
+        @ancestry_dependents = {}  # source => consumers (inverted ancestry_sources)
         # ADR-46 slice 3 — negative (missing) dependencies: a consumer that
         # looked up a name and resolved nothing must be re-checked when that
         # name later appears (e.g. a `call.unresolved-toplevel` whose target
         # is defined by a later edit).
-        @missing = {}              # consumer => Set<"kind:name"> it looked up and missed
-        @negative_dependents = {}  # "kind:name" => Set<consumer> (inverted @missing)
-        @class_decls = {}          # path => Set<qualified class name declared in the file>
+        @missing = {}              # consumer => the "kind:name" keys it looked up and missed
+        @negative_dependents = {}  # "kind:name" => consumers (inverted @missing)
+        @class_decls = {}          # path => qualified class names declared in the file
         # Issue #644 — the value-constant twin: path => { qualified constant name => publication descriptor }.
         # Diffed on a recheck to find every constant whose PUBLISHED answer could have moved, which satisfies
         # the `constant:` edges a reader records at every reference, resolved or not.
@@ -633,9 +631,21 @@ module Rigor
         runner = build_runner
         files = @paths ? runner.analysis_file_set(@paths) : runner.analysis_file_set
         rebind_buffer(files)
-        files
+        admit_new_buffer(files)
       end
 
+      # Issue #2233 — a buffer for a file that is not on disk (a new file) is in no expansion, so the set above never
+      # names it: the recheck neither analyses it nor sees its declarations, and the run answers "re-analysed 0 file(s)"
+      # with no diagnostics for the buffer. Option A (single-file scope) analyses the logical path whether or not it
+      # exists; option B joins it to the set the same way, as an added file, so the closure analyses it like any new
+      # file. A buffer already matched by {#rebind_buffer} is in `files` and is returned as it is.
+      def admit_new_buffer(files)
+        return files if @buffer.nil? || files.include?(@buffer.logical_path)
+
+        files + [@buffer.logical_path]
+      end
+      private :admit_new_buffer
+
       # Verification engine (the `--verify-incremental` gate): with NO source edit, re-analyze `subset` fresh
       # and serve every other analyzed file from the baseline cache. Because nothing on disk changed, the
       # merged result MUST equal a full analysis — so this exercises the subset-analysis and cache-merge
@@ -1397,7 +1407,8 @@ module Rigor
         keys = moved.map { |(class_name, _mark)| "mark:#{class_name.split('::').last}" }.uniq
         keys.concat(mixin_keys(tainted))
         extended = Scope::DiscoveryIndex::ENVELOPE_OBJECT_EXTENDED_MARK
-        keys << "mark:*" if moved.any? { |(_class_name, mark)| mark == extended }
+        meta = Scope::DiscoveryIndex::ENVELOPE_META_SUPERCLASS_MARK
+        keys << "mark:*" if moved.any? { |(_class_name, mark)| mark == extended || mark == meta }
         Incremental.negative_closure(keys, @negative_dependents)
       end
 
@@ -1505,7 +1516,7 @@ module Rigor
       end
 
       # The qualified class/module names declared in the pre-parsed `index` (shared with
-      # {#symbol_fingerprints_from_index}, so the changed set is parsed once). `{ path => Set<class name> }`.
+      # {#symbol_fingerprints_from_index}, so the changed set is parsed once), keyed by path.
       def class_declarations_from_index(index)
         return {} if index.nil?
 

data/lib/rigor/analysis/rule_catalog.rb

@@ -25,7 +25,7 @@ module Rigor
     #   profile, taken from `Configuration::SeverityProfile::PROFILES`.
     # - `evidence_tier` — `:high` / `:medium` / `:low` (or `nil` for informational helpers), Rigor's own
     #   confidence that a firing is a true positive, derived from the rule's firing gates. `:high` rules
-    #   fire only on a concrete, statically- known type with no metaprogramming escape (Rigor's
+    #   fire only on a concrete, statically-known type with no metaprogramming escape (Rigor's
     #   false-positive discipline has already filtered the uncertain cases); `:medium` rules rest on flow /
     #   inference proofs that inherit a documented FP envelope (loop / mutation / RBS-strictness modelling
     #   gaps); `:low` rules are resolution- or coverage-gap signals where a firing often reflects missing
@@ -1120,7 +1120,7 @@ module Rigor
 
       module_function
 
-      # Looks up a rule by canonical id, legacy alias, or family wildcard. Returns an Array<Entry>:
+      # Looks up a rule by canonical id, legacy alias, or family wildcard. Returns the matching entries:
       #
       # - canonical id → 1-element array,
       # - legacy alias → 1-element array (resolved to canonical),

data/lib/rigor/analysis/run_stats.rb

@@ -21,7 +21,7 @@ module Rigor
     #
     # Stats collection is intentionally cheap: wall + RSS are single syscalls, target file count is already
     # in `expand_paths`, gem source-walk uses `Index#class_to_gem.size`, and the RBS class breakdown walks
-    # `class_decl_paths` (a frozen `Hash<String, String>` populated once per environment by the RBS loader;
+    # `class_decl_paths` (a frozen class-name to source-path table populated once per environment by the RBS loader;
     # ~1000-2000 entries × one `String#start_with?`).
     class RunStats
       attr_reader :wall_seconds,
@@ -112,7 +112,7 @@ module Rigor
       # misleading breakdown row.
       CACHED_SENTINEL = "<cached>"
 
-      # Computes `(project_sig, bundled)` counts from a frozen `Hash<class_name => source_path>` snapshot and
+      # Computes `(project_sig, bundled)` counts from a frozen class-name to source-path snapshot and
       # the configured `signature_paths`. `project_sig` is the count of classes whose source path begins
       # with any of the signature path prefixes (after expansion to absolute paths); `bundled` is the
       # remainder.

data/lib/rigor/analysis/runner/buffer_pool_dispatcher.rb

@@ -101,8 +101,8 @@ module Rigor
           @min_batch_size = min_batch_size
         end
 
-        # Runs one `Runner#run([binding.logical_path])` per binding and returns `Array<Array<Diagnostic>>` —
-        # one diagnostics array per input binding, IN INPUT ORDER. The parent always absorbs worker results
+        # Runs one `Runner#run([binding.logical_path])` per binding and returns one diagnostics array per
+        # input binding, IN INPUT ORDER. The parent always absorbs worker results
         # re-indexed by POSITION, never keyed on path, so two bindings that happen to share a logical path
         # (should not occur — one dirty buffer per URI — but is not assumed away) can never collide or
         # silently overwrite one another.

data/lib/rigor/analysis/runner/declaration_position.rb

@@ -20,7 +20,7 @@ module Rigor
 
         module_function
 
-        # @return `[path, line]`
+        # @return the path and the one-based line of the finding
         def of(finding)
           location = finding.location
           return [CONFIG_PATH, 1] if location.nil?