rigortype 0.3.6 → 0.3.8

data/lib/rigor/analysis/runner.rb

@@ -29,6 +29,7 @@ require_relative "../inference/scope_indexer"
 require_relative "../inference/synthetic_method_scanner"
 require_relative "../inference/project_patched_scanner"
 require_relative "../inference/method_dispatcher/file_folding"
+require_relative "crash_signature"
 require_relative "buffer_binding"
 require_relative "check_rules"
 require_relative "dependency_recorder"
@@ -64,7 +65,14 @@ module Rigor
 
       attr_reader :cache_store, :plugin_registry, :dependency_source_index,
                   :rbs_extended_reporter, :boundary_cross_reporter,
-                  :analyzed_files, :unresolved_self_calls, :seed_bundles
+                  :analyzed_files, :unresolved_self_calls, :seed_bundles,
+                  # #788 rounds 6–7 — the rows per-file analysis produced this run, severity-resolved exactly
+                  # as the run's stream is and sliced to this run's targets (a pool backend folds `.rigor.yml`
+                  # prepare / degraded rows into `analyze_files`'s return). `IncrementalSession` caches ONLY
+                  # this and serves reused files from it without re-stamping: a run-level row is regenerated
+                  # every run wherever it is positioned, and slicing the run's full stream by path cached the
+                  # file-positioned ones (`effect.annotations-unchecked`, `source-rbs-*`).
+                  :per_file_diagnostics
 
       # ADR-46 — the per-file cross-file read records this run captured (empty unless
       # `record_dependencies: true`). Sequential analysis records into `@file_dependencies` via
@@ -302,6 +310,7 @@ module Rigor
         # See `self_undefined_rule_active?`.
         @self_undefined_rule_active = nil
         @analyzed_files = [].freeze
+        @per_file_diagnostics = [].freeze
         # In-memory source map for `#run_source` — `{ logical_path => source String }`. When set,
         # `parse_source` reads bytes from here instead of disk and `expand_paths` accepts the (possibly
         # non-existent) logical path. nil on a normal disk-backed run.
@@ -344,16 +353,31 @@ module Rigor
         @cached_plugin_prepare_diagnostics = [].freeze
         @project_discovered_classes = {}.freeze
         @project_discovered_def_nodes = {}.freeze
+        # Issue #681 — the `Module.nesting` recorded per declared `def`, keyed by node identity.
+        @project_discovered_def_nestings = {}.compare_by_identity.freeze
         @project_discovered_singleton_def_nodes = {}.freeze
         @project_discovered_def_sources = {}.freeze
         @project_discovered_singleton_def_sources = {}.freeze
         @project_discovered_superclasses = {}.freeze
+        # Issue #682 — the `Module.nesting` each class / module declaration HEADER is written in.
+        @project_discovered_header_nestings = {}.freeze
         @project_discovered_includes = {}.freeze
         @project_discovered_class_sources = {}.freeze
+        # Issue #644 — the cross-file VALUE-constant publication table (`{qualified name => Type::Constant}`,
+        # literal writes only) and its per-name write attribution. The first seeds `in_source_constants` on
+        # every per-file scope so `FOO = :sym` in one file reads as `:sym` in another; the second seeds
+        # `constant_sources` only on an ADR-46 recording run, where it is the positive edge's attribution.
+        @project_constant_values = {}.freeze
+        @project_constant_sources = {}.freeze
+        # ...and the raw per-(name, path) publication census the incremental producer diffs.
+        @project_constant_writes = {}.freeze
+        @published_constant_name_set = nil
         @project_discovered_method_visibilities = {}.freeze
         @project_discovered_methods = {}.freeze
         @project_data_member_layouts = {}.freeze
         @project_struct_member_layouts = {}.freeze
+        # Issue #684 — set per run by {#project_discovery_expansion}; nil on every path that does not widen.
+        @project_discovery_expansion = nil
         # ADR-67 WD6a — the call-site parameter-inference table, populated by the opt-in pre-pass in
         # `assemble_run_diagnostics` when `parameter_inference:` is enabled, then seeded onto every per-file
         # scope (sequential + fork-worker) through `project_scope_seed_tables`. Empty by default, so the gate-off
@@ -404,12 +428,16 @@ module Rigor
         return Result.new(diagnostics: [target_ruby_error]) if target_ruby_error
 
         expansion = expand_paths(paths)
+        @project_discovery_expansion = project_discovery_expansion(paths, expansion)
         @snapshots.reset_for_run
         # Per-run reset of the deferred-discovery memo (see `#ensure_project_discovery`).
         @project_discovery_done = false
         # Per-run reset of the environment the cacheable path resolves, reused by the envelope pass so a
         # run never builds two.
         @run_environment = nil
