rigortype 0.4.7 → 0.4.8

data/lib/rigor/scope/resolution_chain.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require_relative "../run_scoped_slots"
+require_relative "../typing_state"
+require_relative "../memo_audit"
 
 module Rigor
   class Scope
@@ -92,6 +93,39 @@ module Rigor
       # when the entry is interned.
       Entry = Data.define(:name, :side, :raw, :candidates, :superclass_edge, :last_segment, :owner) do
         def external? = name.nil?
+
+        # Issue #3156 — the BODY-LESS class or module the project declares that an external entry names, or nil: the
+        # first of its spellings that is a `discovered_classes` key, read in Ruby's lookup order. Such a declaration
+        # records no method, superclass or include (`module PMod; end`), which is why the chain holds it as external.
+        # The owner-qualified spelling (#1698) leads only on a mixin edge: Ruby evaluates a superclass expression
+        # outside the class's own body, so `class Leaf < Base` never names `Leaf::Base`. Any spelling up to the match
+        # that RBS alone knows, that a project constant write binds (`AMid = ::Other` in `NS`), or that names a class
+        # with a body leaves nil, since Ruby may resolve the constant there or the chain should have held it. It files
+        # the entry's negative class and constant edges, which a declaration or write of the name appearing or
+        # vanishing fires.
+        def declared_name(scope)
+          spelling = raw.to_s
+          Analysis::DependencyRecorder.read_last_segment(:class, spelling)
+          Analysis::DependencyRecorder.read_last_segment(:constant, spelling)
+          own = owner && !superclass_edge && !spelling.start_with?("::")
+          (own ? ["#{owner}::#{spelling}", *candidates] : candidates).uniq.each do |candidate|
+            return nil if constant_written?(scope, candidate)
+            return (scope.known_user_class?(candidate) ? nil : candidate) if scope.discovered_classes.key?(candidate)
+            return nil if Rigor::Reflection.rbs_class_known?(candidate, scope: scope)
+          end
+          nil
+        end
+
+        private
+
+        # Whether a project constant write other than a class declaration binds `name` exactly (the census keeps a
+        # write as spelled, a `*::` wildcard for one it cannot place), or a literal `const_set` in this file does
+        # (`LastLine::SelfEvidence#const_set_spellings`; the census files none).
+        def constant_written?(scope, name)
+          (scope.bound_constant_names(name) + scope.shadowing_constant_names(name)).any? do |written|
+            written == name || written.start_with?("*::")
+          end || scope.discovery.implicit_self_evidence&.const_set_spellings&.include?(name) || false
+        end
       end
 
       # How many project entries a chain may hold before it is cut (ADR-41 WD4). The breadth-first walks
@@ -104,9 +138,20 @@ module Rigor
       # the multi-file rule fired (two or more files declare it and it has two or more edges on that side).
       # Interned per `[node, kind]` in the flavor's bucket, so equal marks are one object. Kind `:extend_hook`
       # (#1730, listing `"*"`) marks a node a module it extends may mix into through a hook; it is not an order mark
-      # ({#order_marks}).
+      # ({#order_marks}). Kind `:include_hook` (#1592, listing `"*"` and `"?"`) marks a class object a module it
+      # includes or prepends may extend, through a hook, with a module no table names; nor is it. Kind `:hook_order`
+      # (#1592, listing nothing) marks a class object whose own `extend`s and hook-extended modules have no known
+      # order between them: the fork it counts already settles the chain, and the mark tells the typing read why.
+      # Kind `:singleton_prepend` (#2998, listing nothing) marks a class object with singleton-side prepends of its
+      # own, which master's order does not place, and kind `:prepend_order` (#2998, listing nothing) one whose
+      # singleton-side prepends have no known order among themselves; neither is an order mark. Kind `:unnamed_prepend`
+      # (#3020, listing nothing) marks a class object with a singleton-side prepend of a module no table names, which
+      # is not an order mark either.
       Mark = Data.define(:node, :kind, :listed, :multi_file)
 
+      # The mark kinds that are not order marks.
+      HOOK_MARK_KINDS = %i[extend_hook include_hook hook_order singleton_prepend prepend_order unnamed_prepend].freeze
+
       NO_MARKS = [].freeze
 
       attr_reader :root, :side, :entries, :level_starts, :level_classes, :flavor
@@ -133,6 +178,13 @@ module Rigor
       # "no definer" from "a definer past the cut", which is budget uncertainty, not absence.
       def truncated? = @truncated
 
+      # ADR-129 G2 — the chain's content, for the memo audit: a recomputation builds a new chain object, which
+      # equals the stored one field for field (its retro world included) when the memo's key holds every input.
+      def audit_signature
+        [@root, @side, @entries, @level_starts, @level_classes, @levels_end, @truncated, @forks, @marks, @flavor,
+         @retro&.audit_signature]
+      end
+
       # How many forks the replay met while this chain was built, counted across every module sub-chain it drew
       # on (a memoised sub-chain hands its own count up): each entry that reached the chain by a second route.
       # An over-count only ever sends a reader to master's answer.
@@ -149,13 +201,57 @@ module Rigor
       # those readers to master's order would answer a constant lookup breadth-first, which is wrong for the
       # #1567 shape on every class that extends such a module.
       def order_marks
-        @memo[:order_marks] ||= @marks.reject { |mark| mark.kind == :extend_hook }.freeze
+        @memo[:order_marks] ||= @marks.reject { |mark| HOOK_MARK_KINDS.include?(mark.kind) }.freeze
       end
 
       # True when a class on the chain records a mixin the tables cannot name (`"*"`: an `include` of a
       # non-constant, or a call the walk cannot record), so the chain may hold a module it does not list.
       def wildcard_mixin? = @marks.any? { |mark| mark.listed.include?(Relevance::WILDCARD) }
 
+      # Issue #2991 — true when a class on the chain mixes in a module the tables do not record under any name
+      # (`include(*MODS)`, `include helper`, a hook's `base.include M`, an unrecorded `self.include M`): the chain's SET
+      # of modules is unknown, not only its order. Every such mark is also a {#wildcard_mixin?} one; `include M;
+      # prepend M` taints the order alone.
+      def unnamed_mixin? = @marks.any? { |mark| mark.listed.include?(Relevance::UNNAMED) }
+
+      # Issue #1592 — whether a class object on the chain has hook-extended modules whose order against its own
+      # `extend`s, or among themselves, is not a fact ({Builder#singleton_mixins}).
+      def hook_order_marked? = @marks.any? { |mark| mark.kind == :hook_order }
+
+      # Issue #2998 — whether a class object on the chain has singleton-side prepends of its own
+      # ({Builder#own_singleton_prepends}), which master's order does not place.
+      def singleton_prepend_marked? = @marks.any? { |mark| mark.kind == :singleton_prepend }
+
+      # Issue #2998 — the class objects on the chain whose prepend region has no known order
+      # ({Builder#order_prepends}).
+      def prepend_order_nodes
+        @memo[:prepend_order_nodes] ||= @marks.filter_map { |mark| mark.node if mark.kind == :prepend_order }.freeze
+      end
+
+      # Issue #3020 — the class objects on the chain with a singleton-side prepend of a module no table names
+      # ({Builder#own_singleton_prepends}).
+      def unnamed_prepend_nodes
+        @memo[:unnamed_prepend_nodes] ||= @marks.filter_map { |mark| mark.node if mark.kind == :unnamed_prepend }.freeze
+      end
+
+      # Issue #3020 — the class objects on the chain whose own singleton side lists a module no table names
+      # (`extend(*MODS)`, `class << self; include(*MODS)`, `singleton_class.prepend(*MODS)`: the `:extend` order mark
+      # listing {Relevance::UNNAMED}).
+      def unnamed_extend_nodes
+        @memo[:unnamed_extend_nodes] ||= @marks.filter_map do |mark|
+          mark.node if mark.kind == :extend && mark.listed.include?(Relevance::UNNAMED)
+        end.freeze
+      end
+
+      # The chain's retro world ({#settle}), or nil when it has none.
+      def retro_world = @retro
+
+      # Issue #1592 — the class objects on a singleton chain that a module they include or prepend may extend, through
+      # a hook, with a module no table names: that module sits right after the class object's own entry.
+      def hook_open_nodes
+        @memo[:hook_open_nodes] ||= @marks.filter_map { |mark| mark.node if mark.kind == :include_hook }.freeze
+      end
+
       # The ONE decision every first-definer reader makes: does `answer`, read off this chain, stand, or does
       # the reader answer what the walk this chain replaced answered ({MasterOrder})? Returns `:chain` or
       # `:master`.
