rigortype 0.4.0 → 0.4.2

data/lib/rigor/scope/discovery_index.rb

@@ -34,6 +34,7 @@ module Rigor
       :discovered_includes,
       :discovered_prepends,
       :discovered_extends,
+      :unpositioned_mixins,
       :discovered_class_sources,
       :constant_sources,
       :constant_writers,
@@ -49,7 +50,14 @@ module Rigor
       :patched_line_readers,
       :clears_last_status,
       :defines_case_equality,
-      :implicit_self_evidence
+      :implicit_self_evidence,
+      :in_effect_refinements,
+      :possible_discovered_methods,
+      :possible_discovered_deferred_ranges,
+      :contested_discovered_def_nodes,
+      :contested_discovered_singleton_def_nodes,
+      :contested_discovered_method_visibilities,
+      :contested_discovered_parameter_envelopes
     )
 
     class DiscoveryIndex
@@ -58,6 +66,115 @@ module Rigor
       EMPTY_NAME_SET = Set.new.freeze
       private_constant :EMPTY_NODE_TABLE, :EMPTY_TABLE, :EMPTY_NAME_SET
 
+      # ADR-119 WD1 — each member that may one day admit `possible` or `contested` facts, and the sibling that
+      # holds them. Every copy path reads this one declaration, so a member never travels without its sibling:
+      # {#with} raises on a half pair and {.compact_pairs} drops a pair only when BOTH halves are empty. No
+      # producer fills a sibling yet (the lane-1 carriage), so every sibling is empty and each member keeps its
+      # meaning, the union of its certain and possible facts.
+      #
+      # - `possible_*` has its member's shape and is a subset of it (a `discovered_methods` pair is a
+      #   `{class => {name => kind}}` table).
+      # - `contested_*` is a Set of key paths into its member, one per entry whose value depends on a possible
+      #   fact: `[class, method]`, or `[class, [kind, method]]` for an envelope.
+      #
+      # The members without a sibling here (`discovered_def_sources`, `discovered_singleton_def_sources`) are site
+      # tables (dependency edges, positions, fingerprints): no read takes a definer, visibility, arity or type from
+      # them, and certainty does not move a site. The reads whose answer depends on the site are
+      # `Scope#same_file_top_level_def?` (file identity, independent of certainty), `#singleton_def_shadows_call?`
+      # and `#instance_def_shadows_call?` (a conditional def's site answers "shadows"). Where "shadows" narrows an
+      # answer, the caller pairs it with {#possible_method?}: existence is the method table, certainty is the possible
+      # table alone (ADR-119 C1d-c).
+      SIBLINGS = {
+        discovered_methods: :possible_discovered_methods,
+        discovered_deferred_ranges: :possible_discovered_deferred_ranges,
+        discovered_def_nodes: :contested_discovered_def_nodes,
+        discovered_singleton_def_nodes: :contested_discovered_singleton_def_nodes,
+        discovered_method_visibilities: :contested_discovered_method_visibilities,
+        discovered_parameter_envelopes: :contested_discovered_parameter_envelopes
+      }.freeze
+
+      # Either half of a pair to the other.
+      PARTNERS = SIBLINGS.flat_map { |member, sibling| [[member, sibling], [sibling, member]] }.to_h.freeze
+      private_constant :PARTNERS
+
+      # [#1507](https://github.com/rigortype/rigor/issues/1507) — the kind of fact each member holds, which decides
+      # what a reader may conclude from an entry and which gate covers the member (ADR-119 WD4, proposed). Each
+      # reason describes the table as the code builds it today. `spec/rigor/declaration_facts/member_classes_spec.rb`
+      # fails on a member that is unclassified or classified twice, and checks each class's shape on an index built
+      # from a fixture project; it pins the few misfilings those checks accept.
+      #
+      # - `:set_valued` — names, edges, files or rows whose presence is the fact. A reader asks whether an entry is
+      #   there.
+      # - `:single_valued` — one value per key, which readers use; disagreeing contributions fold by a fixed rule.
+      # - `:typed` — the values are types, which already carry uncertainty in the type lattice.
+      # - `:syntactic` — read off the parse of the analysed file alone, which is their reference.
+      # - `:run_state` — the run's own state, not a fact about the program.
+      # - `:sibling` — the `possible_*` / `contested_*` half of a pair in {SIBLINGS}, which travels with its member.
+      MEMBER_CLASSES = {
+        set_valued: {
+          discovered_classes: "the class and module names the project declares; the value is the name's singleton",
+          discovered_methods: "which names each class answers, and on which side",
+          discovered_refinements: "the methods a refine block adds, keyed by the refined class",
+          discovered_global_write_census: "the names any file aliases, defines or mixes in at the top level",
+          discovered_includes: "the modules each class includes, prepends among them",
+          discovered_prepends: "the modules each class prepends",
+          discovered_extends: "the modules each singleton mixes in; the module itself for module_function",
+          unpositioned_mixins: "per side, the mixin edges each class records whose order is not a fact, or \"*\"",
+          discovered_class_sources: "the files that declare each class, reopenings included",
+          discovered_deferred_ranges: "each file's def and block ranges; def rows add owner and module_function side",
+          constant_sources: "the files that write each constant",
+          constant_writers: "the constant names some write binds, by last segment",
+          constant_shadowers: "the constant names a non-memo write assigns, by last segment",
+          published_constant_names: "the last segments of the constants the project publishes",
+          local_constant_names: "the last segments of the constants the analysed file assigns",
+          published_constant_alias_names: "the file's constants copied straight from a published one",
+          published_constant_ivars: "the ivars each class seeds from a published constant"
+        }.freeze,
+        single_valued: {
+          discovered_def_nodes: "the def node each instance method resolves to",
+          discovered_singleton_def_nodes: "the def node each singleton method resolves to",
+          discovered_def_sources: "the first-seen path:line of each instance method, which readers use",
+          discovered_singleton_def_sources: "the first-seen path:line of each singleton method, which readers use",
+          discovered_method_visibilities: "each method's visibility",
+          discovered_parameter_envelopes: "each method's parameter shape, opaque when contributions disagree",
+          discovered_superclasses: "each class's superclass as written",
+          discovered_header_nestings: "the cref each ancestor name resolves in, an alternatives list when ambiguous",
+          data_member_layouts: "each Data class's member layout",
+          struct_member_layouts: "each Struct class's member layout"
+        }.freeze,
+        typed: {
+          declared_types: "the type each declaration node binds",
+          class_ivars: "the joined type of each ivar's writes, per class",
+          class_cvars: "the joined type of each cvar's writes, per class",
+          program_globals: "the joined type of each global's writes",
+          program_global_seeds: "a declared global's signature type joined with its writes",
+          in_source_constants: "the type each constant's write binds",
+          param_inferred_types: "the union of each parameter's call-site argument types"
+        }.freeze,
+        syntactic: {
+          discovered_def_nestings: "the Module.nesting each def is written in, keyed by node identity",
+          patched_line_readers: "the gets / readline names the file defines through the define_method family",
+          clears_last_status: "whether the analysed file holds a call that may set $? to nil",
+          defines_case_equality: "whether the analysed file holds a define_method naming ===",
+          in_effect_refinements: "the file's ordered in-effect refinements; built lazily from its tree, never seeded",
+          implicit_self_evidence: "where the file's implicit-self readers sit; built lazily from its tree, never seeded"
+        }.freeze,
+        run_state: {
+          run_generation: "the identity token of the current run"
+        }.freeze,
+        sibling: {
+          possible_discovered_methods: "the names and sides of discovered_methods that only a possible definer gives",
+          possible_discovered_deferred_ranges: "the rows of discovered_deferred_ranges that only a possible fact gives",
+          contested_discovered_def_nodes: "the key paths of discovered_def_nodes that a possible definer may change",
+          contested_discovered_singleton_def_nodes:
+            "the key paths of discovered_singleton_def_nodes that a possible definer may change",
+          contested_discovered_method_visibilities:
+            "the key paths of discovered_method_visibilities that a possible fact may change",
+          contested_discovered_parameter_envelopes:
+            "the key paths of discovered_parameter_envelopes that a possible fact may change"
+        }.freeze
+      }.freeze
+
       # The third value a `discovered_methods` entry can hold, beside `:instance` and `:singleton`. One name may
       # legitimately be defined on both sides of the same class (`def helper` plus a `class << self` twin), and the
       # table is keyed by name alone — so before this existed the second `def` overwrote the first's kind and