+        # #788 — the per-file reader is assigned only on the analysis (miss) path; reset it here so a run the
+        # ADR-45 result cache serves does not answer with the previous run's rows.
+        @per_file_diagnostics = [].freeze
         # ADR-84 WD2 — roll the return-memo bucket: a fresh frozen token per run makes every per-file scope
         # of THIS run share one memo bucket while entries from any earlier run in this process (stale after
         # an edit) become unreachable.
@@ -530,6 +558,22 @@ module Rigor
         result.transform_values(&:freeze).freeze
       end
 
+      # Issue #644 — per-file PUBLICATION CENSUS: `{path => {qualified constant name => descriptor}}`, the
+      # value-constant twin of {#class_declarations}. The descriptor (`[literal]` or
+      # `ScopeIndexer::CONSTANT_UNPUBLISHABLE`) is load-bearing and a bare name set is not: a name's published
+      # answer is a function of the WHOLE project's write set for it, so what a recheck has to detect is a
+      # change in the census — a value edit, a write becoming unpublishable, a second declarer appearing or
+      # going away — not merely a name appearing.
+      # {Incremental.changed_constant_publications} diffs it; the reader's `constant:` edge is recorded on
+      # every reference, resolved or not, so the diff reaches it either way.
+      def constant_declarations
+        result = Hash.new { |hash, key| hash[key] = {} }
+        @project_constant_writes.each do |name, by_path|
+          by_path.each { |path, descriptor| result[path][name] = descriptor }
+        end
+        result.transform_values(&:freeze).freeze
+      end
+
       # ADR-67 WD6c lift — the inferred-param table this run seeded from (frozen; empty when
       # `parameter_inference:` is off or the pre-pass failed soft). The incremental session reads it back
       # after a baseline so the snapshot records the seeds the cached diagnostics were computed under.
@@ -637,10 +681,19 @@ module Rigor
       def evaluate_return_types_setup(paths, specs)
         expansion = expand_paths(paths || @configuration.paths)
         @project_discovery_done = false
+        # This entry point supplies its own expansion; it never widens (see {#project_discovery_expansion}).
+        @project_discovery_expansion = nil
         @run_generation = Object.new.freeze
         run_project_pre_passes(expansion: expansion)
         ensure_project_discovery(expansion)
-        environment = @pool_coordinator.resolve_sequential_environment(source_files: target_files(expansion))
+        # Issue #795 — `source_files:` is the WHOLE project's file list, never `target_files(expansion)`.
+        # `IncrementalSession#build_runner` threads its own `@buffer` into this Runner, so in editor-buffer
+        # mode `target_files` narrows to the buffer's single logical path; an environment built over just
+        # that path drops every OTHER file's plugin-synthesized virtual RBS, which can flip a re-evaluated
+        # return descriptor and wrongly declare a caller's return type unstable (or stable) relative to the
+        # full-project answer. This probe never analyzes a file, so it carries none of #788's per-file-cache
+        # duplication concern either.
+        environment = @pool_coordinator.resolve_sequential_environment(source_files: expansion.fetch(:files))
         specs.to_h do |spec|
           [[spec[:class_name], spec[:method_name], spec[:singleton]], evaluate_spec_returns(spec, environment)]
         end
@@ -893,9 +946,19 @@ module Rigor
         ).diagnostics
       end
 
+      # Issue #795 — `source_files:` is the WHOLE project's file list (`expansion.fetch(:files)`), never
+      # `target_files(expansion)`. A subset or editor-buffer run's `target_files` narrows to the
+      # `analyze_only` closure or the buffer's single logical path; building the envelope walk's
+      # environment over that subset drops every plugin-synthesized virtual RBS from an excluded file, so
+      # an envelope declared only in that file's inline annotation is invisible to the walk — the same #793
+      # gap #788 closed for per-file analysis, left open here because #788's binding sentences scoped
+      # themselves to "the environments the per-file analysis builds". This path is exempt from #788's
+      # per-file-cache duplication concern: `effect.unknown-label` (and its envelope-pass siblings) are
+      # produced by this pass, never by `Runner#per_file_diagnostics`, so `IncrementalSession` never caches
+      # them and widening this source list cannot duplicate a row on recheck.
       def envelope_rbs_loader(expansion)
         environment = @run_environment ||
-                      @pool_coordinator.resolve_sequential_environment(source_files: target_files(expansion))
+                      @pool_coordinator.resolve_sequential_environment(source_files: expansion.fetch(:files))
         environment&.rbs_loader
       rescue StandardError
         nil
@@ -951,7 +1014,17 @@ module Rigor
         # per-file cache, so it needs the full analyzed set to subtract the affected closure from.
         targets = target_files(expansion)
         @analyzed_files = targets
