rigortype 0.3.6 → 0.3.7

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

@@ -126,6 +126,10 @@ module Rigor
           snapshot_project_signature_state(environment)
           snapshot_effect_annotation_carrier(environment&.rbs_loader)
           result = files.flat_map { |path| @analyze_file.call(path, environment) }
+          # Issue #696 — AFTER the loop, deliberately. Definition builds are lazy (ADR-54 WD1: per class, on
+          # first demand), so a snapshot taken beside the ones above — which run BEFORE `files.flat_map` —
+          # would read an empty list on every run, including the ones this diagnostic exists for.
+          record_definition_build_failures(environment&.rbs_loader&.definition_build_failures)
           if @collect_stats
             loader = environment.rbs_loader
             @snapshots.class_decl_paths = loader&.class_decl_paths || {}.freeze
@@ -567,6 +571,11 @@ module Rigor
           snapshot_effect_annotation_carrier(environment.rbs_loader)
           diagnostics = files.flat_map { |path| @analyze_file.call(path, environment) }
           loader = environment.rbs_loader
+          # Issue #696 — this path analyses on the coordinator, so its loader IS the one that reached the
+          # failing build, and it must snapshot the same slot the two real paths do. Reached whenever
+          # `fork` is unavailable (Windows) and on `--incremental` / effects runs without it: a run that
+          # degraded to sequential must not also report less than a sequential run would.
+          record_definition_build_failures(loader&.definition_build_failures)
           @snapshots.class_decl_paths = loader&.class_decl_paths || {}.freeze
           @snapshots.signature_paths = loader&.signature_paths || [].freeze
           @snapshots.quarantined_signatures =
@@ -608,10 +617,35 @@ module Rigor
               plugin_id: entry.plugin_id, path: entry.path, message: entry.message
             )
           end
+          # Issue #696. Fetched with a default so an older drain stays compatible, exactly as the line above.
+          record_definition_build_failures(drained[:definition_build_failures])
         end
 
         private
 
+        # Issue #696 — accumulate the per-class `RBS::DefinitionBuilder` failures this run observed, deduped
+        # by class name and kept in first-seen order.
+        #
+        # Accumulating rather than assigning is what makes a pooled run say what a sequential one says: each
+        # worker holds its OWN loader and its own memo (the `@state` that also gates the stderr banner, which
+        # is why the banner repeats per worker — #295), so a class that fails in two workers arrives twice
+        # and a class only one worker touched arrives once. The union over the workers is the set the RUN
+        # hit; neither worker alone is.
+        #
+        # NOT gated on `project_signature_paths?`, unlike {#snapshot_project_signature_state}. That gate
+        # exists because each condition there forces the otherwise-lazy env build, which would warm the cache
+        # on a project with no sig set of its own. Nothing is forced here — this reads what the analysis
+        # already demanded — and the failure is not a project-sig-only condition anyway: two BUNDLED sources
+        # declaring the same method collapse a class with no `signature_paths:` in sight (the
+        # `bigdecimal` / `BigMath` shape, #299). Gating it would suppress exactly the variant the user cannot
+        # fix by editing their own `sig/`.
+        def record_definition_build_failures(failures)
+          return if failures.nil? || failures.empty?
+
+          @snapshots.definition_build_failures =
+            (@snapshots.definition_build_failures + failures).uniq(&:first).freeze
+        end
+
         # True when the project declares its own `signature_paths:` (the only place the
         # qualified-name-without-namespace mistake lives).
         def project_signature_paths?

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

@@ -53,17 +53,11 @@ module Rigor
         # consumes them and so never pays the double parse (see {#discover} + `Runner#ensure_project_discovery`).
         # The slot names mirror the discovery half of {Result} exactly.
         Discovery = Data.define(
-          :discovered_classes,
-          :discovered_def_nodes,
-          :discovered_singleton_def_nodes,
-          :discovered_def_sources,
-          :discovered_singleton_def_sources,
-          :discovered_superclasses,
-          :discovered_includes,
-          :discovered_class_sources,
-          :discovered_method_visibilities,
-          :discovered_methods,
-          :data_member_layouts,
+          :discovered_classes, :discovered_def_nodes, :discovered_def_nestings,
+          :discovered_singleton_def_nodes, :discovered_def_sources, :discovered_singleton_def_sources,
+          :discovered_superclasses, :discovered_header_nestings, :discovered_includes,
+          :discovered_class_sources, :constant_values, :constant_sources, :constant_writes,
+          :discovered_method_visibilities, :discovered_methods, :data_member_layouts,
           :struct_member_layouts
         )
 
