rigortype 0.4.6 → 0.4.8

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

@@ -3,6 +3,7 @@
 require_relative "../check_rules/rule_ids"
 require_relative "../crash_signature"
 require_relative "../diagnostic"
+require_relative "../run_cache_key"
 require_relative "../severity_stamp"
 
 module Rigor
@@ -29,35 +30,24 @@ module Rigor
         # @param pool_mode — reader returning the pool-mode flag.
         # @param cached_plugin_prepare_diagnostics — reader returning the prepare-diagnostic snapshot.
         # @param pre_eval_diagnostics_from_scanner — reader returning the pre-eval scanner diagnostics.
-        # @param synthesized_namespaces_snapshot — reader.
-        # @param quarantined_signatures_snapshot — reader returning the `signature_paths:` files skipped
-        #   because they do not parse (`[path, first_error_line]` pairs).
-        # @param signature_standdowns_snapshot — reader returning the plugin-contributed signature files
-        #   that stood down against a colliding generic arity (#610), as
-        #   `[path, class_name, existing_arity, incoming_arity, existing_file]` tuples. Defaults to none so
-        #   a caller that snapshots nothing of the kind need not say so.
-        # @param vendored_standdowns_snapshot — issue #1713 — reader returning what each required-feature-gated
-        #   vendored directory left out (`Environment::RbsLoader#vendored_standdowns`). Defaults to none.
-        # @param env_build_failure_snapshot — reader returning the total RBS env-build failure tuple
-        #   (`[error_class, first_error_line, conflicting_buffer_names]`) or nil when the env built.
-        # @param definition_build_failures_snapshot — issue #696 — reader returning the per-class
-        #   `RBS::DefinitionBuilder` failures the run observed, as `[class_name, error_class, member,
-        #   conflicting_buffer_names, unresolved_type_name_detail]` tuples (issue #997 added the fifth
-        #   element — `[token, location, refinement_hint]`, `nil` unless `error_class` is
-        #   `RBS::NoTypeFoundError`). Empty for a healthy sig set.
-        # @param hkt_scan_failure_snapshot — issue #784 — reader returning the `[error_class_name,
-        #   first_message_line, raw_frame_or_nil, stage]` tuple whichever stage of the HKT-registry build
-        #   raised, or nil when both built (or were never demanded). `stage` is `:scan` (the RBS `type`-alias
-        #   scan) or `:overlay` (the plugin-manifest aggregation, #791), and picks the row's wording.
-        # @param conformance_results_snapshot — reader.
+        # @param snapshots — the run's {RunSnapshots} store (ADR-116 WD3), read at row-build time. Its slots'
+        #   shapes, as the rows below read them:
+        #   - `quarantined_signatures` — the `signature_paths:` files skipped because they do not parse
+        #     (`[path, first_error_line]` pairs);
+        #   - `signature_standdowns` (#610) — `[path, class_name, existing_arity, incoming_arity,
+        #     existing_file]` tuples, then (#2422) `[path, declaration, nil, nil, cause_file, :member]` ones;
+        #   - `vendored_standdowns` (#1713) — `Environment::RbsLoader#vendored_standdowns`;
+        #   - `env_build_failure` — `[error_class, first_error_line, conflicting_buffer_names]`, or nil;
+        #   - `definition_build_failures` (#696) — `[class_name, error_class, member,
+        #     conflicting_buffer_names, unresolved_type_name_detail, mixin_count]` tuples (#997 added the fifth
+        #     element — `[token, location, refinement_hint]`, `nil` unless `error_class` is
+        #     `RBS::NoTypeFoundError`; #2440 the sixth, {Environment::RbsLoader#variable_mixin_count});
+        #   - `hkt_scan_failure` (#784) — `[error_class_name, first_message_line, raw_frame_or_nil, stage]`,
+        #     or nil; `stage` is `:scan` or `:overlay` (#791) and picks the row's wording.
         def initialize(configuration:, rbs_extended_reporter:, boundary_cross_reporter:, # rubocop:disable Metrics/ParameterLists
                        source_rbs_synthesis_reporter:, plugin_registry:, dependency_source_index:,
                        pool_mode:, cached_plugin_prepare_diagnostics:,
-                       pre_eval_diagnostics_from_scanner:, synthesized_namespaces_snapshot:,
-                       quarantined_signatures_snapshot:, env_build_failure_snapshot:,
-                       definition_build_failures_snapshot:, hkt_scan_failure_snapshot:,
-                       conformance_results_snapshot:, signature_standdowns_snapshot: -> { [] },
-                       vendored_standdowns_snapshot: -> { [] }, pooled_run_disclosures: -> { [] },
+                       pre_eval_diagnostics_from_scanner:, snapshots:, pooled_run_disclosures: -> { [] },
                        served_run_disclosures: -> { [] }, pooled_trust_refusals: -> { [] })
           @configuration = configuration
           @rbs_extended_reporter = rbs_extended_reporter