-        diagnostics += @pool_coordinator.analyze_files(targets, environment: environment)
+        # Issue #784 — the whole project's file list rides along so an EMPTY `targets` (a narrowed run whose
+        # closure is empty) can still resolve the environment a full run would — same files, same
+        # synthesized RBS — to demand the HKT registry once, while a project with no files resolves nothing.
+        # #788 rounds 6–7 — the per-file stream is kept apart from the run-level streams appended below,
+        # because `IncrementalSession` must cache ONLY what per-file analysis produced (#per_file_diagnostics),
+        # and the reader is exposed SEVERITY-RESOLVED and sliced to this run's targets. The cache serves a
+        # reused file without re-stamping, so a raw row would resurrect a rule the profile resolves to `:off`
+        # (`static.value-use.void` ships off on the default profile) and serve the authored severity where an
+        # override re-stamps it; and a pool backend folds `.rigor.yml`-positioned prepare / pool-degraded rows
+        # into the same return, which the slice drops. The run's own stream is stamped once, at the end.
+        diagnostics += analyze_targets(targets, environment: environment, project_files: expansion.fetch(:files))
         # ADR-103 WD12 — the effect fixpoint, in the post-pool aggregation slot beside the conformance
         # results. Graph-only over a finite lattice, so it is a plain worklist to a true fixpoint; it
         # contributes NO diagnostics and its result leaves through `#effect_table`, never through the
@@ -959,6 +1032,14 @@ module Rigor
         close_effect_graph
         diagnostics += @diagnostic_aggregator.rbs_quarantined_signature_diagnostics
         diagnostics += @diagnostic_aggregator.rbs_environment_build_failed_diagnostics
+        # Issue #696 — after its env-wide twin and before the synthesized-namespace notice: the four
+        # `rbs.coverage.*` build conditions surface widest-consequence first, and their relative order is
+        # the diagnostic output contract.
+        diagnostics += @diagnostic_aggregator.rbs_definition_build_failed_diagnostics
+        # Issue #784 — last of the four, deliberately: it loses only the IMPLICIT HKT registrations a
+        # `type` alias would have contributed, never a class's own declared method surface, so it is the
+        # narrowest-consequence rung on the same ladder.
+        diagnostics += @diagnostic_aggregator.rbs_hkt_scan_failed_diagnostics
         diagnostics += @diagnostic_aggregator.rbs_synthesized_namespace_diagnostics
         diagnostics += @diagnostic_aggregator.conforms_to_diagnostics
         diagnostics += @diagnostic_aggregator.rbs_extended_reporter_diagnostics
@@ -966,6 +1047,21 @@ module Rigor
         diagnostics + @diagnostic_aggregator.source_rbs_synthesis_diagnostics
       end
 
+      # #788 round 7 — runs per-file analysis over `targets` and exposes what it produced as
+      # `#per_file_diagnostics`: the `analyze_files` return, stamped with the same severity profile the run's
+      # own stream gets (`SeverityStamp` drops `:off` rows and re-stamps overrides, and the per-file cache never
+      # re-stamps), sliced to the rows positioned at the targets. Returns the RAW return for the run's stream,
+      # which is stamped once, at the end of `#run_analysis`.
+      def analyze_targets(targets, environment:, project_files:)
+        raw = @pool_coordinator.analyze_files(targets, environment: environment, project_files: project_files)
+        analysed = targets.to_set
+        @per_file_diagnostics = @diagnostic_aggregator.apply_severity_profile(raw)
+                                                      .select { |diagnostic| analysed.include?(diagnostic.path) }
+                                                      .freeze
+        raw
+      end
+      private :analyze_targets
+
       # ADR-67 WD6a — the check-walk parameter-inference pre-pass. Populates `@project_param_inferred_types`
       # (read by `project_scope_seed_tables`) with the call-site union of every undeclared parameter, running
       # ONE round (a single hop of call-site → param typing; the protection scan's three-round fixpoint stays a
@@ -1081,15 +1177,33 @@ module Rigor
       end
 
       def build_run_dependency_descriptor(expansion, rbs_descriptor)
-        entries = analyzed_file_entries(expansion) + pre_eval_file_entries + rbs_descriptor.files
+        entries = analyzed_file_entries(expansion) + discovery_file_entries(expansion) +
+                  pre_eval_file_entries + rbs_descriptor.files
+        globs = []
         @plugin_registry.plugins.each do |plugin|
           # Read the boundary WITHOUT triggering its lazy `@io_boundary ||=` initializer: plugin instances
           # are frozen after the run, and a plugin that never built a boundary read no files through it,
           # so it contributes no dependencies.
           boundary = plugin.instance_variable_get(:@io_boundary)
           entries.concat(boundary.cache_descriptor.files) if boundary
