rigortype 0.4.1 → 0.4.2

data/lib/rigor/cli/unused_command.rb

@@ -51,7 +51,7 @@ module Rigor
         paths = @argv.empty? ? configuration.paths : @argv
         scan_cache = Analysis::Reachability::ScanCache.open(configuration.cache_path,
                                                             target_ruby: configuration.target_ruby)
-        declarations, references, dynamic_uses = scan(paths, configuration, scan_cache)
+        declarations, references, dynamic_uses, shadows = scan(paths, configuration, scan_cache)
         references.concat(signature_references(configuration))
         dynamic_uses.concat(template_mentions(declarations, scan_cache))
 
@@ -59,7 +59,8 @@ module Rigor
                                                                    cache_store: cache_store(configuration))
         references.concat(plugin_references(contribution.references))
         graph = build_graph(configuration, options, contribution,
-                            declarations: declarations, references: references, dynamic_uses: dynamic_uses)
+                            declarations: declarations, references: references, dynamic_uses: dynamic_uses,
+                            shadows: shadows)
         emit(graph.report, options, supply: root_supply(contribution.roots, declarations))
         scan_cache.save
         0
@@ -67,9 +68,9 @@ module Rigor
 
       private
 
-      def build_graph(configuration, options, contribution, declarations:, references:, dynamic_uses:)
+      def build_graph(configuration, options, contribution, declarations:, references:, dynamic_uses:, shadows:)
         Analysis::Reachability::Graph.new(
-          declarations: declarations, references: references, dynamic_uses: dynamic_uses,
+          declarations: declarations, references: references, dynamic_uses: dynamic_uses, shadows: shadows,
           root_fqns: root_fqns(declarations, options.fetch(:entry_points)) + contribution.roots,
           foreign: foreign_predicate(configuration)
         )
@@ -106,22 +107,25 @@ module Rigor
       end
 
       # Declarations come from the analysed paths; references additionally from the wider corpus (WD7).
+      # A wider-corpus file's own declarations come back as shadows: never nodes, only what that file's own
+      # references resolve to first (#1732).
       # Every file is consulted every run — an unchanged one contributes its cached scan, so the
       # whole-project completeness the `--incremental` refusal protects is unaffected.
       def scan(paths, configuration, cache)
         declaration_files = Analysis::PathExpansion.ruby_files(paths, configuration.exclude_patterns).to_set
         declarations = []
+        shadows = []
         references = []
         dynamic_uses = []
         (declaration_files + reference_files(paths, configuration)).sort.each do |file|
           result = cache.serve(:scan, file) { read_and_scan(file, configuration) }
           next if result.nil?
 
-          declarations.concat(result.declarations) if declaration_files.include?(file)
+          (declaration_files.include?(file) ? declarations : shadows).concat(result.declarations)
           references.concat(result.references)
           dynamic_uses.concat(result.dynamic_uses)
         end
-        [declarations, references, dynamic_uses]
+        [declarations, references, dynamic_uses, shadows]
       end
 
       # The reference corpus is the PROJECT, not the analysed paths. A constant declared in `lib/` is commonly
@@ -137,7 +141,8 @@ module Rigor
 
       def read_and_scan(file, configuration)
         Analysis::Reachability::Scan.call(path: file, source: File.read(file),
-                                          target_ruby: configuration.target_ruby)
+                                          target_ruby: configuration.target_ruby,
+                                          root: File.absolute_path(Dir.pwd))
       rescue SystemCallError
         nil
       end
@@ -235,6 +240,7 @@ module Rigor
       def foreign_predicate(configuration)
         env = Environment.for_project(libraries: configuration.libraries, signature_paths: [],
                                       cache_store: cache_store(configuration),
+                                      required_features: ProjectEnvironment.required_features(configuration),
                                       **ProjectEnvironment.dependency_discovery_options(configuration))
         ->(fqn) { !env.singleton_for_name(fqn).nil? }
       rescue StandardError