@@ -89,6 +206,9 @@ module Rigor
       # `Source::ParameterEnvelope::OPAQUE`, so a bucket folds under the one join every other entry does.
       # Symbols, because every per-method key is an Array and neither can collide with the other.
       #
+      # The class marks below and {ENVELOPE_PROJECT_WIDE} are presence facts read only to decline a read; they are
+      # never a contested path. Contested envelope paths are always `[class, [kind, name]]`.
+      #
       # - {ENVELOPE_MODULE_MARK}: the name is declared with `module` (or `Const = Module.new do … end`) somewhere
       #   in the project. An instance of it is an instance of an unknown includer.
       # - {ENVELOPE_DYNAMIC_MARK}: the class body rewrites its method table in a way no literal argument names
@@ -99,12 +219,36 @@ module Rigor
       # - {ENVELOPE_REFINED_MARK}: a `refine` block refines the class, which redefines its methods wherever a `using`
       #   is in effect. Issue #1367 splits it from {ENVELOPE_DYNAMIC_MARK}, which it used to share: an implicit
       #   conversion (`to_str`, `to_int`) ignores a refinement, so the `global.*` rules must tell the two apart.
-      #   Every reader that asks whether a surface is rewritten reads both ({.rewritten_surface?}).
+      #   The readers that ask whether a surface is rewritten read both ({.rewritten_surface?}), except
+      #   `call.wrong-arity`'s source envelope (`CheckRules::SourceArity`), which leaves a refinement to the per-call
+      #   decline that knows the name and the `using` (issue #1797).
+      # Issue #1820 — the kind of a `[ENVELOPE_REMOVED_KIND, method_name]` bucket entry: the project removes the name
+      # from the class with a literal `undef`, `remove_method` or `undef_method`, whichever side. A removal is not
+      # otherwise distinguishable from an `attr_*` or `define_method`, whose envelope is opaque too, and the
+      # refinement own-definer proof must not take a removed method as the one Ruby finds.
+      ENVELOPE_REMOVED_KIND = :removed
+      # Issue #1820 — a `K = Class.new(Parent)` constant write: the class's superclass is not in the superclass table
+      # (the meta-new walk does not route `Parent` through ancestor discovery), so a reader that must place `K` in a
+      # hierarchy reads its superclass as unknown, as it reads the `nil` the table records for `class K < <expr>`.
+      ENVELOPE_META_SUPERCLASS_MARK = :"<meta-superclass>"
       ENVELOPE_MODULE_MARK = :"<module>"
       ENVELOPE_DYNAMIC_MARK = :"<dynamic>"
       ENVELOPE_OBJECT_EXTENDED_MARK = :"<object-extended>"
       ENVELOPE_REFINED_MARK = :"<refined>"
 