@@ -224,18 +320,30 @@ module Rigor
       # it does not head the part searched (its prepends, or its own edges when the search starts past it,
       # placed the rest). The entry that answers records none of its own: its method edge is the caller's
       # `Scope#user_def_for`. A read that finds nothing has passed every entry.
+      #
+      # Issue #2998 — on a singleton chain a NEW file reopening a class object's class can prepend to its singleton
+      # (`class << self; prepend P`), ahead of everything the class object's level holds, which no class edge of the
+      # declaring files sees. So each class object the search passes, and one that answers, also files the name edge
+      # `mark:<last segment>` ({#record_prepend_regions}), which `IncrementalSession#mark_affected` fires when a
+      # `[ENVELOPE_SINGLETON_PREPEND_KIND, …]` entry (a diffed class mark) appears on or vanishes from the class, and
+      # not on a plain reopening. A class object behind the answer is filed through {#settle}'s filing, and so is every
+      # one on a read that finds nothing.
       def search(scope, start = 0, stop = nil, side: nil)
         recording = Analysis::DependencyRecorder.active?
         stop ||= @entries.size
         if recording
           record_head(scope, start, side)
           record_extend_hooks(scope)
+          record_include_hooks(scope)
         end
         index = start
         while index < stop
           entry = @entries[index]
           answer = side.nil? || entry.side == side ? yield(entry) : nil
-          return answer if answer
+          if answer
+            record_prepend_regions(start, index) if recording
+            return answer
+          end
 
           ResolutionChain.record_entry(scope, entry, side) if recording
           index += 1
@@ -243,6 +351,19 @@ module Rigor
         nil
       end
 
+      # The `mark:` name edges of the class objects on a singleton chain from `start` through `last`.
+      def record_prepend_regions(start, last)
+        return unless @side == :singleton
+
+        (start..last).each do |index|
+          entry = @entries[index]
+          next unless entry.side == :singleton && !entry.external?
+
+          Analysis::DependencyRecorder.read_last_segment(:mark, entry.name)
+        end
+      end
+      private :record_prepend_regions
+
       # Records the ADR-46 class edge of the root and of every project entry ahead of `stop` (on `side`, when
       # given; every entry when `stop` is nil) — the dependency of a read that consulted those positions.
       def record(scope, stop = nil, side: nil)
@@ -251,6 +372,21 @@ module Rigor
         ResolutionChain.record_class(scope, @root)
         (stop || @entries.size).times { |index| ResolutionChain.record_entry(scope, @entries[index], side) }
         record_extend_hooks(scope)
+        record_include_hooks(scope)
+      end
+
+      # Issue #2689 — the negative edge a method-walk MISS owes each EXTERNAL entry: `class:<last segment>` of the name
+      # as written. An external entry is an ancestor the project declares with no methods (the usual empty
+      # `ApplicationRecord`) or not at all yet, so the walk looked nothing up there; a later file that declares it
+      # with the method turns the miss, and the declaration appearing is the one event that file fires. A core or gem
+      # ancestor (`StandardError`, `Comparable`) files its key too, which fires only on a file that declares a
+      # constant of that name. Recorded only on a miss: a hit's answer cannot be turned by an entry gaining a method.
+      def record_external_absence
+        return unless Analysis::DependencyRecorder.active?
+
+        @entries.each do |entry|
+          Analysis::DependencyRecorder.read_last_segment(:class, entry.raw.to_s) if entry.external?
+        end
       end
 
       # What a {#settle} verdict adds to what the search already filed. The search files the root and every entry
@@ -279,6 +415,7 @@ module Rigor
         Analysis::DependencyRecorder.file_chain_once(self, start, scope.discovery) { file_beyond(scope, start) }
         record_hooks(scope)
         record_extend_hooks(scope)
+        record_include_hooks(scope)
       end
       private :record_beyond
 
@@ -325,7 +462,7 @@ module Rigor
       end
       private :record_hooks
 
-      # #1730 — the edges of the {Builder#extend_hook_taint?} decision: an instance chain's project entries may carry
+      # #1730 — the edges of the {Builder#extend_hook_taint} decision: an instance chain's project entries may carry
       # a `"*"` mark because a module one of them `extend`s has a hook that mixes into the extender, and the
       # module is often declared in a file the chain records nothing of. Each such module the decision read files
       # its class edges (an edit to its hook moves its declaration signature) and the negative method edges of
@@ -352,6 +489,168 @@ module Rigor
       end
       private :record_extend_hooks
 