data/lib/rigor/cli.rb

@@ -281,6 +281,10 @@ module Rigor
         # tempfile, uri, logger, date, prism, rbs). Adding a
         # `sig/<gem>.rbs` file under `sig/` is the simplest way
         # to extend type coverage today.
+        #
+        # `target_ruby` is left commented: the default only picks the syntax Rigor parses. Set it to the lowest
+        # Ruby your project runs on, and Rigor also reports what that Ruby deprecates.
+        # target_ruby: #{Configuration::DEFAULTS.fetch('target_ruby').dump}
         #{YAML.dump(init_settings(path)).sub(/\A---\n/, '')}
       YAML
     end
@@ -288,13 +292,17 @@ module Rigor
     # The settings `rigor init` writes: the defaults, with `test_paths:` spelled out as the test roots found now, so
     # the project's config says where its tests are rather than leaving it to auto-detection. The roots are written
     # relative to the config file's directory, which is what {Configuration.load} resolves them against.
+    #
+    # `target_ruby` is left out (the template writes it commented): a written key is a statement about the runtime
+    # (#1692), and the starter must not make one the user never chose.
     def init_settings(path)
+      settings = Configuration::DEFAULTS.except("target_ruby")
       test_paths = Configuration.new.resolved_test_paths
-      return Configuration::DEFAULTS if test_paths.empty?
+      return settings if test_paths.empty?
 
       config_dir = Pathname(File.absolute_path(File.dirname(path)))
       relative = test_paths.map { |root| Pathname(root).relative_path_from(config_dir).to_s }
-      Configuration::DEFAULTS.merge("test_paths" => relative)
+      settings.merge("test_paths" => relative)
     end
 
     def run_annotate

data/lib/rigor/configuration/severity_profile.rb

@@ -38,6 +38,10 @@ module Rigor
           "call.argument-type-mismatch" => :warning,
           "call.possible-nil-receiver" => :warning,
           "call.raise-non-exception" => :warning,
+          # Issue #1692 — the code runs on the stated Ruby (it warns, and breaks only at the removal version), so the
+          # rule takes the slot of the rules that report working-but-wrong code: `flow.unreachable-branch`'s
+          # info / warning / error. It runs only under an explicit `target_ruby` of 4.1 or later.
+          "call.deprecated-ruby2-keywords" => :info,
           "flow.always-raises" => :warning,
           "flow.unreachable-branch" => :info,
           "flow.dead-assignment" => :info,
@@ -100,6 +104,7 @@ module Rigor
           "call.argument-type-mismatch" => :error,
           "call.possible-nil-receiver" => :error,
           "call.raise-non-exception" => :error,
+          "call.deprecated-ruby2-keywords" => :warning,
           "flow.always-raises" => :error,
           "flow.unreachable-branch" => :warning,
           "flow.dead-assignment" => :warning,
@@ -141,6 +146,7 @@ module Rigor
           "call.argument-type-mismatch" => :error,
           "call.possible-nil-receiver" => :error,
           "call.raise-non-exception" => :error,
+          "call.deprecated-ruby2-keywords" => :error,
           "flow.always-raises" => :error,
           "flow.unreachable-branch" => :error,
           "flow.dead-assignment" => :error,

data/lib/rigor/configuration.rb

@@ -283,6 +283,23 @@ module Rigor
                 :effects_snapshot_path, :effects_snapshot_reach, :effects_snapshot_gate, :effects_tolerated,
                 :effects_labels, :effects_attribution, :effects_envelopes
 