+      # Issue #1820 — whether an envelope bucket says the project declares, or rewrites, the name's method table: a
+      # per-method entry, the {ENVELOPE_MODULE_MARK} a `module` declaration records, or the {ENVELOPE_DYNAMIC_MARK}
+      # (`Comparable.module_eval { define_method(computed) }` gives a module a method no table names, so a reader
+      # must keep it on its chain rather than read RBS's surface for it). A bucket that holds only the refined,
+      # object-extended or meta-superclass marks is evidence about a name the project may only mention, such as
+      # `Comparable` in `x.singleton_class.prepend(Comparable)`.
+      DECLARING_MARKS = [ENVELOPE_MODULE_MARK, ENVELOPE_DYNAMIC_MARK].freeze
+      private_constant :DECLARING_MARKS
+
+      def self.declares_surface?(bucket)
+        !bucket.nil? && bucket.any? { |key, _| !key.is_a?(Symbol) || DECLARING_MARKS.include?(key) }
+      end
+
       # Whether an envelope bucket says the project rewrites the class's method table beyond its literal names: a
       # dynamic rewrite, or a refinement.
       def self.rewritten_surface?(bucket)
@@ -118,6 +262,14 @@ module Rigor
       # present. Not a constant character, so no class can be named it.
       ENVELOPE_PROJECT_WIDE = "<project-wide>"
 