+          plugin.class.producers.each_value do |prod|
+            globs.concat(plugin.send(:watch_glob_entries, prod[:watch])) if prod[:watch]
+          end
         end
-        Cache::Descriptor.new(files: entries)
+        Cache::Descriptor.new(files: entries, globs: globs.uniq)
+      end
+
+      # Issue #684 — the project files this run DISCOVERED but did not analyse. A widened run's diagnostics
+      # are a function of them (that is the entire point: the method whose absence would have been reported
+      # is defined in one of them), so the run-result cache must invalidate when one changes. Empty on every
+      # run whose discovery expansion is its analysis expansion, which is every whole-project run.
+      def discovery_file_entries(expansion)
+        return [] if @project_discovery_expansion.nil?
+
+        analyzed = expansion.fetch(:files).to_set
+        analyzed_file_entries(
+          { files: @project_discovery_expansion.fetch(:files).reject { |path| analyzed.include?(path) } }
+        )
       end
 
       def analyzed_file_entries(expansion)
@@ -1185,12 +1299,18 @@ module Rigor
       def apply_discovery_result(discovery)
         @project_discovered_classes = discovery.discovered_classes
         @project_discovered_def_nodes = discovery.discovered_def_nodes
+        @project_discovered_def_nestings = discovery.discovered_def_nestings
         @project_discovered_singleton_def_nodes = discovery.discovered_singleton_def_nodes
         @project_discovered_def_sources = discovery.discovered_def_sources
         @project_discovered_singleton_def_sources = discovery.discovered_singleton_def_sources
         @project_discovered_superclasses = discovery.discovered_superclasses
+        @project_discovered_header_nestings = discovery.discovered_header_nestings
         @project_discovered_includes = discovery.discovered_includes
         @project_discovered_class_sources = discovery.discovered_class_sources
+        @project_constant_values = discovery.constant_values
+        @published_constant_name_set = nil
+        @project_constant_sources = discovery.constant_sources
+        @project_constant_writes = discovery.constant_writes
         @project_discovered_method_visibilities = discovery.discovered_method_visibilities
         @project_discovered_methods = discovery.discovered_methods
         @project_data_member_layouts = discovery.data_member_layouts
@@ -1210,6 +1330,8 @@ module Rigor
         return if @project_discovery_done
 
         @project_discovery_done = true
+        # Issue #684 — the cross-file index spans the PROJECT even when the analysis targets a file list.
+        expansion = @project_discovery_expansion || expansion
         if @collect_seed_bundles
           # ADR-85 WD2 — rebuild discovery from the prior run's bundles (re-walking only changed files) and
           # capture the refreshed bundle set for the session to persist.
@@ -1222,6 +1344,39 @@ module Rigor
         end
       end
 
+      # Issue #684 — the file set the cross-file DISCOVERY pre-pass walks, when that is wider than the set
+      # being analysed. nil means "the same one", which is every whole-project run.
+      #
+      # `rigor check path/to/one_file.rb` — what an editor integration, a pre-commit hook and
+      # `git diff --name-only | xargs rigor check` all do — discovered only the files it was handed, so a
+      # class the project declares in `sig/` WITHOUT declaring every one of its methods drew a false
+      # `call.undefined-method` for any method whose defining file was outside the invocation. The class was
+      # RBS-known, source discovery could not supply the method, and the rule fired on correct code. The
+      # same check over the containing DIRECTORY reported nothing, which is also why per-directory sums
+      # over a tree over-reported against a whole-tree run (14 diagnostics of this shape against 2 during
+      # the #652 work).
+      #
+      # Discovery is a parse pass, not an analysis: 0.55s over Rigor's own 444-file `lib` cold, and under
+      # ADR-85 seed bundles a warm run re-walks only what changed. The alternative — standing the rule down
+      # whenever evidence might be missing — buys the same FP safety by making `rigor check one_file.rb`
+      # answer a different question than `rigor check .`, and the diagnostics for a file should not depend
+      # on what else was on the command line.
+      #
+      # Excluded, each because its expansion is already the one it means: the LSP `prebuilt:` path (which
+      # seeds discovery from a snapshot), editor `buffer:` mode, `run_source`'s in-memory single file, and
+      # ADR-46's `analyze_only` subset mode (which already passes the full expansion and filters later).
+      def project_discovery_expansion(paths, expansion)
+        return nil unless widen_discovery_to_project?(paths)
+
+        widened = expand_paths(@configuration.paths | paths)
+        widened.fetch(:files).size > expansion.fetch(:files).size ? widened : nil
+      end
+
+      def widen_discovery_to_project?(paths)
+        @prebuilt.nil? && @buffer.nil? && @in_memory_sources.nil? && @analyze_only.nil? &&
+          paths != @configuration.paths
+      end
+
       # ADR-46 — the dependency-recording and subset-analysis modes read the discovery tables OUTSIDE the
       # analysis assembly (`Runner#symbol_fingerprints` / `#class_declarations`, consumed by
       # {IncrementalSession} after the run), so they force the build eagerly — matching the pre-slice-1