+    # ADR-47 WD5 amendment (#1692) — whether `.rigor.yml` (or its `includes:` chain) set `target_ruby:` itself.
+    # The default `"4.0"` is a parse version, not something the user said about the Ruby the project runs on.
+    def target_ruby_explicit?
+      @target_ruby_explicit
+    end
+
+    # ADR-47 WD5 amendment (#1692) — `target_ruby` read as a user statement about the runtime: the configured
+    # version when the user set it explicitly, nil when it is the default or `"latest"`. `"latest"` names the
+    # newest syntax this Prism build parses, which moves with a Rigor upgrade, so it states no runtime. Only the
+    # Ruby-deprecation rules read this; `Inference::VersionGuard` keeps the analyzer's own `RUBY_VERSION`.
+    def stated_runtime_ruby
+      return nil unless target_ruby_explicit?
+      return nil if target_ruby == "latest"
+
+      target_ruby
+    end
+
     # ADR-103 WD13 — whether effect collection runs. True exactly when the loaded configuration carried an
     # `effects:` block, whatever its body; `rigor effects` enables it for its own run by loading an
     # implicit `effects: {}` instead of by consulting anything else. Nothing else — no annotation, no
@@ -327,6 +344,7 @@ module Rigor
       if resolved.nil? || !File.exist?(resolved)
         data = DEFAULTS
         effects_key_present = false
+        target_ruby_key_present = false
       else
         # ADR-103 WD15 — captured from the RAW, pre-`DEFAULTS.merge` file (+ its `includes:` chain) because
         # `DEFAULTS` itself carries an `"effects" => false` entry: once merged, "the file never wrote
@@ -334,9 +352,10 @@ module Rigor
         # indistinguishable to {#initialize}. This is the only place that distinction still exists.
         raw = load_with_includes(resolved)
         effects_key_present = raw.key?("effects")
+        target_ruby_key_present = raw.key?("target_ruby")
         data = DEFAULTS.merge(raw)
       end
-      new(autowire_default_plugins(data), effects_key_present)
+      new(autowire_default_plugins(data), effects_key_present, target_ruby_key_present || false)
     end
 
     # ADR-93 WD2 — the one bundled plugin default-wired without a `plugins:` entry. `rigor-rbs-inline` is the
@@ -519,7 +538,13 @@ module Rigor
     #   `"key" => value` hash literal — this class's usual call shape, all over the spec suite — is coerced
     #   into keyword arguments by Ruby whenever the method declares ANY keyword parameter, which would break
     #   every `Configuration.new("some_key" => value)` call site with an "unknown keyword" `ArgumentError`.
-    def initialize(data = DEFAULTS, effects_key_present = data.key?("effects"))
+    # @param target_ruby_key_present — ADR-47 WD5 amendment (#1692) — whether the file set `target_ruby:` itself,
+    #   captured before `DEFAULTS.merge` for the same reason as `effects_key_present` and positional for the same
+    #   reason. See {#stated_runtime_ruby}. The default reads the key off `data`, which is right only for a hash that
+    #   has not been through `DEFAULTS.merge` (DEFAULTS carries the key); a caller that merges passes it explicitly.
+    #   The bare `Configuration.new` is not explicit.
+    def initialize(data = DEFAULTS, effects_key_present = data.key?("effects"),
+                   target_ruby_key_present = data.key?("target_ruby") && !data.equal?(DEFAULTS))
       # Record before the per-key fetches below discard the evidence. Top level only, deliberately —
       # see {ConfigAudit.unknown_key_warnings} for why a nested check cannot key on DEFAULTS.
       @unknown_keys = (data.keys.map(&:to_s) - KNOWN_KEYS).sort.freeze
@@ -528,6 +553,7 @@ module Rigor
       plugins_io = DEFAULTS.fetch("plugins_io").merge(data.fetch("plugins_io", {}))
 
       @target_ruby = coerce_target_ruby(data.fetch("target_ruby", DEFAULTS.fetch("target_ruby")))
+      @target_ruby_explicit = target_ruby_key_present ? true : false
       @paths = Array(data.fetch("paths", DEFAULTS.fetch("paths"))).map(&:to_s).freeze
       user_excludes = Array(data.fetch("exclude", DEFAULTS.fetch("exclude"))).map(&:to_s)
       @exclude_patterns = (BUILTIN_EXCLUDES + user_excludes).uniq.freeze