+      # ADR-121 WD7 (issues #1796, #1799) — the wildcard of `discovered_refinements`, standing for what the walk could
+      # not read. As a refined-class key it is a class the walk cannot name (`refine(k)`, `refine(self)`); as a method
+      # key, names a refine body defines that the walk cannot enumerate (`import_methods`, a computed
+      # `define_method`); as a refining module, a module the walk cannot name (a `refine` in an instance method,
+      # which any module extending it may run). `{"*" => {"*" => [M]}}` makes `M` opaque: some `refine` of `M` is
+      # unreadable. No constant can be named `*`, and method keys are Symbols, so neither axis collides.
+      REFINEMENT_WILDCARD = "*"
+
       # The shared all-empty index `Scope.empty` (and every scope that never sees a seeding pass) points at — one
       # allocation per process.
       EMPTY = new(
@@ -210,6 +362,24 @@ module Rigor
         # the table inside the indexer and threw it away; `Narrowing` needs it to survive onto the scope,
         # because `Singleton[C]`'s ancestry is exactly what `extend` writes and nothing else records it.
         discovered_extends: EMPTY_TABLE,
+        # `{qualified class or module name => {include: [names], extend: [names]}}` — the mixin edges of the three
+        # tables above whose ORDER is not a fact, per side (`:include` is the instance side, `include` and
+        # `prepend`; `:extend` the singleton side). An edge is listed when it is written anywhere but as a direct
+        # statement of the class's own body (or its `class << self` body) in a declaration that is itself a
+        # direct statement — inside a `def`, a block, a conditional, or a conditional or deferred declaration —
+        # or in the receiver form, and when it shares an argument list with a name the walk could not record
+        # (`Inference::ScopeIndexer::MixinAccumulator`). A mixin call the walk cannot record at all (`include
+        # helper`, `include(*MODS)`, `send(:include, M)`, `self.include M`, `C.include(M)`,
+        # `singleton_class.include M`, a call on a `self.included(base)`-style hook's parameter, an `*_eval` block on
+        # one or on an opaque receiver whose body mixes a module in) lists the name
+        # `"*"` on the side it reshapes: that side of the owner has no known order. An edge written both ways
+        # is listed. Folded by union. A reader that depends on the order of a class's ancestors MUST decline
+        # when the owner it asks about, or any ancestor it walks through, lists anything on the side it reads;
+        # the three tables themselves are unchanged.
+        unpositioned_mixins: EMPTY_TABLE,
+        # The files that declare each class, reopenings included. Seeded on every run: the ADR-46 recording
+        # accessors read it for their class edges, and an ancestor-order reader reads whether a class is
+        # declared in more than one file, where the order of its mixins across the files is load order.
         discovered_class_sources: EMPTY_TABLE,
         # Issue #644 — `{qualified constant name => Set[declaring file]}`, the write attribution behind the
         # cross-file value-constant table. Read only by `Scope#record_constant_dependency` during ADR-46
@@ -280,8 +450,93 @@ module Rigor
         # (`Inference::LastLine::SelfEvidence`, read on the first ask), which `Inference::LastLine.reads_line?` reads
         # them by. Filled by `Inference::ScopeIndexer.index` from the file's own tree only; nil, where no file was
         # indexed, declines every such reader.
-        implicit_self_evidence: nil
+        implicit_self_evidence: nil,
+        # Issue #1673 (ADR-121 WD1) — the file's in-effect refinements (`Inference::InEffectRefinements`, walked on the
+        # first ask), which `Scope#in_effect_refinements` reads for the typer and the check rules read off the root's
+        # scope. Filled by `Inference::ScopeIndexer.index` from the file's own tree only; nil, where no file was
+        # indexed, answers no lexical refinement.
+        in_effect_refinements: nil,
+        # ADR-119 WD1 — the siblings of the members {SIBLINGS} pairs, empty until a producer admits a possible fact.
+        possible_discovered_methods: EMPTY_TABLE,
+        possible_discovered_deferred_ranges: EMPTY_TABLE,
+        contested_discovered_def_nodes: EMPTY_NAME_SET,
+        contested_discovered_singleton_def_nodes: EMPTY_NAME_SET,
+        contested_discovered_method_visibilities: EMPTY_NAME_SET,
+        contested_discovered_parameter_envelopes: EMPTY_NAME_SET
       )