@@ -1232,7 +1387,8 @@ module Rigor
       end
 
       private :run_project_pre_passes, :adopt_prebuilt_project_scan, :apply_pre_passes_result,
-              :apply_discovery_result, :ensure_project_discovery, :force_eager_discovery?
+              :apply_discovery_result, :ensure_project_discovery, :force_eager_discovery?,
+              :project_discovery_expansion, :widen_discovery_to_project?
 
       # Ruby versions probed (ascending) to discover the lowest one this Prism build accepts for
       # `version:`. Prism exposes no version list, so the floor is found empirically — only when a
@@ -1329,7 +1485,7 @@ module Rigor
       # indexes, prepare-diagnostic snapshot, and the four end-of-pass snapshots) is reached through reader
       # procs so each collaborator observes the live ivar value at call time without a back-reference
       # cycle. The reporter accumulators and the {RunSnapshots} sink are shared mutable instances.
-      def build_collaborators # rubocop:disable Metrics/MethodLength
+      def build_collaborators # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
         @pre_passes = ProjectPrePasses.new(
           configuration: @configuration, cache_store: @cache_store, buffer: @buffer,
           plugin_requirer: @plugin_requirer, pool_mode: -> { pool_mode? }
@@ -1363,6 +1519,8 @@ module Rigor
           synthesized_namespaces_snapshot: -> { @snapshots.synthesized_namespaces },
           quarantined_signatures_snapshot: -> { @snapshots.quarantined_signatures },
           env_build_failure_snapshot: -> { @snapshots.env_build_failure },
+          definition_build_failures_snapshot: -> { @snapshots.definition_build_failures },
+          hkt_scan_failure_snapshot: -> { @snapshots.hkt_scan_failure },
           conformance_results_snapshot: -> { @snapshots.conformance_results }
         )
       end
@@ -1581,6 +1739,9 @@ module Rigor
         tables[:run_generation] = @run_generation if @run_generation
         tables[:discovered_classes] = @project_discovered_classes unless @project_discovered_classes.empty?
         tables[:discovered_def_nodes] = @project_discovered_def_nodes unless @project_discovered_def_nodes.empty?
+        unless @project_discovered_def_nestings.empty?
+          tables[:discovered_def_nestings] = @project_discovered_def_nestings
+        end
         unless @project_discovered_singleton_def_nodes.empty?
           tables[:discovered_singleton_def_nodes] = @project_discovered_singleton_def_nodes
         end
@@ -1588,6 +1749,9 @@ module Rigor
         unless @project_discovered_superclasses.empty?
           tables[:discovered_superclasses] = @project_discovered_superclasses
         end
+        unless @project_discovered_header_nestings.empty?
+          tables[:discovered_header_nestings] = @project_discovered_header_nestings
+        end
         tables[:discovered_includes] = @project_discovered_includes unless @project_discovered_includes.empty?
         unless @project_discovered_method_visibilities.empty?
           tables[:discovered_method_visibilities] = @project_discovered_method_visibilities
@@ -1595,14 +1759,22 @@ module Rigor
         tables[:discovered_methods] = @project_discovered_methods unless @project_discovered_methods.empty?
         seed_opt_in_pre_pass_tables(tables)
         seed_member_layout_tables(tables)
-        # ADR-46 slice 1 — the class-declaration source map is read only by the ancestry accessors during
-        # dependency recording, so seed it only when recording is on; a normal run never carries it.
-        if @record_dependencies && !@project_discovered_class_sources.empty?
-          tables[:discovered_class_sources] = @project_discovered_class_sources
-        end
+        seed_dependency_attribution_tables(tables)
         tables
       end
 
+      # ADR-46 slice 1 / issue #644 — the two SOURCE-ATTRIBUTION tables, read only by the recording accessors
+      # (`Scope#record_class_dependency` for the class-declaration map, `Scope#record_constant_dependency`
+      # for the constant-write map). A normal run carries neither. Extracted to keep
+      # {#project_scope_seed_tables} under the complexity budget.
+      def seed_dependency_attribution_tables(tables)
+        return unless @record_dependencies
+
+        tables[:discovered_class_sources] = @project_discovered_class_sources unless
+          @project_discovered_class_sources.empty?
+        tables[:constant_sources] = @project_constant_sources unless @project_constant_sources.empty?
+      end
+
       # Issue #260 — the mutable starting point {#project_scope_seed_tables} fills in: a copy of the opt-in
       # `discovery_seed:` when one was supplied, otherwise the empty Hash every other run has always started
       # from. Extracted so the seed costs {#project_scope_seed_tables} no branch of its complexity budget.