+      # #1592 — the edges of the {Builder#hook_extensions} read: a singleton chain draws, for every class on it, the
+      # modules that class's direct mixins' hooks extend it with, and the mixins are declared in files the chain's own
+      # entries record nothing of. Each resolved mixin files its class edges and the negative `mark:` edge on its name,
+      # which an edit adding or dropping a hook-extend entry fires; every mixin, and every module a hook extends by
+      # name, files the negative class edge on its last segment, which a NEW file declaring or reopening it fires.
+      # Filed once per consumer and chain.
+      def record_include_hooks(scope)
+        return unless @side == :singleton
+
+        edges = (@memo[:include_hook_edges] ||= ResolutionChain.include_hook_edges(scope, @flavor, @level_classes))
+        return if edges.empty?
+
+        Analysis::DependencyRecorder.file_chain_once(self, :include_hooks, scope.discovery) do
+          edges.each do |kind, name|
+            ResolutionChain.record_class(scope, name) if kind == :mixin
+            Analysis::DependencyRecorder.read_last_segment(:mark, name) if kind == :mixin
+            Analysis::DependencyRecorder.read_last_segment(:class, name)
+          end
+        end
+      end
+      private :record_include_hooks
+
+      # `[[:mixin, resolved name] | [:spelling, raw], …]`: the direct mixins of every class on a singleton chain, and
+      # the modules the resolved ones' hooks extend by name ({Builder#hook_extensions}).
+      def self.include_hook_edges(scope, flavor, classes)
+        resolver = resolver_for(scope, flavor)
+        discovery = scope.discovery
+        classes.each_with_object([]) do |klass, out|
+          next if klass.nil?
+
+          (discovery.discovered_includes[klass] || EMPTY_NAMES).uniq.each do |raw|
+            mixin = resolver.resolve_declared(klass, raw)
+            next out << [:spelling, raw].freeze if mixin.nil?
+
+            out << [:mixin, mixin].freeze
+            hook_extend_keys(discovery, mixin).each { |key| out << [:spelling, key[1]].freeze }
+            concern_dependency_edges(discovery, resolver, mixin, out)
+          end
+        end.uniq.freeze
+      end
+
+      # Issue #2992 — the edges of a concern mixin's dependency read ({.concern_dependencies}): every module its
+      # dependency entries name, a concern or not yet one (a file that adds `extend ActiveSupport::Concern` to it
+      # turns it into one), as a mixin, with the modules its hooks extend by name; a spelling no module answers files
+      # its negative class edge. A concern among them is followed further.
+      def self.concern_dependency_edges(discovery, resolver, mixin, out, seen = [mixin])
+        return unless concern_bucket?(discovery, mixin)
+
+        dependency_spellings(discovery, mixin).each do |raw|
+          dependency = resolver.resolve_declared(mixin, raw)
+          next out << [:spelling, raw].freeze if dependency.nil?
+          next if seen.include?(dependency)
+
+          seen << dependency
+          out << [:mixin, dependency].freeze
+          hook_extend_keys(discovery, dependency).each { |key| out << [:spelling, key[1]].freeze }
+          concern_dependency_edges(discovery, resolver, dependency, out, seen)
+        end
+      end
+      private_class_method :concern_dependency_edges
+
+      # The `[ENVELOPE_CONCERN_DEPENDENCY_KIND, written]` spellings of a module's bucket, nearest first (a later
+      # statement's ahead of an earlier one's).
+      def self.dependency_spellings(discovery, name)
+        bucket = discovery.discovered_parameter_envelopes[name]
+        return EMPTY_NAMES if bucket.nil?
+
+        bucket.each_key.filter_map do |key|
+          key[1] if key.is_a?(Array) && key.first == DiscoveryIndex::ENVELOPE_CONCERN_DEPENDENCY_KIND
+        end.reverse.uniq
+      end
+
+      # Issue #2992 — the concerns a concern `mixin` provably takes as dependencies (its
+      # `[ENVELOPE_CONCERN_DEPENDENCY_KIND, written]` entries: an `include` or `prepend` after its own `extend
+      # ActiveSupport::Concern`), at any depth through concerns, nearest first, without `mixin`:
+      # `Concern#append_features` records each as a dependency of `mixin` and includes it into `mixin`'s final
+      # includer, so the includer's singleton chain gains what each one's hooks extend it with. Empty when `mixin` is
+      # no concern. A dependency the walk meets twice is listed once, at its nearest place.
+      def self.concern_dependencies(discovery, resolver, mixin, seen = [mixin])
+        return EMPTY_NAMES unless concern_bucket?(discovery, mixin)
+
+        out = []
+        dependency_spellings(discovery, mixin).each do |raw|
+          dependency = resolver.resolve_declared(mixin, raw)
+          next if dependency.nil? || seen.include?(dependency) || !concern_bucket?(discovery, dependency)
+
+          seen << dependency
+          out << dependency
+          out.concat(concern_dependencies(discovery, resolver, dependency, seen))
+        end
+        out
+      end
+
+      # The entry an `extend ActiveSupport::Concern` module records ({Inference::ScopeIndexer}).
+      CONCERN_KEY = [DiscoveryIndex::ENVELOPE_HOOK_EXTEND_KIND, "ClassMethods", :const_get].freeze
+      private_constant :CONCERN_KEY
+
+      def self.concern_bucket?(discovery, name)
+        bucket = discovery.discovered_parameter_envelopes[name]
+        !bucket.nil? && bucket.key?(CONCERN_KEY)
+      end
+      private_class_method :concern_bucket?
+
+      # Issue #2997 — whether `owner.const_get(raw)` may find the project's `candidate` (`"#{owner}::#{raw}"`): a
+      # `class_methods do … end` block's `def`s are filed on `Owner::ClassMethods` in every body of the module, but
+      # Ruby has that module only when `owner` is a concern, so one that no `module` declaration writes counts only
+      # for a concern `owner`.
+      def self.const_get_candidate?(discovery, owner, candidate)
+        concern_bucket?(discovery, owner) || discovery.discovered_classes.key?(candidate)
+      end
+
+      # Issue #3005 — whether `name` is a module a concern block's `def self.x`s are filed on (`Owner::<included>`).
+      def self.hook_block_module?(name)
+        DiscoveryIndex::HOOK_BLOCK_SEGMENTS.any? { |segment| name.end_with?("::#{segment}") }
+      end
+
+      # Issue #3005 — whether a hook-block module on the level of the class object at `index` defines `method_name`:
+      # Ruby defines it on that class object itself when the block runs, so it and the class's own `def self.x`
+      # replace each other in an order the tables do not hold (the `include` against the `def`).
+      def hook_block_rival?(scope, index, method_name)
+        level = @level_starts.rindex { |start| start <= index }
+        return false if level.nil? || level >= level_count
+
+        level_entries(level).any? do |entry|
+          !entry.external? && entry.side == :instance && ResolutionChain.hook_block_module?(entry.name) &&
+            !scope.user_def_for(entry.name, method_name).nil?
+        end
+      end
+
+      GATED_HOOKS = DiscoveryIndex::CONCERN_BLOCK_HOOKS.invert.freeze
+      private_constant :GATED_HOOKS
+
+      # Issue #3005 — the hook an entry of `owner`'s bucket naming `hook` runs on: a gated concern-block hook
+      # ({DiscoveryIndex::CONCERN_BLOCK_HOOKS}) is its plain hook when `owner` is a concern and nil otherwise; any
+      # other hook is itself.
+      def self.effective_hook(discovery, owner, hook)
+        plain = GATED_HOOKS[hook]
+        return hook if plain.nil?
+
+        concern_bucket?(discovery, owner) ? plain : nil
+      end
+
+      HOOK_KEY_SLOTS = {
+        DiscoveryIndex::ENVELOPE_HOOK_EXTEND_KIND => 2, DiscoveryIndex::ENVELOPE_HOOK_EXTEND_OPEN_KIND => 1,
+        DiscoveryIndex::ENVELOPE_HOOK_DEF_KIND => 1
+      }.freeze
+      private_constant :HOOK_KEY_SLOTS
+
+      # The hook a hook-extend, open or def envelope key names (`:const_get` for a concern's), or nil for another key.
+      def self.hook_of(key)
+        slot = key.is_a?(Array) ? HOOK_KEY_SLOTS[key.first] : nil
+        slot && key[slot]
+      end
+
+      # The `[ENVELOPE_HOOK_EXTEND_KIND, written, hook]` keys of a module's envelope bucket, in recording order.
+      def self.hook_extend_keys(discovery, name)
+        bucket = discovery.discovered_parameter_envelopes[name]
+        return EMPTY_NAMES if bucket.nil?
+
+        bucket.each_key.select { |key| key.is_a?(Array) && key.first == DiscoveryIndex::ENVELOPE_HOOK_EXTEND_KIND }
+      end
+
       # The hooks that let a module `extend`ed onto N reshape N's INSTANCE side (#1730): its singleton `extended` /
       # `extend_object` run against N at the `extend` and may mix into N; its instance `included` /
       # `append_features` / `prepended` / `prepend_features` / `inherited` become N's own singleton hooks and run
@@ -359,11 +658,44 @@ module Rigor
       SINGLETON_EXTEND_HOOKS = %i[extended extend_object].freeze
       INSTANCE_EXTEND_HOOKS = %i[included append_features prepended prepend_features inherited].freeze
 
-      @extend_hook_keys = {}
+      # ADR-129 WD1 — three interning Memos, not run-scoped: a value is a frozen Array of frozen Strings built from the
+      # name and frozen constants alone, so an entry is fixed once written and holds nothing of a run. Each hit goes
+      # through `MemoAudit.check`, and an audit recomputation bypasses the table.
+      EXTEND_HOOK_KEYS = TypingState.memo(
+        :resolution_chain_extend_hook_keys,
+        audit: "extend hook keys",
+        reason: "keyed on the module name; a frozen Array of frozen Strings built from the name and the extend-hook " \
+                "constants alone"
+      )
+      HOOK_KEYS = TypingState.memo(
+        :resolution_chain_hook_keys,
+        audit: "hook keys",
+        reason: "keyed on the class name; a frozen Array of frozen Strings built from the name and " \
+                "Relevance::HOOKS alone"
+      )
+      EXTERNAL_KEYS = TypingState.memo(
+        :resolution_chain_external_keys,
+        audit: "external keys",
+        reason: "keyed on the class name; HOOK_KEYS' answer plus one frozen String built from the name"
+      )
+      private_constant :EXTEND_HOOK_KEYS, :HOOK_KEYS, :EXTERNAL_KEYS
 
       # The frozen negative method keys of `name`'s {SINGLETON_EXTEND_HOOKS} and {INSTANCE_EXTEND_HOOKS}.
       def self.extend_hook_keys(name)