@@ -156,12 +150,22 @@ module Rigor
           Discovery.new(
             discovered_classes: index.fetch(:classes),
             discovered_def_nodes: def_index.fetch(:def_nodes),
+            # Issue #681 — the recorded `Module.nesting` per declared `def`, so a callee's body re-walk
+            # resolves its constants the way the declaration that owns it does.
+            discovered_def_nestings: def_index.fetch(:def_nestings),
             discovered_singleton_def_nodes: def_index.fetch(:singleton_def_nodes),
             discovered_def_sources: def_index.fetch(:def_sources),
             discovered_singleton_def_sources: def_index.fetch(:singleton_def_sources),
             discovered_superclasses: def_index.fetch(:superclasses),
+            # Issue #682 — the nesting each declaration header is written in, so an ancestor name resolves in
+            # the cref Ruby resolves it in rather than by peeling the subclass's own qualified name.
+            discovered_header_nestings: def_index.fetch(:header_nestings),
             discovered_includes: def_index.fetch(:includes),
             discovered_class_sources: def_index.fetch(:class_sources),
+            # Issue #644 — the cross-file value-constant publication table and its write attribution.
+            constant_values: def_index.fetch(:constant_values),
+            constant_sources: def_index.fetch(:constant_sources),
+            constant_writes: def_index.fetch(:constant_writes),
             discovered_method_visibilities: def_index.fetch(:method_visibilities),
             discovered_methods: def_index.fetch(:methods),
             data_member_layouts: def_index.fetch(:data_member_layouts),

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

@@ -17,12 +17,15 @@ module Rigor
       class RunSnapshots
         attr_accessor :class_decl_paths, :signature_paths,
                       :synthesized_namespaces, :quarantined_signatures, :conformance_results,
-                      :env_build_failure, :effect_annotation_carrier
+                      :env_build_failure, :definition_build_failures, :effect_annotation_carrier
 
         # Constructor defaults match the {Runner} constructor: the pre-seed values `build_run_stats` /
         # `pre_file_diagnostics` read before the first analysis path runs are frozen empties. The
         # `env_build_failure` slot is nil (no failure) rather than an empty collection — it holds a single
-        # `[error_class, first_line, buffer_names]` tuple or nothing.
+        # `[error_class, first_line, buffer_names]` tuple or nothing. Its per-class sibling
+        # `definition_build_failures` (#696) holds a LIST, because a collapsed universe fails many classes,
+        # and is accumulated ACROSS pool workers rather than assigned once — see
+        # {PoolCoordinator#merge_worker_reporters}.
         def initialize
           @class_decl_paths = {}.freeze
           @signature_paths = [].freeze
@@ -30,6 +33,7 @@ module Rigor
           @quarantined_signatures = [].freeze
           @conformance_results = [].freeze
           @env_build_failure = nil
+          @definition_build_failures = [].freeze
           @effect_annotation_carrier = [].freeze
         end
 
@@ -42,6 +46,7 @@ module Rigor
           @quarantined_signatures = []
           @conformance_results = []
           @env_build_failure = nil
+          @definition_build_failures = []
           @effect_annotation_carrier = [].freeze
         end
       end

data/lib/rigor/analysis/runner.rb

@@ -344,16 +344,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,6 +419,7 @@ 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
@@ -530,6 +546,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,6 +669,8 @@ 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)
@@ -959,6 +993,10 @@ 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 three
+        # `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
         diagnostics += @diagnostic_aggregator.rbs_synthesized_namespace_diagnostics
         diagnostics += @diagnostic_aggregator.conforms_to_diagnostics
         diagnostics += @diagnostic_aggregator.rbs_extended_reporter_diagnostics
@@ -1081,15 +1119,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 +1241,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 +1272,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 +1286,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 +1329,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
@@ -1363,6 +1461,7 @@ 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 },
           conformance_results_snapshot: -> { @snapshots.conformance_results }
         )
       end
@@ -1581,6 +1680,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 +1690,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 +1700,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 +1735,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).

data/lib/rigor/analysis/worker_session.rb

@@ -235,6 +235,14 @@ module Rigor
       # 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.
       def drain_reporters
         {
           rbs_extended: {
@@ -242,7 +250,8 @@ module Rigor
             lossy_projections: @rbs_extended_reporter.lossy_projections
           },
           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 || []
         }
       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