@@ -1622,9 +1794,33 @@ module Rigor
       # Extracted to keep {#project_scope_seed_tables} under the complexity budget.
       def seed_opt_in_pre_pass_tables(tables)
         tables[:param_inferred_types] = @project_param_inferred_types unless @project_param_inferred_types.empty?
-        return if @project_pre_eval_constants.empty?
+        constants = merged_seed_constants
+        return if constants.empty?
+
+        tables[:in_source_constants] = constants
+        names = published_constant_name_set
+        tables[:published_constant_names] = names unless names.empty?
+      end
+
+      # Issue #644 — the seeded `in_source_constants` table, joining the two cross-file constant producers.
+      # The whole-project literal table wins over a `pre_eval:` publication of the same name: both describe
+      # the same assignment, the literal table pins the value the write actually carries while ADR-17's
+      # widener erases it to the class, and listing a file under `pre_eval:` must never LOSE precision. The
+      # per-file table still wins over both (`ScopeIndexer.index`'s merge) — same-file stays the most
+      # specific authority.
+      # Issue #644 — the LAST SEGMENTS of the published table, the run-wide half of
+      # `Scope#published_constant?`. Seeded on EVERY run (unlike `constant_sources`, which only a recording
+      # run needs) because {CheckRules::PublishedConstantGuard} asks the question on every `if` / `unless`.
+      def published_constant_name_set
+        @published_constant_name_set ||=
+          @project_constant_values.keys.to_set { |name| name.split("::").last }.freeze
+      end
+
+      def merged_seed_constants
+        return @project_constant_values if @project_pre_eval_constants.empty?
+        return @project_pre_eval_constants if @project_constant_values.empty?
 
-        tables[:in_source_constants] = @project_pre_eval_constants
+        @project_pre_eval_constants.merge(@project_constant_values).freeze
       end
 
       # ADR-46 — seed the instance + singleton `"path:line"` def-source tables (each only when non-empty).
@@ -1739,7 +1935,7 @@ module Rigor
             path: path,
             line: 1,
             column: 1,
-            message: "internal analyzer error: #{e.class}: #{e.message}",
+            message: CrashSignature.check_rule_message(e),
             severity: :error
           )
         ]

data/lib/rigor/analysis/worker_session.rb

@@ -16,6 +16,7 @@ require_relative "../effects/envelope_index"
 require_relative "../inference/scope_indexer"
 require_relative "../inference/method_dispatcher/file_folding"
 require_relative "check_rules"
+require_relative "crash_signature"
 require_relative "dependency_recorder"
 require_relative "dependency_source_inference"
 require_relative "diagnostic"
@@ -228,21 +229,54 @@ module Rigor
       rescue Errno::ENOENT => e
         [analyzer_error(path, e.message)]
       rescue StandardError => e
-        [analyzer_error(path, "internal analyzer error: #{e.class}: #{e.message}")]
+        [analyzer_error(path, CrashSignature.check_rule_message(e))]
       end
       private :analyze_body
 
       # Read-once snapshot of the per-worker reporters so the caller (or the eventual Phase 4b pool
       # aggregator) can merge into a single coordinator-side reporter. Both reporters dedupe at write time,
       # so a post-hoc concat + de-dup at the entry-key level is sound.
+      #
+      # Issue #696 — `definition_build_failures` rides this channel rather than a coordinator-side snapshot,
+      # and it has to. Under the pool the PARENT never analyses a file, so its loader never demands a
+      # definition and never enters the failing build; a diagnostic wired off the parent's loader would
+      # appear at `--workers=0` and vanish at `--workers=N`, which is the same "reports less depending on
+      # how you ran it" defect the diagnostic exists to end. Draining it out of the workers is what makes
+      # the two paths say the same thing. The payload is `[String, String, String, Array<String>]` tuples —
+      # Marshal-clean for the fork backend and shareable for the Ractor one.
+      #
+      # Issue #784 — `hkt_scan_failure` rides the same channel for the same reason: the PARENT's own
+      # Environment never demands `#hkt_registry` under the pool, so its slot is always nil, and draining it
+      # out of the workers is the only way `--workers=N` says what `--workers=0` says.
+      #
+      # Issue #805 — the Marshal-clean requirement binds every stream here, not just the ones written for it.
+      # The `RbsExtended::Reporter`'s unresolved / lossy-projection entries used to carry the `RBS::Location`
+      # itself, and `Marshal.dump` on one raises `TypeError` (a C-extension object with no `_dump`), so a
+      # project whose `sig/` produced a single such event killed each worker HERE — after its files were
+      # analysed — and the run degraded to in-process re-analysis with a `pool-degraded` row. All three
+      # streams now carry `(path, line, column)` primitives.
       def drain_reporters