-        @extend_hook_keys[name] ||= (
+        return build_extend_hook_keys(name) if Inference::MemoAudit.enabled? && Inference::MemoAudit.suspended?
+
+        state = TypingState.current
+        table = (state[EXTEND_HOOK_KEYS] ||= {})
+        stored = table[name]
+        if stored.nil?
+          return table[name] = Inference::MemoAudit.key_audit("extend hook keys") { build_extend_hook_keys(name) }
+        end
+
+        Inference::MemoAudit.check("extend hook keys", stored, name) { build_extend_hook_keys(name) }
+      end
+
+      def self.build_extend_hook_keys(name)
+        (
           SINGLETON_EXTEND_HOOKS.map { |hook| "method:#{name}.#{hook}".freeze } +
           INSTANCE_EXTEND_HOOKS.map { |hook| "method:#{name}##{hook}".freeze }
         ).freeze
@@ -387,7 +719,7 @@ module Rigor
       end
 
       # `[[spelling, resolved name or nil, candidate names], …]`: every module the project entries of an instance chain
-      # `extend`, as {Builder#extend_hook_taint?} resolved them.
+      # `extend`, as {Builder#extend_hook_taint} resolved them.
       def self.extend_targets(scope, flavor, entries)
         resolver = resolver_for(scope, flavor)
         extends = scope.discovery.discovered_extends
@@ -401,19 +733,37 @@ module Rigor
         end.uniq.freeze
       end
 
-      @hook_keys = {}
-      @external_keys = {}
-
       # The frozen `method:Name.hook` negative keys of `name`'s {Relevance::HOOKS}, built once per name.
       def self.hook_keys(name)
-        @hook_keys[name] ||= Relevance::HOOKS.map { |hook| "method:#{name}.#{hook}".freeze }.freeze
+        return build_hook_keys(name) if Inference::MemoAudit.enabled? && Inference::MemoAudit.suspended?
+
+        state = TypingState.current
+        table = (state[HOOK_KEYS] ||= {})
+        stored = table[name]
+        return table[name] = Inference::MemoAudit.key_audit("hook keys") { build_hook_keys(name) } if stored.nil?
+
+        Inference::MemoAudit.check("hook keys", stored, name) { build_hook_keys(name) }
       end
 
+      def self.build_hook_keys(name) = Relevance::HOOKS.map { |hook| "method:#{name}.#{hook}".freeze }.freeze
+
       # {hook_keys} plus the `mixin:<name>` key an external entry files for its unpositioned mixins (#1661).
       def self.external_keys(name)
-        @external_keys[name] ||= (hook_keys(name) + ["mixin:#{name}".freeze]).freeze
+        return build_external_keys(name) if Inference::MemoAudit.enabled? && Inference::MemoAudit.suspended?
+
+        state = TypingState.current
+        table = (state[EXTERNAL_KEYS] ||= {})
+        stored = table[name]
+        if stored.nil?
+          return table[name] = Inference::MemoAudit.key_audit("external keys") { build_external_keys(name) }
+        end
+
+        Inference::MemoAudit.check("external keys", stored, name) { build_external_keys(name) }
       end
 
+      def self.build_external_keys(name) = (hook_keys(name) + ["mixin:#{name}".freeze]).freeze
+      private_class_method :build_extend_hook_keys, :build_hook_keys, :build_external_keys
+
       def record_head(scope, start, side)
         ResolutionChain.record_class(scope, @root) unless start.zero? && @entries.first&.name == @root
         start.times { |index| ResolutionChain.record_entry(scope, @entries[index], side) }
@@ -445,6 +795,25 @@ module Rigor
         @entries.index { |entry| entry.name == name && entry.side == side }
       end
 
+      # Issue #2979 — the position of the first entry after `name`'s own that is a true ancestor of it, or nil when
+      # `name` has no entry on `side`. The entries of the names bound to the same class object
+      # (`K = Struct.new("Named", …)`) follow `name`'s own directly, and a `def` under one of them is a redefinition
+      # of the class's method, not an override, so a reader of "the entries after the class" starts past them.
+      def ancestors_start(scope, name, side = @side)
+        own = index_of(name, side)
+        return nil if own.nil?
+
+        twins = DiscoveryIndex.same_class_names(scope.discovery.discovered_parameter_envelopes[name])
+        start = own + 1
+        start += 1 while twins_entry?(@entries[start], twins, side)
+        start
+      end
+
+      def twins_entry?(entry, twins, side)
+        !twins.empty? && !entry.nil? && entry.side == side && twins.include?(entry.name)
+      end
+      private :twins_entry?
+
       # A LEVEL is one superclass step: the class (or its singleton) with the modules inserted around it,
       # before the next superclass's entries begin. `level_classes[k]` is that class, or nil for a level that
       # is an external superclass. Only COMPLETE levels are counted — a level the {LIMIT} cut in half is not.
@@ -496,8 +865,21 @@ module Rigor
       end
       private :compute_levels
 
-      MEMO_KEY = RunScopedSlots.register(:__rigor_resolution_chain__)
-      private_constant :MEMO_KEY
+      # ADR-129 WD1 — a run-scoped Memo: one `[discovery, flavors]` slot keyed on the discovery index's identity, the
+      # only input a chain reads.
+      #
+      # ADR-129 G2 — every table of the slot's flavor buckets is audited on a hit under `RIGOR_MEMO_AUDIT=1`, and an
+      # audit recomputation reads a fresh, unstored bucket ({.flavor_bucket}), so it reads nothing stored.
+      MEMO = TypingState.memo(
+        :resolution_chain,
+        run_scoped: true,
+        audit: ["resolution chain", "resolution chain name", "resolution chain relevance",
+                "resolution chain master order", "resolution chain linearisation", "resolution chain mark",
+                "resolution chain entry", "resolution chain external entry", "singleton hook verdict"],
+        reason: "one slot keyed on the discovery index's identity; a chain is a pure function of that frozen index " \
+                "and the flavor"
+      )
+      private_constant :MEMO
 
       FLAVORS = %i[methods constants arity].freeze
 
@@ -509,17 +891,40 @@ module Rigor
 
         bucket = flavor_bucket(scope.discovery, flavor)
         chains = bucket[side]
-        chains[class_name] || (chains[class_name] = Builder.new(scope, flavor, bucket).chain(class_name, side))
+        cached = chains[class_name]
+        if cached.nil?
+          return chains[class_name] = Inference::MemoAudit.key_audit("resolution chain") do
+            Builder.new(scope, flavor, bucket).chain(class_name, side)
+          end
+        end
+        return cached unless Inference::MemoAudit.enabled?
+
+        Inference::MemoAudit.check("resolution chain", cached.audit_signature, class_name, side) do
+          fresh = Analysis::DependencyRecorder.withhold do
+            Builder.new(scope, flavor, flavor_bucket(scope.discovery, flavor)).chain(class_name, side)
+          end
+          fresh.first.audit_signature
+        end
+        cached
       end
 
+      # The flavor's bucket of memo tables. While an audit recomputation runs ({Inference::MemoAudit.suspended?})
+      # every call answers a fresh bucket that is never stored, so the recomputation neither reads nor writes the
+      # slot.
       def self.flavor_bucket(discovery, flavor)
-        slot = Thread.current[MEMO_KEY]
+        return new_bucket if Inference::MemoAudit.enabled? && Inference::MemoAudit.suspended?
+
+        state = TypingState.current
+        slot = state[MEMO]
         unless slot && slot[0].equal?(discovery)
           slot = [discovery, {}]
-          Thread.current[MEMO_KEY] = slot
+          state[MEMO] = slot
         end
-        slot[1][flavor] ||= { instance: {}, singleton: {}, names: {}, interned: {}, externals: {}, master: {},
-                              marks: {} }
+        slot[1][flavor] ||= new_bucket
+      end
+
+      def self.new_bucket
+        { instance: {}, singleton: {}, names: {}, interned: {}, externals: {}, master: {}, marks: {} }
       end
 
       # Which project class an as-written ancestor name denotes, under one flavor — shared by the chain and
@@ -536,9 +941,13 @@ module Rigor
         # ambiguous spelling names (`:arity` only), or nil.
         def resolve(owner, raw)
           by_owner = (@names[owner] ||= {})
-          return by_owner[raw] if by_owner.key?(raw)
+          unless by_owner.key?(raw)
+            return by_owner[raw] = Inference::MemoAudit.key_audit("resolution chain name") { compute(owner, raw) }
+          end
 
-          by_owner[raw] = compute(owner, raw)
+          Inference::MemoAudit.check("resolution chain name", by_owner[raw], owner, raw) do
+            Analysis::DependencyRecorder.withhold { compute(owner, raw) }.first
+          end
         end
 
         # {#resolve}, with an ambiguous spelling read as unresolved.
@@ -547,8 +956,28 @@ module Rigor
           resolved.is_a?(String) ? resolved : nil
         end
 
+        # Issue #1592 — {#resolve_one}, or else the first candidate the project declares at all: a module holding only
+        # hooks (`included do extend M end`) is no project class under any flavor, yet its hooks run.
+        # The search stops at the first candidate that exists in any form: one RBS or a gem declares and the project's
+        # source does not has no hooks the tables know, so it answers nil.
+        #
+        # Issue #3015 — a module whose bucket holds the concern entry counts too: its body runs `extend
+        # ActiveSupport::Concern`, so the project declares it. A one-file index has no `discovered_class_sources`, and
+        # would otherwise drop a concern whose only defs sit in its blocks from an includer's chain.
+        def resolve_declared(owner, raw)
+          candidates(owner, raw).each do |candidate|
+            return candidate if project?(candidate) || @discovery.discovered_class_sources.key?(candidate) ||
+                                @discovery.discovered_parameter_envelopes[candidate]&.key?(CONCERN_KEY)
+            return nil if rbs_known?(candidate)
+          end
+          nil
+        end
+
         def candidates(owner, raw) = @scope.ancestor_name_candidates(owner, raw)
 
+        # Whether `name`, already qualified, is a project class under this flavor.
+        def project_name?(name) = project?(name)
+
         private
 
         def compute(owner, raw)
@@ -559,6 +988,12 @@ module Rigor
           alternatives.empty? ? nil : alternatives
         end
 
+        def rbs_known?(name)
+          Rigor::Reflection.rbs_class_known?(name, scope: @scope)
+        rescue StandardError
+          false
+        end
+
         def project?(name)
           case @flavor
           when :constants
@@ -574,7 +1009,7 @@ module Rigor
       end
       private_constant :Resolver
 
-      private_class_method :flavor_bucket
+      private_class_method :flavor_bucket, :new_bucket
 
       # {Relevance}'s verdict memo, one table per flavor bucket.
       def self.relevance_memo(scope, flavor)
@@ -718,9 +1153,16 @@ module Rigor
       def self.master_memo(scope, flavor, key)
         bucket = flavor_bucket(scope.discovery, flavor)
         memo = bucket[:master]
-        return memo[key] if memo.key?(key)
+        unless memo.key?(key)
+          return memo[key] = Inference::MemoAudit.key_audit("resolution chain master order") do
+            yield(Resolver.new(scope, flavor, bucket))
+          end
+        end
 
-        memo[key] = yield(Resolver.new(scope, flavor, bucket))
+        Inference::MemoAudit.check("resolution chain master order", memo[key], flavor, key) do
+          fresh = flavor_bucket(scope.discovery, flavor)
+          Analysis::DependencyRecorder.withhold { yield(Resolver.new(scope, flavor, fresh)) }.first
+        end
       end
 
       # The linearisation itself, in one world: Ruby's skip rule (`retro: false`), or every skipped insertion
@@ -770,7 +1212,7 @@ module Rigor
         # The chain for `root`, carrying its retro world when the skip rule skipped anything on the way.
         def chain(root, side)
           entries, starts, classes, forks, marks, retro_ok = lin_for(root, side)
-          order_marked = marks.any? { |mark| mark.kind != :extend_hook }
+          order_marked = marks.any? { |mark| !HOOK_MARK_KINDS.include?(mark.kind) }
           retro = build_retro(root, side) if forks == 1 && retro_ok && !order_marked && !@retro
           cut_at = cut_position(entries)
           return whole_chain(root, side, entries, starts, classes, [forks, marks], retro) if cut_at.nil?
@@ -829,14 +1271,10 @@ module Rigor
           memoised(@retro ? :lin_singleton_retro : :lin_singleton, name, depth) { compute_singleton(name, depth) }
         end
 
-        def memoised(table, name, depth)
+        def memoised(table, name, depth, &)
           memo = (@bucket[table] ||= {})
           cached = memo[name]
-          if cached
-            # A memoised chain's forks are the asker's too.
-            @frames.last&.absorb(cached[3], cached[4], cached[5])
-            return cached
-          end
+          return absorb_cached(audited_lin(cached, table, name)) if cached
 
           # A cycle (`class Foo < Foo` resolved inside its own namespace) or a hierarchy deeper than the budget
           # contributes nothing past that point, and the chains computed while it did are not memoised: they
@@ -851,7 +1289,7 @@ module Rigor
           frame = Frame.new(0, false, NO_MARKS, true)
           @frames.push(frame)
           stack.push(name)
-          entries, starts, classes = yield
+          entries, starts, classes = Inference::MemoAudit.key_audit("resolution chain linearisation", &)
           stack.pop
           @frames.pop
           lin = [entries, starts, classes, frame.forks, frame.marks, frame.retro_ok].freeze
@@ -860,6 +1298,29 @@ module Rigor
           lin
         end
 
+        # A memoised linearisation rebuilt for the audit by a Builder over a fresh bucket. A memoised one met no
+        # cycle and stayed inside the depth budget, so its depth does not change it; a retro world that fit
+        # {LIMIT} once fits it again.
+        # A memoised chain's forks are the asker's too.
+        def absorb_cached(cached)
+          @frames.last&.absorb(cached[3], cached[4], cached[5])
+          cached
+        end
+
+        def audited_lin(cached, table, name)
+          Inference::MemoAudit.check("resolution chain linearisation", cached, table, name) { fresh_lin(table, name) }
+        end
+
+        SINGLETON_LIN_TABLES = %i[lin_singleton lin_singleton_retro].freeze
+        private_constant :SINGLETON_LIN_TABLES
+
+        def fresh_lin(table, name)
+          side = SINGLETON_LIN_TABLES.include?(table) ? :singleton : :instance
+          builder = Builder.new(@scope, @flavor, ResolutionChain.send(:flavor_bucket, @discovery, @flavor),
+                                retro: @retro)
+          Analysis::DependencyRecorder.withhold { builder.send(:lin_for, name, side) }.first
+        end
+
         def hand_up(frame)
           parent = @frames.last
           return if parent.nil?
@@ -869,9 +1330,11 @@ module Rigor
         end
 
         def compute_instance(name, depth)
-          # `discovered_includes` already carries the prepended names, so it counts every instance-side edge once.
-          mark_unsettled(name, :include, (@discovery.discovered_includes[name] || EMPTY).size)
-          @frames.last.add_marks(mark_for(name, :extend_hook, WILDCARD_LIST, false)) if extend_hook_taint?(name)
+          twins = same_class_twins(name)
+          mark_instance_node(name, :include)
+          twins.each { |owner| mark_instance_node(owner, :include) }
+          return same_class_instance(name, twins, depth) unless twins.empty?
+
           entries = [project_entry(name, :instance)]
           super_lin = superclass_lin(name, :instance, depth)
           entries.concat(super_lin[0])
@@ -883,12 +1346,333 @@ module Rigor
         end
 
         def compute_singleton(name, depth)
-          mark_unsettled(name, :extend, (@discovery.discovered_extends[name] || EMPTY).size)
+          twins = same_class_twins(name)
+          own = @discovery.discovered_extends[name] || EMPTY
+          own_prepends = own_singleton_prepends(name, own)
+          mark_unsettled(name, :extend, singleton_order_edges(own, own_prepends))
+          twins.each { |owner| mark_unsettled(owner, :extend, (@discovery.discovered_extends[owner] || EMPTY).size) }
+          return same_class_singleton(name, twins, depth) unless twins.empty?
+
           entries = [project_entry(name, :singleton)]
           super_lin = superclass_lin(name, :singleton, depth)
           entries.concat(super_lin[0])
-          extends = @discovery.discovered_extends[name] || EMPTY
-          super_start = include_all(entries, name, extends, EMPTY, depth, [0, 1])
+          own_extends = own_prepends.empty? ? own : own - own_prepends
+          extends, prepends = singleton_mixins(name, own_extends, own_prepends)
+          boundary = prepends.empty? ? CLASS_FIRST : prepend_all(entries, name, prepends, depth)
+          super_start = include_all(entries, name, extends, EMPTY, depth, boundary)
+          finish(entries, name, super_lin, super_start)
+        end
+
+        # #1592 — the class's own `extend`s and the modules its direct mixins' hooks extend it with
+        # ({#hook_extensions}), nearest first. Ruby inserts each where its statement ran, and the tables keep the
+        # `extend` and `include` statements apart, so with both kinds present the two blocks' order is a fork: the
+        # chain puts the own `extend`s nearer (the usual layout writes them after the `include`s) and the retro world
+        # the hooks' modules, and a reader that the two worlds answer alike stands, since then only one block can
+        # answer the name. An order the hooks do not fix, or an include whose own position is not a fact, is two
+        # forks, which settle to master. Answers `[extends, prepends]`: a concern's `ClassMethods` on a prepend edge is
+        # prepended to the class object (`Concern#prepend_features` runs `base.singleton_class.prepend`), so it sits
+        # ahead of the class object's own entry.
+        #
+        # Issue #2998 — `own_prepends` are the class's own singleton-side prepends ({#own_singleton_prepends}), which
+        # sit ahead of the class object too. An `extend` always sits behind the class object and a prepend always
+        # ahead of it, so only two prepends can trade places ({#order_prepends}).
+        def singleton_mixins(name, extends, own_prepends)
+          plan = hook_extensions(name)
+          if plan.open || unnamed_instance_mixin?(name)
+            @frames.last.add_marks(mark_for(name, :include_hook, UNNAMED_LIST, false))
+          end
+          fork_hook_order(name, 2) unless plan.ordered || (plan.extends.empty? && plan.prepends.empty?)
+          prepends = order_prepends(name, own_prepends, plan.prepends)
+          hooked = plan.extends
+          return [extends, prepends] if hooked.empty?
+          return [hooked, prepends] if extends.empty?
+
+          fork_hook_order(name, 1)
+          [@retro ? hooked + extends : extends + hooked, prepends]
+        end
+
+        # The class object's prepends, nearest first, once its own are placed against its hooks'. Where their order
+        # is not a fact (own and hook prepends both, or two own ones from two files or with an edge whose position is
+        # not a fact), the chain counts two forks, which settle to master, and the class takes a `:prepend_order`
+        # mark: the typing read declines a definer from its prepend region, since neither order is Ruby's for sure.
+        def order_prepends(name, own, hooked)
+          return hooked if own.empty?
+
+          if !hooked.empty? || (own.size > 1 && !own_prepends_ordered?(name))
+            @frames.last.forks += 2
+            @frames.last.add_marks(mark_for(name, :prepend_order, nil, false))
+          end
+          own + hooked
+        end
+
+        def own_prepends_ordered?(name)
+          !multi_file?(name) && (@discovery.unpositioned_mixins[name]&.dig(:extend) || EMPTY).empty?
+        end
+
+        # Issue #2998 — the spellings of `name`'s singleton edges (`discovered_extends`) that are prepends: a
+        # `class << self; prepend P` or a `singleton_class.prepend P` the walk filed as a
+        # `[ENVELOPE_SINGLETON_PREPEND_KIND, "P"]` entry. They keep the table's order, nearest first, which is the
+        # prepends' own: a later `prepend` sits ahead of an earlier one. A class with any takes the `:singleton_prepend`
+        # mark, which tells the typing read that master's order, which knows no singleton prepend, may answer
+        # otherwise.
+        #
+        # Issue #3020 — a prepend whose module no table names (`class << self; prepend(*MODS)`,
+        # `singleton_class.prepend(*MODS)`) files the `"?"` entry instead, which no edge spells: the class takes the
+        # `:unnamed_prepend` mark, and the typing read declines a definer at or behind the class object.
+        def own_singleton_prepends(name, own)
+          bucket = @discovery.discovered_parameter_envelopes[name]
+          return EMPTY if bucket.nil?
+
+          @frames.last.add_marks(mark_for(name, :unnamed_prepend, nil, false)) if bucket.key?(UNNAMED_PREPEND_KEY)
+          return EMPTY if own.empty?
+
+          prepends = own.select { |raw| bucket.key?([DiscoveryIndex::ENVELOPE_SINGLETON_PREPEND_KIND, raw]) }
+          return EMPTY if prepends.empty?
+
+          @frames.last.add_marks(mark_for(name, :singleton_prepend, nil, false))
+          prepends
+        end
+
+        # The edge count the multi-file rule weighs: a prepend sits ahead of the class object and an `extend` behind
+        # it whatever the load order, so only edges of one kind can trade places across files.
+        def singleton_order_edges(own, own_prepends)
+          return own.size if own_prepends.empty?
+
+          [own_prepends.size, own.size - own_prepends.size].max
+        end
+
+        def fork_hook_order(name, weight)
+          @frames.last.forks += weight
+          @frames.last.add_marks(mark_for(name, :hook_order, nil, false))
+        end
+
+        # The {HookPlan} for a class: the `[owner, spelling]` pairs of the modules the hooks of its direct
+        # mixins extend it with, nearest first (a later include's ahead of an earlier one's, and within one mixin the
+        # hook's own extends ahead of a concern's `ClassMethods`, which `append_features` extends before the
+        # `included` block runs); the concern `ClassMethods` its prepend edges prepend to its singleton; whether one of
+        # those hooks may extend it with a module no entry names; and whether the order is a fact. A concern includer
+        # gets nothing from a concern: `Concern#append_features` records it as a dependency instead (#2992).
+        def hook_extensions(name)
+          includes = @discovery.discovered_includes[name] || EMPTY
+          return NO_HOOKS if includes.empty?
+
+          listed = @discovery.unpositioned_mixins[name]&.dig(:include) || EMPTY
+          plan = HookPlan.new([], [], false, true)
+          each_hooked_mixin(name, includes) do |raw, mixin, hooks, loose|
+            unpositioned = loose || listed.include?(raw) || listed.include?(WILDCARD_LIST.first)
+            merge_targets(plan, hook_targets(mixin, hooks), unpositioned)
+            plan.open ||= uncertain_dependencies?(mixin)
+          end
+          # Two files' includes run in load order.
+          plan.ordered &&= plan.extends.size + plan.prepends.size < 2 || !multi_file?(name)
+          plan
+        end
+
+        # Adds one mixin's targets to the class's plan; an include whose own position is not a fact (`unpositioned`)
+        # leaves its modules' order unknown.
+        def merge_targets(plan, targets, unpositioned)
+          plan.open ||= targets.open
+          return if targets.extends.empty? && targets.prepends.empty?
+
+          plan.ordered &&= targets.ordered && !unpositioned
+          plan.extends.concat(targets.extends)
+          plan.prepends.concat(targets.prepends)
+        end
+
+        # Issue #2994 — whether a module no table names may be mixed into `name`'s instance side by a call whose target
+        # is `name` itself, so that its `included` / `prepended` hook runs with `name` as `base` and may extend the
+        # class object with anything: `name` lists {Relevance::UNNAMED} on its own instance side (`include(*MODS)`,
+        # `include helper`), or a module it includes does (a hook's `base.include(*MODS)`; that module's own
+        # `include(*MODS)` is read so too). A superclass's own mark is read when its singleton chain is built. The
+        # entries this reads are the class's own sites and its direct mixins', which a singleton chain's readers file
+        # already. An extended module's hook that splats a module in already declines the read on another route.
+        def unnamed_instance_mixin?(name)
+          return true if lists_unnamed?(name)
+
+          (@discovery.discovered_includes[name] || EMPTY).uniq.any? do |raw|
+            mixin = @resolver.resolve_declared(name, raw)
+            !mixin.nil? && lists_unnamed?(mixin)
+          end
+        end
+
+        def lists_unnamed?(name)
+          listed = @discovery.unpositioned_mixins[name]&.dig(:include)
+          !listed.nil? && listed.include?(UNNAMED_LIST.last)
+        end
+
+        HookPlan = Struct.new(:extends, :prepends, :open, :ordered)
+        private_constant :HookPlan
+
+        # Yields each direct mixin of `name`, nearest first, as `[spelling, resolved, hooks]`: the hooks its edges
+        # run, `:included` for an `include` and `:prepended` for a `prepend`.
+        #
+        # Issue #2992 — a concern mixin's dependencies follow it, each on the same edge
+        # ({ResolutionChain.concern_dependencies}): `Concern#append_features` includes them into `name` ahead of the
+        # concern itself, so their modules sit farther than the concern's. `spelling` is the mixin's for each, and
+        # `loose` says a dependency's place is not a fact: `Concern` puts a prepended dependency ahead of the included
+        # ones, which the tables list the other way, and two files of the concern add theirs in load order.
+        def each_hooked_mixin(name, includes)
+          prepends = @discovery.discovered_prepends[name] || EMPTY
+          concern = concern?(name)
+          includes.uniq.each do |raw|
+            mixin = @resolver.resolve_declared(name, raw)
+            next if mixin.nil? || (concern && concern?(mixin))
+
+            hooks = []
+            hooks << :prepended if prepends.include?(raw)
+            hooks << :included if includes.count(raw) > prepends.count(raw)
+            yield raw, mixin, hooks, false
+            dependencies = ResolutionChain.concern_dependencies(@discovery, @resolver, mixin)
+            loose = dependencies.size > 1 && dependencies.any? { |member| loose_dependencies?(member, mixin) }
+            dependencies.each { |dependency| yield raw, dependency, hooks, loose }
+          end
+        end
+
+        # Issue #2992 — whether a concern declared in two files includes a concern its dependency entries do not name:
+        # written in a reopening without the `extend ActiveSupport::Concern`, that `include` is a dependency when the
+        # reopening loads after the `extend` and an ordinary include of the concern itself when it loads first, so the
+        # includer may or may not be extended with that concern's modules.
+        def uncertain_dependencies?(mixin)
+          return false unless concern?(mixin) && multi_file?(mixin)
+
+          spellings = ResolutionChain.dependency_spellings(@discovery, mixin)
+          (@discovery.discovered_includes[mixin] || EMPTY).any? do |raw|
+            next false if spellings.include?(raw)
+
+            dependency = @resolver.resolve_declared(mixin, raw)
+            !dependency.nil? && concern?(dependency)
+          end
+        end
+
+        # Whether the concern `owner` or its dependency `member` prepends a module or is declared in two files.
+        def loose_dependencies?(member, owner)
+          [member, owner].any? { |name| multi_file?(name) || !(@discovery.discovered_prepends[name] || EMPTY).empty? }
+        end
+
+        NO_HOOKS = HookPlan.new(EMPTY, EMPTY, false, true).freeze
+        private_constant :NO_HOOKS
+
+        def concern?(name)
+          bucket = @discovery.discovered_parameter_envelopes[name]
+          !bucket.nil? && bucket.key?(CONCERN_KEY)
+        end
+
+        # One mixin's hook-extended modules for the edges `hooks` runs, as {#hook_extensions} answers them.
+        # A hook defined twice (`ENVELOPE_HOOK_DEF_KIND`) is open: which definition Ruby keeps is load order.
+        #
+        # Issue #3005 — a hook block's `def self.x`s (`<included>`) sit on the class object itself, ahead of every
+        # module the block extends it with, so that module goes first and does not make the order unknown.
+        def hook_targets(mixin, hooks)
+          named, open = hook_keys(mixin, hooks)
+          blocks, modules = named.partition { |raw| DiscoveryIndex::HOOK_BLOCK_SEGMENTS.include?(raw) }
+          pairs = (blocks + modules).map { |raw| hook_target_pair(mixin, raw) }
+          targets = HookPlan.new(pairs, [], open, modules.size <= 1)
+          found = concern?(mixin) && const_get_target(mixin, "ClassMethods")
+          (hooks.include?(:prepended) ? targets.prepends : targets.extends) << [mixin, "::#{found}"] if found
+          targets
+        end
+
+        # `[named, open]`: the spellings the mixin's hooks for `hooks` extend with, and whether one of them is open
+        # or defined twice.
+        def hook_keys(mixin, hooks)
+          named = []
+          open = false
+          defs = Hash.new(0)
+          (@discovery.discovered_parameter_envelopes[mixin] || EMPTY_BUCKET).each_key do |key|
+            next unless hooks.include?(ResolutionChain.effective_hook(@discovery, mixin, ResolutionChain.hook_of(key)))
+
+            case key.first
+            when DiscoveryIndex::ENVELOPE_HOOK_EXTEND_KIND then named << key[1]
+            when DiscoveryIndex::ENVELOPE_HOOK_EXTEND_OPEN_KIND then open = true
+            else defs[key[1]] += 1
+            end
+          end
+          [named.uniq, open || defs.each_value.any? { |count| count > 1 }]
+        end
+
+        EMPTY_BUCKET = {}.freeze
+        private_constant :EMPTY_BUCKET
+
+        # The module a hook's constant names, written in the mixin's body: `Mixin::Raw` first (the mixin is the
+        # innermost cref there), then the names its header's nesting gives. A name no project module answers stays
+        # the mixin's spelling, an external entry.
+        def hook_target_pair(mixin, raw)
+          own = "#{mixin}::#{raw}"
+          return [mixin, "::#{own}"] if !raw.start_with?("::") && @resolver.project_name?(own)
+
+          [mixin, raw]
+        end
+
+        # `mixin.const_get(raw)`, as `Concern#append_features` looks `ClassMethods` up: `Name::Raw` for each entry of
+        # the mixin's own instance chain, then a top-level `Raw`; nil when no project module answers, which Concern
+        # then does not extend.
+        #
+        # Issue #2992 — a concern the mixin depends on is no ancestor of it ({ResolutionChain.concern_dependencies}),
+        # so its `ClassMethods` is not found here: it reaches the includer as that dependency's own.
+        def const_get_target(mixin, raw)
+          chain = ResolutionChain.for(@scope, mixin, :instance, @flavor)
+          dependencies = ResolutionChain.concern_dependencies(@discovery, @resolver, mixin)
+          chain.entries.each do |entry|
+            next if dependencies.include?(entry.name)
+
+            names = entry.external? ? entry.candidates : [entry.name]
+            found = names.map { |owner| [owner, "#{owner}::#{raw}"] }.find do |owner, candidate|
+              @resolver.project_name?(candidate) && ResolutionChain.const_get_candidate?(@discovery, owner, candidate)
+            end&.last
+            return found if found
+          end
+          @resolver.project_name?(raw) ? raw : nil
+        end
+
+        # The instance-side marks of one node; `kind` is the side's mixin kind, `:include`. `discovered_includes`
+        # already carries the prepended names, so it counts every instance-side edge once.
+        def mark_instance_node(name, kind)
+          mark_unsettled(name, kind, (@discovery.discovered_includes[name] || EMPTY).size)
+          hook = extend_hook_taint(name)
+          @frames.last.add_marks(mark_for(name, :extend_hook, hook, false)) if hook
+        end
+
+        # Issue #2979 — the names `name`'s envelope bucket binds to the same class object (`K = Struct.new("Named",
+        # …)` makes `K` and `Struct::Named` one class), without `name`; empty, and allocating nothing, for nearly every
+        # class. The chain of either name heads with every name's entry, so a reader asks each name's own tables where
+        # Ruby asks the one class's; nothing is copied between the names. Only the direct binding counts: two
+        # `Struct.new("Named", …)` writes make two classes in Ruby, and neither constant reaches the other's tables
+        # through `Struct::Named`. {ResolutionChain#ancestors_start} tells a reader where the true ancestors begin.
+        def same_class_twins(name)
+          twins = DiscoveryIndex.same_class_names(@discovery.discovered_parameter_envelopes[name])
+          twins.include?(name) ? twins - [name] : twins
+        end
+
+        # The instance side of a class with twins: every name's prepends ahead of the class, then every name's
+        # includes after the LAST name, so the names stay ahead of every module either one includes, as the one class
+        # heads its own ancestors. The superclass edge stays `name`'s own: a Struct's class has none the tables
+        # record, under either name.
+        def same_class_instance(name, twins, depth)
+          names = [name, *twins].uniq
+          entries = names.map { |owner| project_entry(owner, :instance) }
+          super_lin = superclass_lin(name, :instance, depth)
+          entries.concat(super_lin[0])
+          boundary = [0, names.size]
+          names.each do |owner|
+            boundary = prepend_all(entries, owner, @discovery.discovered_prepends[owner] || EMPTY, depth, boundary)
+          end
+          super_start = names.reduce(boundary[1]) do |start, owner|
+            include_all(entries, owner, @discovery.discovered_includes[owner] || EMPTY,
+                        @discovery.discovered_prepends[owner] || EMPTY, depth, [boundary[0] + names.size - 1, start])
+          end
+          finish(entries, name, super_lin, super_start)
+        end
+
+        # The singleton twin of {#same_class_instance}: every name's class-object entry, then every name's extends.
+        def same_class_singleton(name, twins, depth)
+          names = [name, *twins].uniq
+          entries = names.map { |owner| project_entry(owner, :singleton) }
+          super_lin = superclass_lin(name, :singleton, depth)
+          entries.concat(super_lin[0])
+          super_start = names.reduce(names.size) do |start, owner|
+            include_all(entries, owner, @discovery.discovered_extends[owner] || EMPTY, EMPTY, depth,
+                        [names.size - 1, start])
+          end
           finish(entries, name, super_lin, super_start)
         end
 
@@ -910,24 +1694,53 @@ module Rigor
         # The one-element frozen array carrying the {Mark} of `[name, kind]`, interned in the bucket.
         def mark_for(name, kind, listed, multi)
           by_node = (@bucket[:marks][kind] ||= {})
-          by_node[name] ||= [ResolutionChain::Mark.new(name, kind, listed.nil? ? EMPTY : listed.to_a.freeze,
-                                                       multi)].freeze
+          cached = by_node[name]
+          if cached.nil?
+            return by_node[name] = Inference::MemoAudit.key_audit("resolution chain mark") do
+              new_mark(name, kind, listed, multi)
+            end
+          end
+          return cached unless Inference::MemoAudit.enabled?
+
+          # The failure names the whole key: the bucket's flavor, the mark's kind, the node.
+          Inference::MemoAudit.check("resolution chain mark", cached, [@flavor, kind], name) do
+            new_mark(name, kind, listed, multi)
+          end
         end
 
-        WILDCARD_LIST = ["*"].freeze # Relevance::WILDCARD, which loads after this file
-        private_constant :WILDCARD_LIST
+        def new_mark(name, kind, listed, multi)
+          [ResolutionChain::Mark.new(name, kind, listed.nil? ? EMPTY : listed.to_a.freeze, multi)].freeze
+        end
+
+        # The `[origin, super_start]` of a one-name chain: the class at 0, its superclass's entries from 1.
+        CLASS_FIRST = [0, 1].freeze
+        private_constant :CLASS_FIRST
 
         # #1730 — whether a module `name` extends has a hook that may mix into `name`'s instance side or its
         # includers' ({ResolutionChain.extend_reshapes_instance?}). Ruby runs it at the `extend`, so the mixin is
         # not a fact of the tables and `name`'s instance side is unpositioned. A spelling no project module
         # answers taints nothing: the project cannot see its hooks.
-        def extend_hook_taint?(name)
-          (@discovery.discovered_extends[name] || EMPTY).any? do |raw|
+        #
+        # The mark's list: nil when no extended module taints, else {UNNAMED_LIST} when one of those modules lists `"?"`
+        # (#2991), {WILDCARD_LIST} otherwise. Only the marker carries over: a name such a module lists is spelled
+        # relative to that module, not to the extender.
+        def extend_hook_taint(name)
+          found = nil
+          (@discovery.discovered_extends[name] || EMPTY).each do |raw|
             resolved = @resolver.resolve_one(name, raw)
-            !resolved.nil? && ResolutionChain.extend_reshapes_instance?(@scope, resolved)
+            next if resolved.nil? || !ResolutionChain.extend_reshapes_instance?(@scope, resolved)
+            return UNNAMED_LIST if @discovery.unpositioned_mixins[resolved][:include].include?(UNNAMED_LIST.last)
+
+            found = WILDCARD_LIST
           end
+          found
         end
 
+        WILDCARD_LIST = ["*"].freeze # Relevance::WILDCARD, which loads after this file
+        UNNAMED_LIST = ["*", "?"].freeze # with Relevance::UNNAMED
+        UNNAMED_PREPEND_KEY = [DiscoveryIndex::ENVELOPE_SINGLETON_PREPEND_KIND, "?"].freeze # with Relevance::UNNAMED
+        private_constant :WILDCARD_LIST, :UNNAMED_LIST, :UNNAMED_PREPEND_KEY
+
         def multi_file?(name)
           sites = @discovery.discovered_class_sources[name]
           !sites.nil? && sites.size >= 2
@@ -972,14 +1785,15 @@ module Rigor
         # module's own includes may have run before or after), and the tables record `include M; prepend M`
         # exactly as a plain `prepend M`. A direct prepend of the module itself is always inserted, in Ruby and
         # here, so it forks nothing.
-        def prepend_all(entries, owner, prepends, depth)
-          origin = 0
-          super_start = 1
+        def prepend_all(entries, owner, prepends, depth, boundary = CLASS_FIRST)
+          origin, super_start = boundary
           # The table holds every statement, nearest first: a same-owner repeat is a no-op in Ruby (the first
           # statement wins), so it is dropped here rather than met as a fork.
           prepends.reverse.uniq.each do |raw|
-            modules = Array(resolve(owner, raw))
-            each_mixin_chain(owner, raw, depth) do |sub|
+            # A hook's module comes as `[owner, spelling]`, as in {#include_all}.
+            from, raw = raw.is_a?(Array) ? raw : [owner, raw]
+            modules = Array(resolve(from, raw))
+            each_mixin_chain(from, raw, depth) do |sub|
               point = -1
               sub.each do |entry|
                 found = entries.index(entry)
@@ -1010,7 +1824,9 @@ module Rigor
           mixins.reverse_each do |raw|
             next if skip.include?(raw)
 
-            each_mixin_chain(owner, raw, depth) do |sub|
+            # A hook's module comes as `[owner, spelling]`: the mixin whose body wrote it resolves it.
+            from, raw = raw.is_a?(Array) ? raw : [owner, raw]
+            each_mixin_chain(from, raw, depth) do |sub|
               point = origin
               sub.each_with_index do |entry, index|
                 found = @retro ? nil : entries.index(entry)
@@ -1051,14 +1867,43 @@ module Rigor
 
         def project_entry(name, side)
           by_side = (@bucket[:interned][side] ||= {})
-          by_side[name] ||= Entry.new(name, side, nil, nil, false, name.to_s.split("::").last.freeze, nil)
+          cached = by_side[name]
+          if cached.nil?
+            return by_side[name] = Inference::MemoAudit.key_audit("resolution chain entry") do
+              new_project_entry(name, side)
+            end
+          end
+          return cached unless Inference::MemoAudit.enabled?
+
+          Inference::MemoAudit.check("resolution chain entry", cached, [@flavor, side], name) do
+            new_project_entry(name, side)
+          end
+        end
+
+        def new_project_entry(name, side)
+          Entry.new(name, side, nil, nil, false, name.to_s.split("::").last.freeze, nil)
         end
 
         def external_entry(owner, raw, side, superclass_edge)
           by_edge = ((@bucket[:externals][side] ||= {})[superclass_edge] ||= {})
           by_owner = (by_edge[owner] ||= {})
-          by_owner[raw] ||= Entry.new(nil, side, raw, @scope.ancestor_name_candidates(owner, raw).freeze,
-                                      superclass_edge, nil, owner)
+          cached = by_owner[raw]
+          if cached.nil?
+            return by_owner[raw] = Inference::MemoAudit.key_audit("resolution chain external entry") do
+              new_external_entry(owner, raw, side, superclass_edge)
+            end
+          end
+          return cached unless Inference::MemoAudit.enabled?
+
+          # The failure names the whole key: flavor, side, superclass edge, owner and spelling.
+          Inference::MemoAudit.check("resolution chain external entry", cached, [@flavor, side, superclass_edge],
+                                     [owner, raw]) do
+            Analysis::DependencyRecorder.withhold { new_external_entry(owner, raw, side, superclass_edge) }.first
+          end
+        end
+
+        def new_external_entry(owner, raw, side, superclass_edge)
+          Entry.new(nil, side, raw, @scope.ancestor_name_candidates(owner, raw).freeze, superclass_edge, nil, owner)
         end
       end
       private_constant :Builder