@@ -619,6 +645,9 @@ module Rigor
     def to_h # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
       {
         "target_ruby" => target_ruby,
+        # A stated `target_ruby` turns on the deprecation rules a defaulted one leaves off (#1692), so the run cache
+        # key and the incremental fingerprint must tell the two apart even where the value matches.
+        "target_ruby_explicit" => target_ruby_explicit?,
         "paths" => paths,
         "exclude" => exclude_patterns - BUILTIN_EXCLUDES,
         "plugins" => plugins,
@@ -717,6 +746,21 @@ module Rigor
       copy.freeze
     end
 
+    # #1777 — a sibling Configuration with only `baseline:` unset, every other field (including the
+    # explicitness of `target_ruby`) shared with the receiver. `rigor baseline generate` analyses with
+    # this so the generating run sees exactly the configuration `rigor check` will, minus the filter it
+    # is about to replace; rebuilding from a key list let each unlisted key revert to its default.
+    #
+    # Same frozen `dup` shape as {#with_bleeding_edge}. `@baseline_path` is the only ivar
+    # `#initialize` derives from the `baseline:` key.
+    def without_baseline
+      return self if baseline_path.nil?
+
+      copy = dup
+      copy.instance_variable_set(:@baseline_path, nil)
+      copy.freeze
+    end
+
     # ADR-103 WD14 — the ad-hoc opt-in `rigor effects` uses when the project's configuration carries no
     # `effects:` block: a sibling Configuration with an implicit empty block, every other field shared.
     # A configuration that already enables effects is returned unchanged, so a project's own settings

data/lib/rigor/environment/gated_signature_guard.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "rbs"
+
+module Rigor
+  class Environment
+    # Issue #1700 — the type names a {RequiredFeatures}-gated vendored directory declares, which
+    # `RbsLoader.gated_trouble` builds in its trial to decide whether the directory may stay in an environment.
+    # Read off the vendored files themselves: a nested `class Prime; class EratosthenesGenerator` names
+    # `Prime::EratosthenesGenerator`, and a reopened core class (`class Integer`) is named too, since a clash
+    # there fails `Integer`'s own definition.
+    module GatedSignatureGuard
+      module_function
+
+      # @param dir — the vendored directory (Pathname).
+      # @return the absolute-less names (`"Prime::PseudoPrimeGenerator"`) of every class and module it declares.
+      def type_names(dir)
+        Dir.glob(File.join(dir.to_s, "*.rbs")).flat_map do |file|
+          _, _, decls = RBS::Parser.parse_signature(File.read(file))
+          names(decls, nil)
+        rescue RBS::BaseError, SystemCallError
+          []
+        end.uniq
+      end
+
+      def names(decls, namespace)
+        decls.flat_map do |decl|
+          next [] unless decl.is_a?(RBS::AST::Declarations::Class) || decl.is_a?(RBS::AST::Declarations::Module)
+
+          name = qualify(namespace, decl.name)
+          [name] + names(decl.members, name)
+        end
+      end
+
+      def qualify(namespace, type_name)
+        text = type_name.to_s
+        return text.delete_prefix("::") if text.start_with?("::") || namespace.nil?
+
+        "#{namespace}::#{text}"
+      end
+    end
+  end
+end

data/lib/rigor/environment/gated_signature_plan.rb

@@ -0,0 +1,339 @@
+# frozen_string_literal: true
+
+require "rbs"
+
+module Rigor
+  class Environment
+    # Issue #1713 — loading a {RequiredFeatures}-gated vendored directory minus only what another signature
+    # source already declares, instead of standing the whole directory down.
+    #
+    # `RbsLoader.build_env_for` first tries the directory whole. When that costs the environment something
+    # (`RbsLoader.gated_failures`), it builds the environment WITHOUT the directory and plans against it with
+    # {.build}: the plan is the directory's parsed declarations, rewritten in memory (the files on disk are never
+    # touched), so that
+    #
+    # - a method, attribute or alias another source declares on the same class is left out (an overload
+    #   continuation, `def m: ... | ...`, declares nothing of its own and needs the vendored base, so it keeps
+    #   it); a member declaring two methods loses only the one taken — an `attr_accessor` narrows to its reader
+    #   or writer, a `def self?.m` to its instance or singleton side;
+    # - a type whose header disagrees with another source's — a class one side declares as a module, or a
+    #   different generic arity — stands down as a whole: its declaration becomes a *shell*, the other source's
+    #   header with no members and no superclass, which keeps the vendored types nested inside it in their
+    #   lexical context;
+    # - a type in `shelled` (the types the trial build of a previous plan still failed for) is shelled the same
+    #   way when another source declares it. When none does — the type failed because something it names was
+    #   displaced, a superclass the project redeclared as a module, say — it keeps its own members and nested
+    #   types but loses its superclass, and is stamped as a Rigor-synthesized stub type
+    #   (`RbsLoader::SYNTHETIC_STUB_BUFFER`): its own members still type, and a call it no longer answers reads
+    #   `Dynamic[top]` rather than drawing `call.undefined-method` for a method it inherits at runtime.
+    #
+    # The kept declarations load where the directory would have loaded, ahead of the project's signatures, so
+    # which declaration is a class's primary one does not move; the shells load after them, so a shell never
+    # becomes the primary declaration of a class the project declares. The trial build stays the arbiter:
+    # `build_env_for` keeps a plan's environment only when every gated type builds in it.
+    #
+    # {.standdowns} reads what stood down back off a built environment, the way the other `rbs.coverage.*`
+    # notices are derived, so a warm run off the env cache reports what the cold run reported.
+    module GatedSignaturePlan
+      # Buffer name stamped on the shell declarations. Never a real path, so {.standdowns} tells a shell from the
+      # vendored declaration it replaced by it.
+      SHELL_BUFFER = "(rigor: vendored stand-down shells)"
+
+      # The buffer names Rigor synthesizes declarations under. They stand for no source, so neither a plan nor
+      # a stand-down report reads them as another source's declaration.
+      def self.synthetic_buffers
+        [SHELL_BUFFER, RbsLoader::SYNTHETIC_NAMESPACE_BUFFER, RbsLoader::SYNTHETIC_STUB_BUFFER]
+      end
+
+      # A planned load: `leading` and `shells` are `[buffer, directives, decls]` sources, `changed` is false
+      # when the plan is the directory as it stands.
+      Plan = Data.define(:leading, :shells, :changed)
+
+      # One plan's walk over the vendored declarations: the environment it plans against, the types to shell
+      # whatever their headers, and whether anything was left out.
+      class Planner
+        attr_reader :changed
+
+        def initialize(base_env, shelled)
+          @base_env = base_env
+          @shelled = shelled
+          @changed = false
+        end
+
+        # Splits `decls` into what loads ahead of the project's signatures and what loads after them.
+        def plan_decls(decls, namespace)
+          lead = []
+          shell = []
+          decls.each do |decl|
+            unless GatedSignaturePlan.type_declaration?(decl)
+              lead << decl
+              next
+            end
+
+            kept, shelled = plan_type(decl, GatedSignaturePlan.qualify(namespace, decl.name))
+            lead << kept if kept
+            shell << shelled if shelled
+          end
+          [lead, shell]
+        end
+
+        private
+
+        def plan_type(decl, name)
+          others = GatedSignaturePlan.other_declarations(@base_env, name)
+          nested = decl.members.select { |member| GatedSignaturePlan.type_declaration?(member) }
+          nested_lead, nested_shell = plan_decls(nested, name)
+          if GatedSignaturePlan.header_conflict?(decl, others) || (@shelled.include?(name) && !others.empty?)
+            @changed = true
+            return [nil, GatedSignaturePlan.header_copy(others.first, decl.name, nested_lead + nested_shell)]
+          end
+          return [nil, open_type(decl, nested_lead + nested_shell)] if @shelled.include?(name)
+
+          wrapper = nested_shell.empty? ? nil : GatedSignaturePlan.header_copy(decl, decl.name, nested_shell)
+          [keep_type(decl, others, nested_lead), wrapper]
+        end
+
+        # `decl` less the methods `others` declare, with its nested types replaced by their planned kept halves.
+        def keep_type(decl, others, nested_lead)
+          taken = GatedSignaturePlan.declared_keys(others)
+          own = decl.members.reject { |member| GatedSignaturePlan.type_declaration?(member) }
+          members = own.filter_map { |member| GatedSignaturePlan.untaken(member, taken) }
+          @changed ||= members.size != own.size || members.zip(own).any? { |kept, member| !kept.equal?(member) }
+          GatedSignaturePlan.rebuild(decl, members: members + nested_lead)
+        end
+
+        # A type no other source declares that still failed to build: its own members, no superclass, stamped as a
+        # synthesized stub type so what it no longer inherits reads untyped.
+        def open_type(decl, nested)
+          @changed = true
+          own = decl.members.reject { |member| GatedSignaturePlan.type_declaration?(member) }
+          GatedSignaturePlan.header_copy(decl, decl.name, own + nested, buffer_name: RbsLoader::SYNTHETIC_STUB_BUFFER)
+        end
+      end
+
+      module_function
+
+      # @param roots — the gated directories (Pathnames) to plan, each loaded whole on the first attempt.
+      # @param base_env — the environment built without them: every other signature source, resolved.
+      # @param shelled — absolute-less type names to shell regardless of their headers.
+      def build(roots, base_env, shelled = Set.new)
+        planner = Planner.new(base_env, shelled)
+        leading = []
+        shells = []
+        signature_files(roots).each do |file|
+          buffer, directives, decls = RbsLoader.parse_signature_file(file)
+          next if buffer.nil?
+
+          lead, shell = planner.plan_decls(decls, nil)
+          leading << [buffer, directives, lead]
+          shells << [shell_buffer, directives, shell] unless shell.empty?
+        end
+        Plan.new(leading: leading, shells: shells, changed: planner.changed)
+      end
+
+      def signature_files(roots)
+        roots.flat_map { |root| Dir.glob(File.join(root.to_s, "*.rbs")).sort }
+      end
+
+      def shell_buffer
+        ::RBS::Buffer.new(name: SHELL_BUFFER, content: "")
+      end
+
+      # The declarations of `name` in `env` that some other source made, synthesized stubs left out.
+      def other_declarations(env, name)
+        entry = env&.class_decls&.[](::RBS::TypeName.parse("::#{name}"))
+        return [] if entry.nil?
+
+        RbsLoader.entry_declarations(entry).reject { |decl| synthetic?(decl) }
+      end
+
+      def synthetic?(decl)
+        synthetic_buffers.include?(RbsLoader.declaration_buffer_name(decl))
+      end
+
+      # A class one side declares as a module, or a different number of type parameters. A disagreement the
+      # declarations do not show this plainly — a superclass, a variance, a bound — is the trial build's to find.
+      def header_conflict?(decl, others)
+        first = others.first
+        return false if first.nil?
+        return true unless first.instance_of?(decl.class)
+
+        first.type_params.size != decl.type_params.size
+      end
+
+      def declared_keys(others)
+        others.each_with_object(Set.new) do |other, keys|
+          other.members.each { |member| RbsLoader.member_method_keys(member).each { |key| keys << key } }
+        end
+      end
+
+      # `member` less the methods in `taken`: itself when it declares none of them, nil when it declares only
+      # them, else narrowed to the one it declares that is not taken.
+      def untaken(member, taken)
+        keys = RbsLoader.member_method_keys(member)
+        left = keys.reject { |key| taken.include?(key) }
+        return member if left.size == keys.size
+        return nil if left.empty?
+
+        narrowed(member, left.first)
+      end
+
+      # The two members that declare two methods: an `attr_accessor` (a reader and a writer) and a
+      # `def self?.m` (an instance and a singleton method). The instance side of a `self?` method is private
+      # (a module function), so narrowing to it keeps that.
+      def narrowed(member, key)
+        method_name, kind = key
+        if member.is_a?(::RBS::AST::Members::MethodDefinition)
+          return member.update(kind: kind, visibility: kind == :instance ? :private : member.visibility)
+        end
+
+        attribute = method_name.to_s.end_with?("=") ? ::RBS::AST::Members::AttrWriter : ::RBS::AST::Members::AttrReader
+        attribute.new(
+          name: member.name, type: member.type, ivar_name: member.ivar_name, kind: member.kind,
+          annotations: member.annotations, location: member.location, comment: member.comment,
+          visibility: member.visibility
+        )
+      end
+
+      # `source`'s kind and type parameters under `name`, carrying only `members` — no superclass, self types,
+      # annotations or members of its own, all of which a reopening declaration may omit.
+      def header_copy(source, name, members, buffer_name: SHELL_BUFFER)
+        location = ::RBS::Location.new(::RBS::Buffer.new(name: buffer_name, content: ""), 0, 0)
+        if source.is_a?(::RBS::AST::Declarations::Class)
+          ::RBS::AST::Declarations::Class.new(
+            name: name, type_params: source.type_params, super_class: nil, members: members,
+            annotations: [], location: location, comment: nil
+          )
+        else
+          ::RBS::AST::Declarations::Module.new(
+            name: name, type_params: source.type_params, members: members, self_types: [],
+            annotations: [], location: location, comment: nil
+          )
+        end
+      end
+
+      def rebuild(decl, members:)
+        if decl.is_a?(::RBS::AST::Declarations::Class)
+          ::RBS::AST::Declarations::Class.new(
+            name: decl.name, type_params: decl.type_params, super_class: decl.super_class, members: members,
+            annotations: decl.annotations, location: decl.location, comment: decl.comment
+          )
+        else
+          ::RBS::AST::Declarations::Module.new(
+            name: decl.name, type_params: decl.type_params, members: members, self_types: decl.self_types,
+            annotations: decl.annotations, location: decl.location, comment: decl.comment
+          )
+        end
+      end
+
+      def type_declaration?(decl)
+        decl.is_a?(::RBS::AST::Declarations::Class) || decl.is_a?(::RBS::AST::Declarations::Module)
+      end
+
+      def qualify(namespace, type_name)
+        text = type_name.to_s
+        return text.delete_prefix("::") if text.start_with?("::") || namespace.nil?
+
+        "#{namespace}::#{text}"
+      end
+
+      # What stood down from each of `roots` in `env`, as `[dir, entries, whole]`: `entries` are
+      # `[declaration, cause_file, reason]`, `declaration` reading `Integer#prime?`, `Integer.from_prime_division`
+      # or `Prime` (a whole type), `cause_file` the buffer name of the other source's declaration, or nil when it
+      # cannot be named, and `reason` one of `"member"` (another source declares that method), `"type"` (the
+      # type stood down whole, its header contradicted or failing beside another source's declaration) or
+      # `"open"` (it failed with no other source declaring it, and was kept without its superclass, unchecked).
+      # `whole` is true when the directory stood down entirely; its entries are then only the clashes the
+      # environment still shows. A directory nothing stood down from is left out.
+      #
+      # @param roots — `{dir_basename => Pathname}` of the gated directories the run activated.
+      # @param project_files — the project's own signature files: a cause is named from them (or from inline
+      #   RBS) in preference to another source, and only from them when the type failed rather than clashed.
+      def standdowns(env, roots, project_files = Set.new)
+        return [] if env.nil?
+
+        loaded = RbsLoader.loaded_signature_buffers(env)&.to_set { |buffer| buffer.name.to_s } || Set.new
+        roots.sort.filter_map do |dir, root|
+          files = signature_files([root])
+          whole = files.none? { |file| loaded.include?(file) }
+          entries = files.flat_map { |file| file_standdowns(env, file, whole, project_files) }.uniq
+          [dir, entries, whole] if whole || !entries.empty?
+        end
+      rescue ::RBS::BaseError
+        []
+      end
+
+      def file_standdowns(env, file, whole, project_files)
+        _buffer, _directives, decls = RbsLoader.parse_signature_file(file)
+        return [] if decls.nil?
+
+        entries = []
+        each_type(decls, nil) do |decl, name|
+          entries.concat(type_standdowns(env, file, [decl, name], whole, project_files))
+        end
+        entries
+      end
+
+      def each_type(decls, namespace, &block)
+        decls.each do |decl|
+          next unless type_declaration?(decl)
+
+          name = qualify(namespace, decl.name)
+          block.call(decl, name)
+          each_type(decl.members, name, &block)
+        end
+      end
+
+      def type_standdowns(env, file, (decl, name), whole, project_files)
+        entry = env.class_decls[::RBS::TypeName.parse("::#{name}")]
+        declarations = entry.nil? ? [] : RbsLoader.entry_declarations(entry)
+        vendored = declarations.select { |other| RbsLoader.declaration_buffer_name(other) == file }
+        others = declarations.reject { |other| vendored.include?(other) || synthetic?(other) }
+        # A partial load shells a type that stood down, so its vendored declaration is gone; a whole stand-down
+        # removed every vendored declaration, and only a header the environment still contradicts names a type.
+        conflict = header_conflict?(decl, others)
+        type_row = [[name, type_cause(others, conflict, project_files), "type"]]
+        return conflict ? type_row : member_standdowns(decl, name, [], others, true) if whole
+        return member_standdowns(decl, name, vendored, others, false) unless vendored.empty?
+        return [[name, nil, "open"]] if others.empty? && declarations.any? { |other| stub?(other) }
+
+        type_row
+      end
+
+      # A header clash names the declaration it clashed with, preferring the project's own; a type that only
+      # failed beside another source names a project or inline declaration of it, never core or a gem's copy.
+      def type_cause(others, conflict, project_files)
+        own = others.find do |other|
+          name = buffer_of(other).to_s
+          project_files.include?(name) || name.start_with?("virtual:")
+        end
+        buffer_of(own || (conflict ? others.first : nil))
+      end
+
+      def stub?(decl)
+        RbsLoader.declaration_buffer_name(decl) == RbsLoader::SYNTHETIC_STUB_BUFFER
+      end
+
+      def member_standdowns(decl, name, vendored, others, whole)
+        present = declared_keys(vendored)
+        decl.members.flat_map do |member|
+          RbsLoader.member_method_keys(member).reject { |key| present.include?(key) }.filter_map do |key|
+            cause = others.find { |other| other.members.any? { |m| RbsLoader.member_method_keys(m).include?(key) } }
+            next if whole && cause.nil?
+
+            [member_label(name, key), buffer_of(cause), "member"]
+          end
+        end
+      end
+
+      def member_label(name, key)
+        method_name, kind = key
+        "#{name}#{kind == :singleton ? '.' : '#'}#{method_name}"
+      end
+
+      def buffer_of(decl)
+        decl && RbsLoader.declaration_buffer_name(decl)
+      end
+    end
+  end
+end

data/lib/rigor/environment/rbs_coverage_report.rb

@@ -32,7 +32,7 @@ module Rigor
       # hard-coding is acceptable; a directory walk at every call would add stat-cost to no benefit.)
       VENDORED_GEM_NAMES = Set[
         "ast", "bcrypt", "bundler", "cgi", "did_you_mean",
-        "idn-ruby", "mysql2", "nokogiri", "pg", "prism", "racc", "redis", "rubygems"
+        "idn-ruby", "mysql2", "nokogiri", "pg", "prime", "prism", "racc", "redis", "rubygems"
       ].freeze
 
       # @param locked_gems — The lockfile-resolved gem set. Empty