+
+      # The siblings of an all-empty index, `{sibling name => empty value}`, frozen: what a def-index with no
+      # possible fact carries, and a Runner's initial state. Copy it (`dup`) before mutating.
+      EMPTY_SIBLINGS = SIBLINGS.each_value.to_h { |sibling| [sibling, EMPTY.public_send(sibling)] }.freeze
+
+      # The all-empty value of a paired member or sibling.
+      def self.empty_value(name)
+        EMPTY.public_send(name)
+      end
+
+      def self.empty_siblings = EMPTY_SIBLINGS
+
+      # ADR-119 WD1 — `tables` (a `with(**)` argument Hash) with every pair either complete or absent: a pair whose
+      # halves are both missing, nil or empty is dropped, any other pair carries BOTH halves (the half that was
+      # absent or nil becomes its empty value). Dropping members one at a time would strand a non-empty sibling,
+      # and passing a half would make {#with} raise. Entries outside {SIBLINGS} pass through untouched.
+      def self.compact_pairs(tables)
+        tables.each_with_object({}) do |(name, table), out|
+          partner = PARTNERS[name]
+          next out[name] = table if partner.nil?
+          next if out.key?(name)
+
+          other = tables[partner]
+          next if blank_table?(table) && blank_table?(other)
+
+          out[name] = table.nil? ? empty_value(name) : table
+          out[partner] = other.nil? ? empty_value(partner) : other
+        end
+      end
+
+      # Whether `name` is a member or sibling of {SIBLINGS}.
+      def self.paired?(name)
+        PARTNERS.key?(name)
+      end
+
+      def self.blank_table?(table)
+        table.nil? || table.empty?
+      end
+      private_class_method :blank_table?
+
+      # The six siblings as `{sibling name => table}`, for a caller that rebuilds the paired members and carries
+      # their siblings over unchanged.
+      def sibling_tables
+        SIBLINGS.each_value.to_h { |sibling| [sibling, public_send(sibling)] }
+      end
+
+      # ADR-119 WD1/WD2 — whether `class_name` answers `method_name` on `kind` only through a `possible` fact
+      # (`possible_discovered_methods`, empty until a producer admits one). Internal to the candidate-set read.
+      def possible_method?(class_name, method_name, kind)
+        recorded = possible_discovered_methods[class_name.to_s]&.[](method_name.to_sym)
+        recorded == kind || (!recorded.nil? && recorded == METHOD_KIND_BOTH)
+      end
+
+      # ADR-119 WD1 — whether `path` (`[class, name]`, or `[class, [kind, name]]` for an envelope) is a contested
+      # entry of `member`, one of the single-valued members {SIBLINGS} pairs. Internal to the candidate-set read.
+      def contested?(member, path)
+        public_send(SIBLINGS.fetch(member)).include?(path)
+      end
+
+      # Data's `with`, except that a paired member and its sibling are accepted only TOGETHER (ADR-119 WD1): a
+      # caller that rebuilt one without the other would leave the sibling describing the old table, so it
+      # raises instead. A call with no change returns the receiver.
+      def with(**changes)
+        return self if changes.empty?
+
+        changes.each_key do |name|
+          partner = PARTNERS[name]
+          next if partner.nil? || changes.key?(partner)
+
+          raise ArgumentError, "DiscoveryIndex#with: #{name} and #{partner} change together; #{partner} is missing"
+        end
+        super
+      end
     end
   end
 end