+        # Issue #784 — demand the registry once per worker before reading the slot, so a worker whose share
+        # of files happened to contain no `Klass.method` call still reports the run's outcome (the same
+        # reason `PoolCoordinator#hkt_scan_outcome` demands it on the sequential path). The Environment
+        # object is built in the constructor, but its RBS env is lazy: on a worker that analysed a file this
+        # is a memoised read; on one that demanded nothing it is the same cache-served env load that file
+        # would have paid. The fork backend never hands a worker an empty slice, so no idle worker pays it.
+        @environment&.hkt_registry
         {
           rbs_extended: {
             unresolved_payloads: @rbs_extended_reporter.unresolved_payloads,
-            lossy_projections: @rbs_extended_reporter.lossy_projections
+            lossy_projections: @rbs_extended_reporter.lossy_projections,
+            # Issue #785 — the HKT directive stream rides the same channel for the same reason
+            # `hkt_scan_failure` does: the directives are read by the registry scan, and under the pool the
+            # PARENT never demands that scan, so a diagnostic wired off the parent's reporter would appear
+            # at `--workers=0` and vanish at `--workers=N`. The demand above is what fills this.
+            hkt_directive_errors: @rbs_extended_reporter.hkt_directive_errors
           },
           boundary_cross: @boundary_cross_reporter.entries,
-          source_rbs_synthesis: @source_rbs_synthesis_reporter.entries
+          source_rbs_synthesis: @source_rbs_synthesis_reporter.entries,
+          definition_build_failures: @environment&.rbs_loader&.definition_build_failures || [],
+          hkt_scan_failure: @environment&.hkt_scan_failure
         }
       end
 

data/lib/rigor/bleeding_edge.rb

@@ -107,14 +107,15 @@ module Rigor
         id: "reject-unparseable-signatures",
         kind: :severity,
         summary: "A broken `signature_paths:` RBS set fails the run instead of degrading it silently. An " \
-                 "unparseable `.rbs` is otherwise skipped with a warning, and a duplicate-declaration " \
-                 "conflict (a file that parses fine but collides on resolve — typically against Rigor's " \
-                 "own bundled RBS) collapses the whole env with a warning; either way the run gets quieter " \
-                 "rather than cleaner. This treats both as a build error, the way a broken source file " \
-                 "already is.",
+                 "unparseable `.rbs` is otherwise skipped with a warning; a duplicate-declaration conflict " \
+                 "(a file that parses fine but collides on resolve — typically against Rigor's own bundled " \
+                 "RBS) collapses the whole env with a warning; and a duplicate METHOD definition collapses " \
+                 "one class's method surface the same way. Each leaves the run quieter rather than " \
+                 "cleaner. This treats all three as a build error, the way a broken source file already is.",
         severity_overrides: {
           "rbs.coverage.quarantined-signature" => :error,
-          "rbs.coverage.environment-build-failed" => :error
+          "rbs.coverage.environment-build-failed" => :error,
+          "rbs.coverage.definition-build-failed" => :error
         }.freeze
       ),
       Feature.new(

data/lib/rigor/builtins/hkt_builtins.rb

@@ -52,6 +52,15 @@ module Rigor
         Rigor::Inference::HktBodyParser.parse(CSV_PARSED_BODY, params: [:K])
       end
 
+      # `csv::row[K]` — `Array[K | nil]` (CSV.parse_line's shape:
+      # an Array of optionally-nil cell values for a single row).
+      CSV_ROW_BODY = "Array[K | nil]"
+      private_constant :CSV_ROW_BODY
+
+      def csv_row_body_tree
+        Rigor::Inference::HktBodyParser.parse(CSV_ROW_BODY, params: [:K])
+      end
+
       def json_value_registration
         Rigor::Inference::HktRegistry::Registration.new(
           uri: :"json::value",
@@ -90,6 +99,25 @@ module Rigor
         )
       end
 
+      def csv_row_registration
+        Rigor::Inference::HktRegistry::Registration.new(
+          uri: :"csv::row",
+          arity: 1,
+          variance: [:out],
+          bound: Rigor::Type::Combinator.untyped
+        )
+      end
+
+      def csv_row_definition
+        Rigor::Inference::HktRegistry.definition_with_body_tree(
+          uri: :"csv::row",
+          params: [:K],
+          body_tree: csv_row_body_tree,
+          source_path: __FILE__,
+          source_line: __LINE__ - 5
+        )
+      end
+
       # @return [Rigor::Inference::HktRegistry] frozen registry
       #   pre-seeded with all bundled HKT registrations +
       #   bodies. Allocated fresh each call rather than
@@ -104,8 +132,8 @@ module Rigor
       #   once ADR-15 phase 4b.x covers the dependency graph.
       def registry
         Rigor::Inference::HktRegistry.new(
-          registrations: [json_value_registration, csv_parsed_registration],
-          definitions: [json_value_definition, csv_parsed_definition]
+          registrations: [json_value_registration, csv_parsed_registration, csv_row_registration],
+          definitions: [json_value_definition, csv_parsed_definition, csv_row_definition]
         )
       end
 
@@ -160,6 +188,14 @@ module Rigor
       }.freeze
       private_constant :CSV_PARSED_SPEC
 