@@ -68,14 +58,7 @@ module Rigor
           @pool_mode_reader = pool_mode
           @cached_plugin_prepare_diagnostics_reader = cached_plugin_prepare_diagnostics
           @pre_eval_diagnostics_from_scanner_reader = pre_eval_diagnostics_from_scanner
-          @synthesized_namespaces_snapshot_reader = synthesized_namespaces_snapshot
-          @quarantined_signatures_snapshot_reader = quarantined_signatures_snapshot
-          @signature_standdowns_snapshot_reader = signature_standdowns_snapshot
-          @vendored_standdowns_snapshot_reader = vendored_standdowns_snapshot
-          @env_build_failure_snapshot_reader = env_build_failure_snapshot
-          @definition_build_failures_snapshot_reader = definition_build_failures_snapshot
-          @hkt_scan_failure_snapshot_reader = hkt_scan_failure_snapshot
-          @conformance_results_snapshot_reader = conformance_results_snapshot
+          @snapshots = snapshots
           # Issue #1051 — reader for the pool coordinator's de-duplicated run-scoped disclosure table.
           # Empty on a sequential run, where `plugin_registry`'s own instances are the ones that registered.
           @pooled_run_disclosures_reader = pooled_run_disclosures
@@ -86,6 +69,14 @@ module Rigor
           @pooled_trust_refusals_reader = pooled_trust_refusals
         end
 
+        # ADR-116 WD3 — every post-analysis run-level row, in the contract order {RunLevelFacts.row_builders}
+        # declares: the `rbs.coverage.*` build-failure ladder widest consequence first, its `:info` notices,
+        # the conformance rows, the reporter streams, then the plugin run disclosures and the trust-refusal
+        # envelope, read last so every per-file plugin call has recorded its refusals.
+        def run_level_diagnostics
+          RunLevelFacts.row_builders.flat_map { |builder| public_send(builder) }
+        end
+
         # Pre-file diagnostic streams that fire once per run rather than per analyzed file: plugin load /
         # prepare envelopes, the ADR-10 dependency-source resolution surface, and the `expand_paths` errors
         # for `paths:` entries that don't exist or aren't `.rb`. Aggregated here so `#run` stays under the
@@ -94,9 +85,9 @@ module Rigor
         # ADR-15 Phase 4b — `plugin_prepare_diagnostics` runs on the coordinator's plugin registry under
         # sequential mode; under pool mode each worker re-runs `prepare` against its own plugin instances,
         # so the pool path drains the first worker's prepare-diagnostic snapshot into the aggregated
-        # diagnostic stream instead (see {#analyze_files_in_pool}). Skipping the coordinator prepare in pool
-        # mode avoids double-running `#prepare` against the coordinator-side plugin instances (which the
-        # pool path never consults for per-file analysis).
+        # diagnostic stream instead (see {PoolCoordinator#analyze_files_in_pool}). Skipping the coordinator
+        # prepare in pool mode avoids double-running `#prepare` against the coordinator-side plugin instances
+        # (which the pool path never consults for per-file analysis).
         def pre_file_diagnostics(expansion)
           # ADR-18 slice 3 — prepare diagnostics are captured earlier in #run (before the synthetic-method
           # scanner) so cross-plugin facts are available to the scanner. We re-surface the captured
@@ -109,6 +100,7 @@ module Rigor
             dependency_source_budget_diagnostics +
             dependency_source_config_conflict_diagnostics +
             rbs_coverage_diagnostics +
+            rbs_collection_setup_hint_diagnostics +
             rbs_inline_annotation_hint_diagnostics(expansion) +
             expansion.fetch(:errors)
         end