data/lib/rigor/scope/resolution_chain/relevance.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module Rigor
+  class Scope
+    class ResolutionChain
+      # ADR-119 WD2 — per-name relevance, the narrowing of an unsettled chain (#1591). A {Mark} says a node's mixin
+      # edges have no known order; the chain still answers a question about ONE method name when the module the
+      # mark names cannot answer that name, because with no fork every entry reached the chain by a single route,
+      # so a module of unknown presence or position adds or removes only its own closure's entries and moves no
+      # other entry's first occurrence. A closure that cannot answer the name therefore cannot move its first
+      # definer. {ResolutionChain#settle} asks it under `unknown_for:`; nothing else does.
+      #
+      # - A named entry `Q` (not `"*"`) is discharged for `n` when every entry of `Q`'s own instance chain (its
+      #   closure) is clean: (i) a project entry, or an external one RBS knows whose declaration lacks `n`
+      #   (the test `SourceArity#external_mixin_lacks_method?` applies); (ii) no project entry carries the dynamic
+      #   mark, lists `"*"` on the instance side or the mark's, or records `method_missing`; (iii) no project
+      #   entry records `n` in `discovered_methods` (either kind) or in `discovered_method_visibilities`.
+      # - A multi-file mark names no entry: it is discharged when at most one of the node's edges' closures is
+      #   not clean. A mark that is both listed and multi-file must pass both rules.
+      # - An ambiguous spelling (`:arity` only: several project modules a compact-header collision left as the
+      #   spelling's meaning, #986) is discharged when every one of them is clean; any candidate that fails fails it.
+      # - `"*"` and a truncated closure are never discharged.
+      #
+      # The verdict and the edges it read are memoised per `[mark, name]` in the flavor's bucket and the edges are
+      # replayed on every call while a dependency recording is active (ADR-46): per tested project entry its class
+      # edge and the negative method edge on `Owner#name`, per tested external the negative class edge on the last
+      # segment of its spelling, so a new file declaring the module re-checks the consumer.
+      module Relevance
+        WILDCARD = "*"
+
+        # The singleton hooks Ruby calls while a module enters (or is asked to enter) another's ancestry. A module
+        # that defines one can add methods to the includer, extender or prepender with nothing the tables record
+        # on the module (`def self.included(base) = base.attr_reader(:foo)`), so no closure holding one can be
+        # said not to answer a name.
+        HOOKS = %i[included extended prepended inherited append_features extend_object prepend_features].freeze
+
+        module_function
+
+        def discharged?(scope, chain, mark, name)
+          name = name.to_sym
+          memo = ResolutionChain.relevance_memo(scope, chain.flavor)
+          verdict, edges = memo[[mark, name]] ||= compute(scope, chain.flavor, mark, name)
+          replay(scope, edges) if Analysis::DependencyRecorder.active?
+          verdict
+        end
+
+        def compute(scope, flavor, mark, name)
+          context = Context.new(scope, flavor, mark, name)
+          verdict = !mark.listed.include?(WILDCARD) && listed_discharged?(context) && multi_file_discharged?(context)
+          [verdict, context.edges.uniq.freeze].freeze
+        end
+
+        def listed_discharged?(context)
+          mark = context.mark
+          mark.listed.all? { |raw| context.closure_clean?(raw) }
+        end
+
+        def multi_file_discharged?(context)
+          mark = context.mark
+          return true unless mark.multi_file
+
+          edges = context.edge_names
+          edges.count { |raw| !context.closure_clean?(raw) } <= 1
+        end
+
+        def replay(scope, edges)
+          edges.each do |kind, value|
+            case kind
+            when :class then ResolutionChain.record_class(scope, value)
+            when :method then Analysis::DependencyRecorder.read_missing(:method, value)
+            when :external then Analysis::DependencyRecorder.read_missing(:class, value)
+            end
+          end
+        end
+
+        # True only for an ancestor the project does not declare that RBS knows and whose declaration lacks `name`
+        # (`SourceArity#external_mixin_lacks_method?`); an unknown one, or one that has it, may answer.
+        def external_lacks?(scope, candidates, name)
+          known = candidates.find { |candidate| Rigor::Reflection.rbs_class_known?(candidate, scope: scope) }
+          return false if known.nil?
+
+          Rigor::Reflection.instance_method_definition(known, name, scope: scope).nil?
+        rescue StandardError
+          false
+        end
+
+        # One verdict's working state: the scope, the resolver, and the edges the tests read.
+        class Context
+          attr_reader :mark, :edges
+
+          def initialize(scope, flavor, mark, name)
+            @scope = scope
+            @flavor = flavor
+            @mark = mark
+            @name = name
+            @resolver = ResolutionChain.resolver_for(scope, flavor)
+            @edges = []
+          end
+
+          # The raw names of the node's own edges on the side the mark covers.
+          def edge_names
+            discovery = @scope.discovery
+            table = @mark.kind == :extend ? discovery.discovered_extends : discovery.discovered_includes
+            table[@mark.node] || EMPTY_NAMES
+          end
+
+          # Whether the closure of the module `raw` names from the marked node cannot answer the name.
+          def closure_clean?(raw)
+            resolved = @resolver.resolve(@mark.node, raw)
+            case resolved
+            when String then project_closure_clean?(resolved)
+            when Array then resolved.all? { |name| project_closure_clean?(name) }
+            else external_clean?(@resolver.candidates(@mark.node, raw), raw)
+            end
+          end
+
+          private
+
+          def project_closure_clean?(module_name)
+            chain = ResolutionChain.for(@scope, module_name, :instance, @flavor)
+            return false if chain.truncated?
+
+            chain.entries.all? do |entry|
+              entry.external? ? external_clean?(entry.candidates, entry.raw) : project_clean?(entry)
+            end
+          end
+
+          def project_clean?(entry)
+            owner = entry.name
+            @edges << [:class, owner] << [:method, "#{owner}##{@name}"]
+            return false if Scope::DiscoveryIndex.rewritten_surface?(@scope.parameter_envelopes_of(owner))
+            return false if wildcard_listed?(owner)
+            return false if @scope.discovered_method?(owner, :method_missing, :instance)
+            return false if HOOKS.any? { |hook| @scope.discovered_method?(owner, hook, :singleton) }
+
+            !records_name?(owner)
+          end
+
+          def wildcard_listed?(owner)
+            sides = @scope.discovery.unpositioned_mixins[owner]
+            return false if sides.nil?
+
+            [:include, @mark.kind].uniq.any? { |side| sides[side]&.include?(WILDCARD) }
+          end
+
+          def records_name?(owner)
+            @scope.discovered_method?(owner, @name, :instance) || @scope.discovered_method?(owner, @name, :singleton) ||
+              !@scope.discovered_method_visibility(owner, @name).nil?
+          end
+
+          # An ancestor the project does not declare: only a module RBS knows, whose declaration lacks the name,
+          # is evidence it does not define it (`SourceArity#external_mixin_lacks_method?`).
+          def external_clean?(candidates, raw)
+            @edges << [:external, raw.to_s.split("::").last]
+            Relevance.external_lacks?(@scope, candidates, @name)
+          end
+        end
+        private_constant :Context
+
+        EMPTY_NAMES = [].freeze
+        private_constant :EMPTY_NAMES
+      end
+    end
+  end
+end