+      CSV_ROW_SPEC = {
+        uri: :"csv::row",
+        args: ["String"],
+        discriminator: nil,
+        post_reduce: nil
+      }.freeze
+      private_constant :CSV_ROW_SPEC
+
       METHOD_RETURN_OVERRIDES = {
         # JSON — stdlib's `json` library. Upstream rbs declares
         # `(string, ?options) -> untyped`; the HKT-builtin tier
@@ -190,17 +226,20 @@ module Rigor
         ["YAML",  :safe_load_file, :singleton] => YAML_SAFE_VALUE_SPEC,
         ["Psych", :safe_load,      :singleton] => YAML_SAFE_VALUE_SPEC,
         ["Psych", :safe_load_file, :singleton] => YAML_SAFE_VALUE_SPEC,
-        # CSV.parse / CSV.read — no-headers shape only.
+        # CSV.parse / CSV.read / CSV.readlines / CSV.parse_line — no-headers shape only.
         # Upstream rbs declares broader return shapes but
         # the common case is `Array[Array[String?]]` which
-        # the `csv::parsed[String]` URI matches. The
+        # the `csv::parsed[String]` URI matches, or
+        # `Array[String?]` which `csv::row[String]` matches. The
         # `headers: true` shape (`CSV::Table` of `CSV::Row`)
         # is NOT covered — calls passing the option fall
         # through to the upstream RBS type. CSV.foreach also
         # falls through (it yields rows rather than
         # returning a typed structure).
-        ["CSV", :parse, :singleton] => CSV_PARSED_SPEC,
-        ["CSV", :read,  :singleton] => CSV_PARSED_SPEC
+        ["CSV", :parse,      :singleton] => CSV_PARSED_SPEC,
+        ["CSV", :read,       :singleton] => CSV_PARSED_SPEC,
+        ["CSV", :readlines,  :singleton] => CSV_PARSED_SPEC,
+        ["CSV", :parse_line, :singleton] => CSV_ROW_SPEC
       }.freeze
 
       # @return [Rigor::Type, nil] the reduced HKT type for

data/lib/rigor/builtins/imported_refinements.rb

@@ -2,6 +2,7 @@
 
 require "strscan"
 
+require_relative "../rbs_extended/reporter"
 require_relative "../type"
 require_relative "../type_node"
 
@@ -558,11 +559,14 @@ module Rigor
           result
         end
 
-        # ADR-13 slice 3b — record one `dynamic.shape.lossy-projection` event per (head,
-        # source_location) pair when the projection actually degraded. The builders return
-        # the source carrier unchanged on non-HashShape / non-Tuple receivers (see
-        # `Type::Combinator.pick_of` / `omit_of` and the HashShape-only `partial_of` /
-        # `required_of` / `readonly_of`), so detection is "first arg was lossy".
+        # ADR-13 slice 3b — record one `dynamic.shape.lossy-projection` event per (head, position) pair when
+        # the projection actually degraded. The builders return the source carrier unchanged on
+        # non-HashShape / non-Tuple receivers (see `Type::Combinator.pick_of` / `omit_of` and the
+        # HashShape-only `partial_of` / `required_of` / `readonly_of`), so detection is "first arg was lossy".
+        #
+        # Issue #805 — the `RBS::Location` is flattened to `(path, line, column)` here, at record time: the
+        # entry is drained out of every fork-pool worker, and a location survives neither the drain's
+        # `Marshal.dump` nor its cross-worker dedup (see {Rigor::RbsExtended::Reporter}).
         def record_lossy_projection_if_applicable(node, args, result)
           return if @reporter.nil?
           return if result.nil?
@@ -570,10 +574,8 @@ module Rigor
           return if args.empty?
           return unless Type::Combinator.shape_projection_lossy?(args.first)
 
-          @reporter.record_lossy_projection(
-            head: node.head,
-            source_location: @source_location
-          )
+          path, line, column = RbsExtended::Reporter.position_of(@source_location)
+          @reporter.record_lossy_projection(head: node.head, path: path, line: line, column: column)
         end
 
         def try_parametric_int_builder(node)