@@ -125,7 +117,7 @@ module Rigor
             next if File.file?(path)
 
             Diagnostic.new(
-              path: ".rigor.yml", line: 1, column: 1,
+              path: @configuration.config_display_path, line: 1, column: 1,
               message: "pre_eval entry not found: #{path.inspect}. " \
                        "Pre-evaluation requires the file to exist on disk; remove the entry " \
                        "or create the file before re-running analysis.",
@@ -173,7 +165,7 @@ module Rigor
         def plugin_load_diagnostics
           plugin_registry.load_errors.map do |error|
             Diagnostic.new(
-              path: ".rigor.yml",
+              path: @configuration.config_display_path,
               line: 1,
               column: 1,
               message: plugin_load_error_message(error),
@@ -202,7 +194,7 @@ module Rigor
         def dependency_source_diagnostics
           dependency_source_index.unresolvable.map do |entry|
             Diagnostic.new(
-              path: ".rigor.yml",
+              path: @configuration.config_display_path,
               line: 1,
               column: 1,
               message: "dependencies.source_inference[].gem #{entry.gem_name.inspect} could not be " \
@@ -227,7 +219,7 @@ module Rigor
         def dependency_source_config_conflict_diagnostics
           @configuration.dependencies.warnings.map do |message|
             Diagnostic.new(
-              path: ".rigor.yml",
+              path: @configuration.config_display_path,
               line: 1,
               column: 1,
               message: message,
@@ -242,7 +234,7 @@ module Rigor
           budget = @configuration.dependencies.budget_per_gem
           dependency_source_index.budget_exceeded.map do |gem_name|
             Diagnostic.new(
-              path: ".rigor.yml",
+              path: @configuration.config_display_path,
               line: 1,
               column: 1,
               message: "dependencies.source_inference[].gem #{gem_name.inspect} exceeded the per-gem " \
@@ -258,7 +250,8 @@ module Rigor
 
         # O4 Layer 3 slice 3 — graceful-degradation coverage report. When the project has a `Gemfile.lock`
         # (slice 1) and one or more locked gems are not covered by ANY of the four RBS resolution paths
-        # (`DEFAULT_LIBRARIES`, `data/vendored_gem_sigs/`, slice-1 bundle-shipped `sig/`, slice-2
+        # (the resolved library list — `DEFAULT_LIBRARIES` + `libraries:` + the collection lockfile's stdlib
+        # entries, `data/vendored_gem_sigs/`, slice-1 bundle-shipped `sig/`, slice-2
         # `rbs_collection.lock.yaml`), emit a single `:info` diagnostic summarising the uncovered set so the
         # user can act on it (run `rbs collection install`, opt the gem into `dependencies.source_inference:`,
         # or accept the `Dynamic[T]` fallback).
@@ -271,6 +264,9 @@ module Rigor
             project_root: Dir.pwd,
             auto_detect: @configuration.bundler_auto_detect
           )
+          # Issue #2441 — the project's own path gems are not dependencies missing RBS; the environment skips
+          # their collection copy, so the same set leaves the report here.
+          locked = locked.except(*project_own_gem_names(locked))
           return [] if locked.empty?
 
           bundle_sig_paths = Environment::BundleSigDiscovery.discover(
@@ -286,7 +282,7 @@ module Rigor
           )
           rows = Environment::RbsCoverageReport.classify(
             locked_gems: locked,
-            default_libraries: Environment::DEFAULT_LIBRARIES,
+            default_libraries: resolved_default_libraries,
             bundle_sig_paths: bundle_sig_paths,
             rbs_collection_paths: collection_paths
           )
@@ -296,6 +292,65 @@ module Rigor
           [build_rbs_coverage_missing_diagnostic(missing)]
         end
 
+        # Issue #3030 — one `:info` when the run found no `rbs_collection.lock.yaml` but the directory looks set up for
+        # one ({Environment::RbsCollectionDiscovery.missing_lockfile_hint}): the dependency RBS a collection would
+        # load is absent, and Rigor does not resolve it from `manifest.yaml` or a gemspec itself.
+        def rbs_collection_setup_hint_diagnostics
+          # The run-result key and the `--incremental` fingerprint carry the same answer ({RunCacheKey}).
+          hint = RunCacheKey.collection_setup_hint(@configuration)
+          return [] if hint.nil?
+
+          [build_rbs_collection_setup_hint_diagnostic(hint)]
+        end
+
+        RBS_COLLECTION_SETUP_STEPS = {
+          collection_test_dir: "This looks like a gem_rbs_collection test directory: run the collection's " \
+                               "`bin/test` setup for this gem first (it writes the lockfile and " \
+                               "`.gem_rbs_collection/`), then run Rigor here again.",
+          collection_config: "An `rbs_collection.yaml` is here: run `rbs collection install` to write the " \
+                             "lockfile, then run Rigor again."
+        }.freeze
+        private_constant :RBS_COLLECTION_SETUP_STEPS
+
+        def build_rbs_collection_setup_hint_diagnostic(hint)
+          Diagnostic.new(
+            path: @configuration.config_display_path,
+            line: 1,
+            column: 1,
+            message: "No `rbs_collection.lock.yaml` was found, so no `rbs collection` RBS was loaded: the signatures " \
+                     "of this directory's gem dependencies are absent and calls into them read `Dynamic[top]`. " \
+                     "#{RBS_COLLECTION_SETUP_STEPS.fetch(hint)}",
+            severity: :info,
+            rule: "rbs.coverage.collection-not-installed",
+            source_family: :builtin
+          )
+        end
+
+        # Issue #2962 — the library list is {Environment::BaseLibraries.resolve}'s, the same merge
+        # `Environment.for_project` loads, so a gem covered through `libraries:` or a lockfile stdlib
+        # entry is not reported missing. Only the names the environment loads count ({LibraryProbe.loadable}): a
+        # locked gem named there that RBS has no library for is still missing.
+        def resolved_default_libraries
+          resolved = Environment::BaseLibraries.resolve(
+            @configuration.libraries,
+            rbs_collection_lockfile: @configuration.rbs_collection_lockfile,
+            rbs_collection_auto_detect: @configuration.rbs_collection_auto_detect,
+            root: Dir.pwd
+          )
+          LibraryProbe.loadable(resolved)
+        end
+        private :resolved_default_libraries
+
+        # Issue #2441 — the same project-own set `Environment.for_project` skips the collection copy of.
+        def project_own_gem_names(locked)
+          Environment::ProjectPathGems.names(
+            locked,
+            paths: @configuration.paths, root: Dir.pwd,
+            exclude_patterns: @configuration.exclude_patterns, exclude_base: @configuration.exclude_base
+          )
+        end
+        private :project_own_gem_names
+
         # ADR-93 WD3 — the standalone residual. A bare `gem install rigortype` has no `rbs-inline` library,
         # so the spec's "annotations are official type sources whenever present" cannot be satisfied: the
         # annotated code reads `Dynamic[top]`. When the library is absent AND the project actually carries
@@ -342,7 +397,7 @@ module Rigor
 
         def build_rbs_inline_unsynthesized_diagnostic(sample_path)
           Diagnostic.new(
-            path: ".rigor.yml",
+            path: @configuration.config_display_path,
             line: 1,
             column: 1,
             message: "Inline rbs-inline annotations (`# @rbs …`, `#: <type>`) are present in your project " \
@@ -379,7 +434,7 @@ module Rigor
         # the `reject-unparseable-signatures` feature promotes this rule to `:error` for anyone who opts in
         # (and by default at the next major).
         def rbs_quarantined_signature_diagnostics
-          quarantined = quarantined_signatures_snapshot
+          quarantined = @snapshots[:quarantined_signatures]
           return [] if quarantined.empty?
 
           [build_rbs_quarantined_signature_diagnostic(quarantined)]
@@ -400,7 +455,7 @@ module Rigor
         # `reject-unparseable-signatures` bleeding-edge feature promotes it to `:error` for anyone who opts in
         # (and by default at the next major).
         def rbs_environment_build_failed_diagnostics
-          failure = env_build_failure_snapshot
+          failure = @snapshots[:env_build_failure]
           return [] if failure.nil?
 
           [build_rbs_environment_build_failed_diagnostic(failure)]
@@ -426,7 +481,7 @@ module Rigor
         # a Rigor release turn a green build red with no user change (ADR-5 / AGENTS.md § FP discipline).
         # The `reject-unparseable-signatures` bleeding-edge feature promotes it to `:error`.
         def rbs_definition_build_failed_diagnostics
-          failures = definition_build_failures_snapshot
+          failures = @snapshots[:definition_build_failures]
           return [] if failures.nil? || failures.empty?
 
           [build_rbs_definition_build_failed_diagnostic(failures)]
@@ -445,14 +500,14 @@ module Rigor
         # surface, no signature file is skipped, the environment builds. That is why this sits LAST on the
         # ladder, after its two `rbs.coverage.*` siblings above.
         def rbs_hkt_scan_failed_diagnostics
-          failure = hkt_scan_failure_snapshot
+          failure = @snapshots[:hkt_scan_failure]
           return [] if failure.nil?
 
           [build_rbs_hkt_scan_failed_diagnostic(failure)]
         end
 
         def rbs_synthesized_namespace_diagnostics
-          synthesized = synthesized_namespaces_snapshot
+          synthesized = @snapshots[:synthesized_namespaces]
           return [] if synthesized.nil? || synthesized.empty?
 
           [build_rbs_synthesized_namespace_diagnostic(synthesized)]
@@ -465,10 +520,12 @@ module Rigor
         # typing they are not getting and why, and — unlike the quarantine row this file used to be
         # misreported as — is not sent to remove a declaration the plugin owns.
         def rbs_plugin_signature_stood_down_diagnostics
-          standdowns = signature_standdowns_snapshot
+          standdowns = @snapshots[:signature_standdowns]
           return [] if standdowns.nil? || standdowns.empty?
 
-          standdowns.map { |entry| build_rbs_plugin_signature_stood_down_diagnostic(entry) }
+          members, files = standdowns.partition { |entry| entry[5] == :member }
+          files.map { |entry| build_rbs_plugin_signature_stood_down_diagnostic(entry) } +
+            members.group_by(&:first).map { |path, rows| build_rbs_plugin_member_stood_down_diagnostic(path, rows) }
         end
 
         # Issue #1713 — the other outcome that avoided a definition-build failure: a required-feature-gated
@@ -476,7 +533,7 @@ module Rigor
         # declares — a member, a whole type, or, when nothing narrower built, the directory. One `:info` per
         # directory, naming the declarations that stood down and the files that displaced them.
         def rbs_vendored_signature_stood_down_diagnostics
-          standdowns = vendored_standdowns_snapshot
+          standdowns = @snapshots[:vendored_standdowns]
           return [] if standdowns.nil? || standdowns.empty?
 
           standdowns.map { |entry| build_rbs_vendored_signature_stood_down_diagnostic(entry) }
@@ -498,7 +555,7 @@ module Rigor
         # conformance; every analysis path, pooled or degraded, takes the snapshot `synthesized_namespaces`
         # comes from.
         def conforms_to_diagnostics
-          results = conformance_results_snapshot
+          results = @snapshots[:conformance_results]
           return [] if results.nil? || results.empty?
 
           results.map { |record| build_conformance_diagnostic(record) }
@@ -570,7 +627,7 @@ module Rigor
           sample = quarantined.first(sample_size).map { |path, _first_line| relative_signature_path(path) }
           suffix = quarantined.size > sample_size ? ", and #{quarantined.size - sample_size} more" : ""
           Diagnostic.new(
-            path: ".rigor.yml",
+            path: @configuration.config_display_path,
             line: 1,
             column: 1,
             message: "#{quarantined.size} RBS file(s) under `signature_paths:` were SKIPPED " \
@@ -593,7 +650,7 @@ module Rigor
           suffix = files.size > sample_size ? ", and #{files.size - sample_size} more" : ""
           conflicts = sample.empty? ? "" : " Conflicting signature file(s): #{sample.join(', ')}#{suffix}."
           Diagnostic.new(
-            path: ".rigor.yml",
+            path: @configuration.config_display_path,
             line: 1,
             column: 1,
             message: "The RBS environment failed to build (#{error_class}): #{first_line}.#{conflicts} " \
@@ -630,9 +687,9 @@ module Rigor
           failures = failures.sort_by { |failure| failure.first.to_s }
           sample_size = 5
           files = failures.flat_map { |failure| Array(failure[3]) }
-                          .map { |name| relative_signature_path(name) }.uniq.sort
+                          .map { |name| signature_source_label(name.to_s) }.uniq.sort
           Diagnostic.new(
-            path: ".rigor.yml",
+            path: @configuration.config_display_path,
             line: 1,
             column: 1,
             message: "#{failures.size} RBS class definition(s) failed to build: " \
@@ -641,32 +698,120 @@ module Rigor
                      "Rigor still treats each class as KNOWN, so calls into it — real methods and typos " \
                      "alike — silently read `Dynamic[top]` instead of resolving, and this run is quieter " \
                      "than it should be rather than cleaner. #{definition_build_advice(failures.first)}",
-            severity: :warning,
+            severity: selected_core_failure?(failures) ? :error : :warning,
             rule: "rbs.coverage.definition-build-failed",
             source_family: :builtin
           )
         end
 
+        # Issue #2517 — a class that does not build from the selected `core_root:` alone is that explicit choice
+        # failing, not a Rigor release disagreeing with the user's `sig/`, so it is an error. A failure that also
+        # names a file outside the core (a project `sig/` collision) keeps the warning it has without one.
+        def selected_core_failure?(failures)
+          core_root = @configuration.core_root
+          return false if core_root.nil?
+
+          prefix = File.join(core_root, "")
+          failures.any? do |failure|
+            buffers = Array(failure[3]).map(&:to_s)
+            !buffers.empty? && buffers.all? { |name| name.start_with?(prefix) }
+          end
+        end
+
         # The closing advice follows the FIRST failure's error class: `GenericParameterMismatchError` is two
         # declarations of one CLASS at different generic arity (#610); `NoTypeFoundError` (issue #997) is
         # ONE declaration naming a type that does not exist, which "remove the duplicate declaration" sends
         # its reader after a duplicate that is not there — the fifth tuple element
-        # ({RbsLoader#unresolved_type_name_detail}) is non-nil for exactly that case. Every other error class
-        # (the two duplicated-definition errors, `RecursiveAncestorError`, …) keeps the duplicate-declaration
-        # wording, which is accurate for them.
+        # ({RbsLoader#unresolved_type_name_detail}) is non-nil for exactly that case. Issue #2440 — a
+        # duplicated instance variable, a superclass mismatch, a missing superclass and a type applied to
+        # the wrong arguments each get their own sentence, and when a `virtual:` (inline RBS) buffer is
+        # among the colliding sources the advice never tells the reader to remove it as if it were a file.
+        # Every other error class (the two duplicated-definition errors, `RecursiveAncestorError`, …) keeps
+        # the duplicate-declaration wording, which is accurate for them.
         def definition_build_advice(failure)
-          _, error_class, _member, _buffers, unresolved = failure
-          if error_class.to_s.end_with?("GenericParameterMismatchError")
+          _, error_class, member, buffers, unresolved = failure
+          inline = Array(buffers).any? { |name| name.to_s.start_with?("virtual:") }
+          case error_class.to_s.split("::").last
+          when "GenericParameterMismatchError"
             "Two signature sources declare the class with a different number of type parameters; make " \
-              "the declarations agree (`rbs validate`) to restore type coverage."
-          elsif unresolved
-            unresolved_type_name_advice(unresolved)
+            "the declarations agree (`rbs validate`) to restore type coverage."
+          when "InstanceVariableDuplicationError" then variable_duplication_advice("instance variable", failure)
+          when "ClassInstanceVariableDuplicationError"
+            variable_duplication_advice("class instance variable", failure)
+          when "SuperclassMismatchError" then superclass_mismatch_advice(inline)
+          when "NoSuperclassFoundError" then no_superclass_advice(member)
+          when "InvalidTypeApplicationError" then invalid_type_application_advice(member)
           else
+            return unresolved_type_name_advice(unresolved) if unresolved
+
             "Two signature sources declare the same member; remove the duplicate declaration " \
               "(`rbs validate`) to restore type coverage."
           end
         end
 
+        # The sixth tuple slot ({RbsLoader#variable_mixin_count}) is set only when the failing class mixes in
+        # the variable's owner at least twice and the owner declares it once: rbs counts the variable once per
+        # mixin. Otherwise — a variable duplicated in the owner itself, inherited or not — the wording follows
+        # which sources collide: inline only, inline and a file, two files, or one file declaring it twice.
+        def variable_duplication_advice(noun, failure)
+          class_name, _, member, buffers, _, mixins = failure
+          if mixins.is_a?(Integer) && mixins >= 2
+            return mixin_variable_duplication_advice(noun, class_name.to_s.delete_prefix("::"),
+                                                     member.to_s.delete_prefix("::"))
+          end
+
+          names = Array(buffers).map(&:to_s)
+          inline = names.count { |name| name.start_with?("virtual:") }
+          if inline >= 2 && inline == names.size
+            "Two inline `# @rbs` annotations declare the same #{noun} in one class, and RBS rejects the " \
+              "pair even when the types agree; keep one of them to restore type coverage."
+          elsif inline.positive?
+            "The same #{noun} is declared twice in one class, at least once by an inline `# @rbs` " \
+              "annotation, and RBS rejects the pair even when the types agree. Keep one declaration: " \
+              "regenerate the committed `.rbs` (`rbs-inline --output`) or remove its copy of the " \
+              "variable, or drop the annotation from the `.rb` file, to restore type coverage."
+          elsif names.size >= 2
+            "Two signature files declare the same #{noun} in one class, and RBS rejects the pair even " \
+              "when the types agree; keep one declaration (`rbs validate`) to restore type coverage."
+          else
+            "The same #{noun} is declared twice in one class, and RBS rejects the pair even when the " \
+              "types agree; keep one declaration (`rbs validate`) to restore type coverage."
+          end
+        end
+
+        def mixin_variable_duplication_advice(noun, klass, owner)
+          "`#{klass}` mixes in `#{owner}` (`include`, `extend` or `prepend`) more than once, in one " \
+            "declaration or across several, and RBS counts each #{noun} `#{owner}` declares once per mixin. " \
+            "Keep a single mixin of `#{owner}` in `#{klass}` (a committed `rbs-inline --output` file and the " \
+            "`.rb` file it came from count as two declarations) to restore type coverage."
+        end
+
+        def superclass_mismatch_advice(inline)
+          advice = "Two declarations of the class name different superclasses; make them name the same " \
+                   "one, or leave the superclass off every declaration but one (a reopening needs none), " \
+                   "to restore type coverage."
+          return advice unless inline
+
+          "#{advice} Where one side is an inline annotation, fix the annotation and regenerate the " \
+            "committed `.rbs` (`rbs-inline --output`), or remove the committed copy."
+        end
+
+        def no_superclass_advice(member)
+          name = member.to_s.delete_prefix("::")
+          subject = name.empty? ? "A superclass" : "`#{name}`"
+          "#{subject} is named as a superclass, but no loaded signature declares it; declare it in your " \
+            "`sig/` (or load the library that does through `libraries:`), or re-run `rigor sig-gen` if " \
+            "the signature was generated, to restore type coverage."
+        end
+
+        def invalid_type_application_advice(member)
+          name = member.to_s.delete_prefix("::")
+          subject = name.empty? ? "a type" : "`#{name}`"
+          "A signature applies #{subject} with the wrong number of type arguments, or applies them to the " \
+            "wrong class; match the arguments to the type parameters the class declares (`rbs validate`) " \
+            "to restore type coverage."
+        end
+
         # Issue #997 — `unresolved` is {RbsLoader#unresolved_type_name_detail}'s `[token, location,
         # refinement_hint]`. `refinement_hint` turns the message into a fix: the token is not a typo to
         # chase down but the start of a Rigor refinement name that is not valid in an RBS type position, and
@@ -741,7 +886,7 @@ module Rigor
           frame_clause = relative_frame ? " at #{relative_frame}" : ""
           raised = "(#{error_class}): #{first_line}#{frame_clause}."
           Diagnostic.new(
-            path: ".rigor.yml",
+            path: @configuration.config_display_path,
             line: 1,
             column: 1,
             message: stage == :overlay ? hkt_overlay_failed_message(raised) : hkt_scan_failed_message(raised),
@@ -777,6 +922,15 @@ module Rigor
         end
 
         # The absolute path is what the loader records; the user thinks in project-relative terms.
+        # Issue #2440 — a `virtual:<plugin>:<path>` buffer is named by the `.rb` file it was synthesized
+        # from, which is the file the user can open; the plugin id says how it became RBS.
+        def signature_source_label(name)
+          prefix, plugin_id, path = name.split(":", 3)
+          return relative_signature_path(name) unless prefix == "virtual" && plugin_id && path && !path.empty?
+
+          "#{relative_signature_path(path)} (inline RBS via #{plugin_id})"
+        end
+
         def relative_signature_path(path)
           root = "#{Dir.pwd}#{File::SEPARATOR}"
           path.start_with?(root) ? path.delete_prefix(root) : path
@@ -787,7 +941,7 @@ module Rigor
           sample = synthesized.first(sample_size)
           suffix = synthesized.size > sample_size ? ", and #{synthesized.size - sample_size} more" : ""
           Diagnostic.new(
-            path: ".rigor.yml",
+            path: @configuration.config_display_path,
             line: 1,
             column: 1,
             message: "#{synthesized.size} RBS namespace(s) under `signature_paths:` are " \
@@ -806,7 +960,7 @@ module Rigor
           path, class_name, existing_arity, incoming_arity, existing_file = entry
           displaced_by = displacing_source_phrase(existing_file)
           Diagnostic.new(
-            path: ".rigor.yml",
+            path: @configuration.config_display_path,
             line: 1,
             column: 1,
             message: "`#{relative_signature_path(path.to_s)}` (a signature file a plugin contributes) declares " \
@@ -824,10 +978,37 @@ module Rigor
           )
         end
 
+        # Issue #2422 — one plugin signature file that loaded without the declarations another source also makes,
+        # naming each (sampled) with the file whose declaration was used instead. One row per file, not per
+        # declaration: an `rbs collection install` of a gem can overlap the plugin for it on hundreds. A method
+        # that composed with the other source's as an overload is not here; the plugin's overloads still bind.
+        # The wording covers a superclass a plugin's class header gave up (#2439) as well as a member.
+        def build_rbs_plugin_member_stood_down_diagnostic(path, rows)
+          labels = rows.map do |_path, declaration, _, _, cause_file|
+            cause = cause_file.nil? || cause_file.empty? ? "" : " (#{relative_signature_path(cause_file.to_s)})"
+            "`#{declaration}`#{cause}"
+          end
+          Diagnostic.new(
+            path: @configuration.config_display_path,
+            line: 1,
+            column: 1,
+            message: "`#{relative_signature_path(path.to_s)}` (a signature file a plugin contributes) loaded without " \
+                     "#{rows.size} declaration(s) another signature source already makes: #{sampled(labels, 10)}. " \
+                     "Conflicting declarations (two of one method or constant, or two different superclasses " \
+                     "of one class) fail the build, so the plugin's stood down and the other source's, named in " \
+                     "parentheses, is used; the rest of the plugin's file still " \
+                     "loads. Nothing to fix unless you want the plugin's typing back, which needs that source to " \
+                     "stop declaring it.",
+            severity: :info,
+            rule: "rbs.coverage.plugin-signature-stood-down",
+            source_family: :builtin
+          )
+        end
+
         def build_rbs_vendored_signature_stood_down_diagnostic(entry)
           dir, declarations, whole = entry
           Diagnostic.new(
-            path: ".rigor.yml",
+            path: @configuration.config_display_path,
             line: 1,
             column: 1,
             message: vendored_standdown_message(dir, declarations, whole),
@@ -906,7 +1087,7 @@ module Rigor
           sample = missing.first(sample_size).map(&:gem_name)
           suffix = missing.size > sample_size ? ", and #{missing.size - sample_size} more" : ""
           Diagnostic.new(
-            path: ".rigor.yml",
+            path: @configuration.config_display_path,
             line: 1,
             column: 1,
             message: "#{missing.size} gem(s) in Gemfile.lock have no RBS available: " \
@@ -936,9 +1117,12 @@ module Rigor
         # all three cross the pool drain channel (see {RbsExtended::Reporter}); an entry with no position
         # falls back to `.rigor.yml`-style file-level attribution.
         def rbs_extended_reporter_diagnostics
-          return [] if @rbs_extended_reporter.empty?
+          unresolved_payload_diagnostics + lossy_projection_diagnostics + hkt_directive_diagnostics +
+            deprecated_form_diagnostics
+        end
 
-          unresolved = @rbs_extended_reporter.unresolved_payloads.map do |entry|
+        def unresolved_payload_diagnostics
+          @rbs_extended_reporter.unresolved_payloads.map do |entry|
             build_positioned_reporter_diagnostic(
               entry,
               rule: "dynamic.rbs-extended.unresolved",
@@ -947,8 +1131,10 @@ module Rigor
                        "that contributes the referenced type vocabulary."
             )
           end
+        end
 
-          lossy = @rbs_extended_reporter.lossy_projections.map do |entry|
+        def lossy_projection_diagnostics
+          @rbs_extended_reporter.lossy_projections.map do |entry|
             build_positioned_reporter_diagnostic(
               entry,
               rule: "dynamic.shape.lossy-projection",
@@ -957,8 +1143,6 @@ module Rigor
                        "a `HashShape` / `Tuple` carrier or accept the unchanged result."
             )
           end
-
-          unresolved + lossy + hkt_directive_diagnostics + deprecated_form_diagnostics
         end
 
         # ADR-109 WD3 — one row per annotation still written in a spelling the grammar accepts but no
@@ -1069,7 +1253,7 @@ module Rigor
 
           @boundary_cross_reporter.entries.map do |entry|
             Diagnostic.new(
-              path: ".rigor.yml", line: 1, column: 1,
+              path: @configuration.config_display_path, line: 1, column: 1,
               message: "`#{entry.class_name}##{entry.method_name}` is contributed by both " \
                        "RBS (#{entry.rbs_display}) and the `mode: :full` opt-in gem " \
                        "`#{entry.gem_name}`. RBS wins on dispatch; verify the gem source " \
@@ -1196,7 +1380,7 @@ module Rigor
 
         def run_disclosure_diagnostic(record)
           Diagnostic.new(
-            path: ".rigor.yml", line: 1, column: 1,
+            path: @configuration.config_display_path, line: 1, column: 1,
             message: record.fetch(:message),
             severity: record.fetch(:severity),
             rule: record.fetch(:rule),
@@ -1239,7 +1423,7 @@ module Rigor
         def plugin_trust_refusal_diagnostic(plugin, summary)
           plugin_id = plugin.manifest.id
           Diagnostic.new(
-            path: ".rigor.yml", line: 1, column: 1,
+            path: @configuration.config_display_path, line: 1, column: 1,
             message: "plugin #{plugin_id.inspect} had #{summary[:count]} read(s) refused by the trust " \
                      "policy; first refused path: #{summary[:first_path].inspect}, outside read root " \
                      "#{summary[:nearest_root].inspect}. Spell the path the way that read root spells it " \
@@ -1330,38 +1514,6 @@ module Rigor
         def pre_eval_diagnostics_from_scanner
           @pre_eval_diagnostics_from_scanner_reader.call
         end
-
-        def synthesized_namespaces_snapshot
-          @synthesized_namespaces_snapshot_reader.call
-        end
-
-        def quarantined_signatures_snapshot
-          @quarantined_signatures_snapshot_reader.call
-        end
-
-        def signature_standdowns_snapshot
-          @signature_standdowns_snapshot_reader.call
-        end
-
-        def vendored_standdowns_snapshot
-          @vendored_standdowns_snapshot_reader.call
-        end
-
-        def env_build_failure_snapshot
-          @env_build_failure_snapshot_reader.call
-        end
-
-        def definition_build_failures_snapshot
-          @definition_build_failures_snapshot_reader.call
-        end
-
-        def hkt_scan_failure_snapshot
-          @hkt_scan_failure_snapshot_reader.call
-        end
-
-        def conformance_results_snapshot
-          @conformance_results_snapshot_reader.call
-        end
       end
     end
   end