rigortype 0.4.6 → 0.4.8

data/lib/rigor/inference/declaration_walk/traversal.rb

@@ -235,7 +235,7 @@ module Rigor
         # A subset of a multi-collector run that its nodes keep asking for, built the first time and reused:
         # each collector alone (a pair in which one declines), the run without each collector (a larger run in
         # which one declines), and the run split by `factory_block` and `lexical_prefix` variant where it mixes
-        # them. `key` is a Symbol for a split, or `[kind, collector]` for the other two.
+        # them. `kind` names the table; `key` is the collector, or the rule's Symbol for a split.
         def subset(kind, collector = nil)
           table = (@subsets[kind] ||= {}.compare_by_identity)
           key = collector || kind

data/lib/rigor/inference/declaration_walk.rb

@@ -5,3 +5,7 @@
 # the indexer, which loads the walk. `ScopeIndexer` itself requires the traversal file rather than this one, which
 # keeps the two free of a require cycle.
 require_relative "scope_indexer"
+
+# {Rigor::Reflection.class_declarations_in}'s collectors: the plugin-facing walk lives with `Reflection` but needs the
+# walk above, so it is loaded here rather than by `reflection/declarations`, which the engine-free paths load.
+require_relative "../reflection/declaration_collectors"

data/lib/rigor/inference/deep_erasure.rb

@@ -5,6 +5,7 @@ require_relative "../type"
 require_relative "../source/node_walker"
 require_relative "mutation_rejoin"
 require_relative "receiver_alias"
+require_relative "set_mutation"
 
 module Rigor
   module Inference
@@ -54,11 +55,31 @@ module Rigor
       # and so does `it` / `_1` wherever it is read, and an accumulator parameter (`inject([]) { |acc, e| acc << e }`):
       # the rule is wider than "an element", which only loses precision. It does not follow an alias (`y = x`) or
       # an element passed to a call (`add(x)`), which the straight-line widening does not either.
-      def element_mutation?(body, names)
+      #
+      # A Set-only mutator (`add`, `merge`, `subtract`, … — {SetMutation::MUTATORS} less `SHAPE_MUTATORS`) counts
+      # only when `set_held` is given and answers true (issue #2363). The names are read without their receiver,
+      # and `merge` on a Hash element returns a new Hash, so the caller answers from the collection's type whether
+      # an element could be a Set at all ({holds_set?}). The block runs at the first such site, at most once.
+      def element_mutation?(body, names, &set_held)
         return false if body.nil?
 
         names |= nested_parameter_names(body)
-        Source::NodeWalker.each(body).any? { |node| element_mutation_site?(node, names) }
+        Source::NodeWalker.each(body).any? { |node| element_mutation_site?(node, names, set_held) }
+      end
+
+      # True when `type` holds a `Set` at some depth: as itself, a union member, a `Tuple` element, a `HashShape`
+      # value or a type argument. A collection whose type holds none has no element a Set-only mutator can be
+      # mutating, so a `merge` on one of its elements is `Hash#merge`, which returns a new Hash.
+      def holds_set?(type)
+        case type
+        when Type::Constant then SetMutation.constant?(type)
+        when Type::Nominal then type.class_name == "Set" || type.type_args.any? { |arg| holds_set?(arg) }
+        when Type::Tuple then type.elements.any? { |element| holds_set?(element) }
+        when Type::HashShape then type.pairs.each_value.any? { |value| holds_set?(value) }
+        when Type::Union then type.members.any? { |member| holds_set?(member) }
+        when Type::Difference then holds_set?(type.base)
+        else false
+        end
       end
 
       # The names `parameters` (a block's parameter list, or a `for` index) binds.
@@ -80,9 +101,12 @@ module Rigor
         end
       end
 
-      def element_mutation_site?(node, names)
+      def element_mutation_site?(node, names, set_held)
         if node.is_a?(Prism::CallNode)
-          MutationWidening::SHAPE_MUTATORS.include?(node.name) && element_rooted?(node.receiver, names)
+          return false unless element_rooted?(node.receiver, names)
+
+          MutationWidening::SHAPE_MUTATORS.include?(node.name) ||
+            (!set_held.nil? && SetMutation::MUTATORS.include?(node.name) && set_held.call)
         else
           ELEMENT_WRITE_NODES.include?(node.class) && element_rooted?(node.receiver, names)
         end
@@ -101,15 +125,23 @@ module Rigor
       # A block call hands each of its receiver's elements to the block's parameters, and a body that mutates one in
       # place (`a.each { |x| x << 2 }`) changes the shape the receiver's binding still carries one level down
       # (`[[1]]`). The receiver's variables drop their shapes at every depth ({widen}), as a `for` loop's
-      # value does ({StatementEvaluator#for_collection_after}).
+      # value does ({StatementEvaluator#for_collection_after}). A receiver that is a call exposing a variable's
+      # elements (`h.values`, `a.dup`, `a.each_with_index`) names that variable ({ReceiverAlias.element_sources}).
       def widen_element_aliases(receiver, body, names, scope)
-        return scope unless element_mutation?(body, names)
+        return scope unless element_mutation?(body, names) { receiver_holds_set?(receiver, scope) }
 
         widen_receiver(receiver, scope)
       end
 
+      def receiver_holds_set?(receiver, scope)
+        ReceiverAlias.element_sources(receiver).any? do |read|
+          getter, = MutationWidening::ALIAS_ACCESSORS[read.class]
+          getter && holds_set?(scope.public_send(getter, ReceiverAlias.read_name(read)))
+        end
+      end
+
       def widen_receiver(receiver, scope)
-        ReceiverAlias.candidates(receiver).reduce(scope) { |acc, read| widen_read(read, acc) }
+        ReceiverAlias.element_sources(receiver).reduce(scope) { |acc, read| widen_read(read, acc) }
       end
 
       # `a.each(&:strip!)`: a block argument naming a mutator mutates every element it is handed.

data/lib/rigor/inference/def_handle.rb

@@ -8,7 +8,7 @@ module Rigor
     # file's methods: the file was never parsed this run, so there is no live node to store. A handle records
     # the four things needed to resolve, fingerprint, or scope it without the node:
     #
-    # - `path` + `node_id` — the resolution key. The per-run parse memo ({Scope#resolve_def_handle}) parses the
+    # - `path` + `node_id` — the resolution key. The per-run parse memo ({DefNodeResolver.resolve}) parses the
     #   file once and returns the `Prism::DefNode` whose `node_id` matches (Prism `node_id` is stable across
     #   repeated parses of identical bytes). `name` is the cross-check: a resolved node whose `name` differs
     #   from the handle's forces a fresh walk (bundle/source skew that the digest gate should make impossible —

data/lib/rigor/inference/def_node_resolver.rb

@@ -2,6 +2,7 @@
 
 require "prism"
 require_relative "def_handle"
+require_relative "../typing_state"
 require_relative "../source/node_children"
 
 module Rigor
@@ -20,23 +21,35 @@ module Rigor
     # file, and finally nil — conservative (the accessor then reports no user def, losing precision but never
     # firing a wrong diagnostic), never silent.
     #
-    # The memo is a thread-local installed for the duration of a run (the {Cache::FileDigest} pattern:
-    # process-local, Ractor-safe, never crosses a fork boundary, reset per run). Outside a run scope every
+    # The memo is a {TypingState} Frame installed for the duration of a run ({.with_run}) and restored on the way
+    # out: per thread, and a fork child inherits whatever is installed at the fork. Outside a run scope every
     # resolution parses directly — a correct if un-memoised fallback for runner-less probes.
     module DefNodeResolver
-      MEMO_KEY = :rigor_def_node_resolver_memo
-      private_constant :MEMO_KEY
+      # ADR-129 WD1 — the run's memo is a Frame: {.with_run} installs it for the run and restores the previous one, and
+      # whether one is installed changes answers (outside a run every resolution parses afresh and no `Module.nesting`
+      # is recorded). The installed hash is frozen; the four tables in it are extensional caches its owner fills in
+      # place without a touch (Memos by kind, whose entry is fixed once written): `nodes` is keyed on
+      # `(path, node_id)`, `indexes` and `refinement_queries` on the file's path, and `nestings` on the identity of
+      # the node this module minted, holding the nesting the handle's bundle row (or the file's `refine` bodies)
+      # recorded for it.
+      RUN_MEMO = TypingState.frame(
+        :def_node_resolver_run,
+        memos: %i[nodes indexes nestings refinement_queries],
+        reason: "installed per run by with_run; its tables are extensional caches, keyed on (path, node_id), on the " \
+                "path, and (nestings) on the minted node's identity, filled in place",
+        # G1′ witness: an incremental recheck types a file against handles of the unchanged files, and
+        # {.resolve} reads the run's tables from inside `type_of` (#2874).
+        witness: "spec/fixtures/typing_state_witnesses/def_node_resolver_run.rb"
+      )
+      private_constant :RUN_MEMO
 
       # Installs a fresh per-run resolution memo, restoring the previous one on exit (always, even on a raise).
       # `nodes` caches the resolved node per `(path, node_id)`; `indexes` caches each file's parse index;
       # `nestings` re-attaches each handle's recorded `Module.nesting` to the node this module minted for it
       # ({.rehydrated_nesting}).
-      def self.with_run
-        previous = Thread.current[MEMO_KEY]
-        Thread.current[MEMO_KEY] = { nodes: {}, indexes: {}, nestings: {}.compare_by_identity, refinement_queries: {} }
-        yield
-      ensure
-        Thread.current[MEMO_KEY] = previous
+      def self.with_run(&)
+        memo = { nodes: {}, indexes: {}, nestings: {}.compare_by_identity, refinement_queries: {} }.freeze
+        TypingState.current.with(RUN_MEMO, memo, &)
       end
 
       # Whether a per-run memo scope is in force. The rehydrated `Module.nesting` ({.rehydrated_nesting}) is
@@ -44,7 +57,12 @@ module Rigor
       # per-run memo scope" clause states — and lets a spec assert that no handle-consuming entry point
       # resolves outside it, which is the difference between the peel fallback being a documented edge and
       # being silently reachable from production.
-      def self.run_scope? = !Thread.current[MEMO_KEY].nil?
+      def self.run_scope? = !TypingState.current[RUN_MEMO].nil?
+
+      # Issue #3160 — the nodes this run's memo has minted so far, keyed `[path, node_id]` (nil outside a run scope).
+      # The return memo keys on them, so the runner keeps the table to find an unchanged file's def in the memo once
+      # the run scope has closed.
+      def self.resolved_nodes = TypingState.current[RUN_MEMO]&.fetch(:nodes)
 
       # Resolves `handle` to a `Prism::DefNode` (the same object across the run for a given (path, node_id)), or
       # nil. A non-handle argument is returned unchanged, so callers can pass a table value that is either a live
@@ -52,7 +70,7 @@ module Rigor
       def self.resolve(handle)
         return handle unless handle.is_a?(DefHandle)
 
-        memo = Thread.current[MEMO_KEY]
+        memo = TypingState.current[RUN_MEMO]
         return locate(handle, {}) if memo.nil?
 
         key = [handle.path, handle.node_id].freeze
@@ -96,7 +114,7 @@ module Rigor
       # def_node_resolver_spec.rb` pins that, so a new one added outside a run scope fails there rather than
       # silently reverting to the peel.
       def self.rehydrated_nesting(node)
-        memo = Thread.current[MEMO_KEY]
+        memo = TypingState.current[RUN_MEMO]
         memo && memo[:nestings][node]
       end
 
@@ -104,7 +122,7 @@ module Rigor
       # is recorded like any other: it is the bundle saying the def is written at the top level, and dropping
       # it would leave the warm path peeling the caller's namespace where a cold run resolves at the top
       # level. Only `nil` — a bundle that recorded nothing for the def — is skipped, and
-      # `Cache::IncrementalSnapshot::SCHEMA` 17 is what keeps a pre-#716 blob (where `nil` MEANT top level)
+      # the `SCHEMA` bump to 17 (`Cache::IncrementalSnapshot`) keeps a pre-#716 blob, where `nil` MEANT top level,
       # from being read as one.
       def self.record_nesting(memo, node, nesting)
         return if node.nil? || nesting.nil?
@@ -117,7 +135,7 @@ module Rigor
       # read: the typed refined arm reads another file's refine body through it. The bodies' `Module.nesting`
       # is recorded as a handle's is, so the re-typed body reads its constants where it is written.
       def self.refinement_query(path)
-        memo = Thread.current[MEMO_KEY]
+        memo = TypingState.current[RUN_MEMO]
         return build_refinement_query(path, nil) if memo.nil?
 
         queries = memo[:refinement_queries]

data/lib/rigor/inference/def_return_typer.rb

@@ -35,7 +35,7 @@ module Rigor
         body = def_node.body
         return nil if body.nil?
 
-        last = body_last_expression(body)
+        last = primary_value_expression(body)
         return nil if last.nil?
 
         inner_scope = scope_index[last] || scope_index[body] || scope_index[def_node]
@@ -46,11 +46,54 @@ module Rigor
 
         lookup_context = keep_lookup_nil ? LookupContext.new(scope_index, truthy_guards(body)) : nil
         last_type = with_lookup_nil(last_type, last, inner_scope, lookup_context) if lookup_context
-        union_with_explicit_returns(body, last_type, scope_index, lookup_context: lookup_context)
+        arm_types = rescue_arm_types(body, inner_scope, scope_index, lookup_context)
+        return nil if arm_types.nil?
+
+        union_with_explicit_returns(body, Type::Combinator.union(last_type, *arm_types), scope_index,
+                                    lookup_context: lookup_context)
       rescue StandardError
         nil
       end
 
+      # Issue #2410 — the value a def body ends on when no exception escapes its primary path. A def-level
+      # `rescue … else … end` body is a `BeginNode` whose else-clause, when present, replaces the body's value (the
+      # ensure-clause's value is discarded, so it never counts).
+      def primary_value_expression(body)
+        return body_last_expression(body) unless body.is_a?(Prism::BeginNode) && body.else_clause
+
+        body_last_expression(body.else_clause.statements)
+      end
+
+      # Issue #2410 — the value of each arm of a def-level rescue chain, which the method returns when that arm
+      # completes. An empty arm returns `nil`; an arm ending in `raise`, `retry` or `return` types as bottom and so
+      # adds nothing here (a `return`'s value is collected with the other explicit returns). Nil when an arm cannot
+      # be typed: the body's value alone would be a narrower, wrong contract.
+      def rescue_arm_types(body, inner_scope, scope_index, lookup_context)
+        return [] unless body.is_a?(Prism::BeginNode)
+
+        types = []
+        arm = body.rescue_clause
+        while arm
+          type = rescue_arm_type(arm, inner_scope, scope_index, lookup_context)
+          return nil if type.nil?
+
+          types << type
+          arm = arm.subsequent
+        end
+        types
+      end
+
+      def rescue_arm_type(arm, inner_scope, scope_index, lookup_context)
+        value = body_last_expression(arm.statements)
+        return Type::Combinator.constant_of(nil) if value.nil?
+
+        scope = scope_index[value] || scope_index[arm] || inner_scope
+        type = safe_type_of(scope, value)
+        return nil if type.nil?
+
+        lookup_context ? with_lookup_nil(type, value, scope, lookup_context) : type
+      end
+
       # What {#optimistic_value?} reads beside a node's scope: the engine's per-node scopes, and for each lookup
       # under a guard the source of the guarding predicates ({#truthy_guards}).
       LookupContext = Data.define(:scope_index, :guards)
@@ -83,7 +126,7 @@ module Rigor
       end
 
       def optimistic_call?(node, scope, context)
-        if scope.optimistic_origins[node]
+        if scope.optimistic_origin(node)
           return false if guarded_lookup?(node, context) || non_empty_end?(node, scope)
 
           return true
@@ -227,8 +270,7 @@ module Rigor
 
         scope = scope_index[return_node] || scope_index[args.first]
         return if scope.nil?
-        # `return a, b` packs into a Tuple at runtime; the MVP only handles the single-value form. Multi-arg
-        # returns contribute no type to keep the implementation focused.
+        # `return a, b` packs into a Tuple at runtime; only the single-value form is typed.
         return unless args.size == 1
 
         type = safe_type_of(scope, args.first)

data/lib/rigor/inference/definer_resolution.rb

@@ -25,8 +25,10 @@ module Rigor
     # truth-tested: {UNKNOWN} and {ABSENT} are both truthy, so any other use folds a decline into a firing arm.
     # `spec/rigor/inference/definer_resolution_case_in_spec.rb` fails on a call site of any other shape.
     #
-    # It migrates one question at a time: `SourceArity` (C1b) and the relationship lints (C1c) read the instance
-    # side; no production reader reads the singleton side yet (C2-a landed it for C2's typing sites).
+    # It migrates one question at a time: `SourceArity` (C1b, C2-c) asks for the receiver's own side, instance or
+    # singleton; the override lints (C1c) and the C2 typing sites (`ExpressionTyper#resolve_typing_def_with_owner`,
+    # `StatementEvaluator#own_definer_node`) read the instance side; `RefinedDispatch::OwnMethod.certain_owner?` and
+    # `CheckRules#reached_definer_visibility` pass the side they hold.
     module DefinerResolution
       Known = Data.define(:answer, :owner)
       UnknownResult = Data.define
@@ -80,11 +82,16 @@ module Rigor
       # the entry's answer, as `[owner_name, value]` (the owner is part of the answer so that two worlds naming
       # different parents disagree). It is the override lints' parent read: the nearest project ancestor after the
       # class whose block answers.
+      #
+      # Issue #3156 — a class or module the project declares but whose Ruby body records no method, superclass or
+      # include (`module PMod; end`, `class AMid` / `end`) is an external entry on the chain, which only its RBS
+      # declaration speaks for. The override block answers from RBS, so such an entry is asked too, under the
+      # project name it resolves to (`ResolutionChain::Entry#declared_name`); an undeclared external is not.
       def override_answer(scope)
         lambda do |chain, from|
-          first_hit(chain, scope, from) do |entry|
-            value = yield(entry.name)
-            [entry.name, value] unless value.nil?
+          first_hit(chain, scope, from, askable_external: true) do |name|
+            value = yield(name)
+            [name, value] unless value.nil?
           end
         end
       end
@@ -329,17 +336,20 @@ module Rigor
         kind == :singleton ? [:singleton, method_name.to_sym] : method_name.to_sym
       end
 
-      def first_hit(chain, scope, from)
+      # The first entry at or after `from` whose block answers. The default answer functions are handed the project
+      # entry; the override one (`askable_external:`) is handed a name, and also asks an external entry the project
+      # declares.
+      def first_hit(chain, scope, from, askable_external: false)
         index = from - 1
         found = nil
         chain.search(scope, from) do |entry|
           index += 1
-          next if entry.external?
+          next unless (name = entry.external? ? askable_external && entry.declared_name(scope) : entry.name)
 
-          answer = yield(entry)
+          answer = yield(askable_external ? name : entry)
           next if answer.nil?
 
-          found = Hit.new(answer, entry.name, index, entry.side)
+          found = Hit.new(answer, name, index, entry.side)
         end
         found
       end

data/lib/rigor/inference/definers_index.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require_relative "../typing_state"
+require_relative "../memo_audit"
+
+module Rigor
+  module Inference
+    # The `method_name (Symbol) → [owner names]` inverted index the override gate reads
+    # (`ExpressionTyper#method_definers_index`), over one instance or singleton def table.
+    #
+    # Issue #2300 — a file's def table is its own `def`s merged over the cross-file seed
+    # (`ScopeIndexer#merge_def_node_tables`, `#merge_singleton_def_nodes`, then the #526 extend fold), a new Hash per
+    # file. Inverting it whole scanned every project `def` once per analysed file. {.record_layers} remembers the
+    # seed a final merged table was built over, and {.for} then inverts the seed ONCE per seed table and, per file,
+    # only the owners whose inner table is not the seed's own object ({Layered}).
+    #
+    # The two answers hold the same owners: an owner the merge left alone shares the seed's inner table, so its
+    # names are the seed's, and every other owner is read from the merged table itself. That holds only while the
+    # seed cannot change under the cached index, so a seed whose tables are not all frozen, or a merged table
+    # missing one of the seed's owners, is inverted whole, as is a table {.record_layers} was not told about. Only
+    # the order of a name's owners can differ, and the gate asks `any?` of the list.
+    module DefinersIndex
+      # These thread slots are bounded, like `ExpressionTyper#method_definers_index`'s two ways. Each is a fixed
+      # number of entries, replaced rather than accumulated: two `[merged, seed]` pairs (the last file's two def
+      # tables) and two seed indexes. The run that filled them releases them when it ends (run-scoped, #2399),
+      # so a finished run keeps none of its seed tables or their indexes alive.
+      #
+      # ADR-129 WD1 — all three are run-scoped Memos keyed on table identity. The layers say only which seed a merged
+      # table was built over, a shortcut: {.for} answers the same index owners, `Layered` or whole, so the answer is
+      # a function of the table alone. Each seed index is a pure function of its seed table.
+      #
+      # Each hit goes through `MemoAudit.check`: a `Layered` answer is compared, in {.canonical} form, with the table
+      # inverted whole, and a seed index with the seed inverted again. While an audit recomputation runs
+      # ({MemoAudit.suspended?}) the three are neither read nor written, so it inverts every table whole.
+      LAYERS = TypingState.memo(
+        :definers_index_layers,
+        run_scoped: true, audit: "definers index layers",
+        reason: "the seed each of the last two merged tables was built over; keyed on table identity"
+      )
+      SEED_INDEX = TypingState.memo(
+        :definers_index_seed,
+        run_scoped: true, audit: "definers index seed",
+        reason: "pure function of the seed table it keys on"
+      )
+      SEED_INDEX_ALT = TypingState.memo(
+        :definers_index_seed_alt,
+        run_scoped: true, audit: "definers index seed alt",
+        reason: "pure function of the seed table it keys on"
+      )
+      private_constant :LAYERS, :SEED_INDEX, :SEED_INDEX_ALT
+
+      # A name's owners: the seed's, less the owners the file replaced, plus the replaced owners' own.
+      class Layered
+        def initialize(seed_index, replaced, replaced_index)
+          @seed_index = seed_index
+          @replaced = replaced
+          @replaced_index = replaced_index
+          @answers = {}
+        end
+
+        def [](method_name)
+          return @answers[method_name] if @answers.key?(method_name)
+
+          from_seed = @seed_index[method_name]
+          from_seed = from_seed.reject { |owner| @replaced.key?(owner) } if from_seed && !@replaced.empty?
+          from_file = @replaced_index[method_name]
+          owners = from_file.nil? ? from_seed : (from_seed || []) + from_file
+          @answers[method_name] = owners.nil? || owners.empty? ? nil : owners
+        end
+
+        # Every name some owner may define, for {DefinersIndex.canonical}.
+        def names = @seed_index.keys | @replaced_index.keys
+      end
+
+      module_function
+
+      # Records that the final `merged` table was built over `seed`. The last two are kept (a file merges an
+      # instance and a singleton table), replaced rather than accumulated.
+      def record_layers(merged, seed)
+        return if MemoAudit.enabled? && MemoAudit.suspended?
+
+        state = TypingState.current
+        previous = state[LAYERS]
+        state[LAYERS] = [[merged, seed], previous&.first].compact
+      end
+
+      # The definers index over `table`.
+      def for(table)
+        return build(table) if MemoAudit.suspended?
+
+        seed = TypingState.current[LAYERS]&.find { |entry| entry[0].equal?(table) }&.last
+        return build(table) if seed.nil? || !deeply_frozen?(seed)
+
+        replaced = {}
+        kept = 0
+        table.each do |owner, methods|
+          if methods.equal?(seed[owner])
+            kept += 1
+          else
+            replaced[owner] = methods
+          end
+        end
+        return build(table) unless kept + replaced.count { |owner, _| seed.key?(owner) } == seed.size
+
+        audit_layered(Layered.new(seed_index(seed), replaced, build(replaced)), table)
+      end
+
+      # `index`, after checking it against `table` inverted whole when the audit is on.
+      def audit_layered(index, table)
+        return index unless MemoAudit.enabled?
+
+        MemoAudit.check("definers index layers", canonical(index), table.size) { canonical(build(table)) }
+        index
+      end
+
+      # `index` as a plain `name → sorted owners` Hash, so a `Layered` index and a whole one compare equal when they
+      # hold the same owners. Audit-only: it reads every name.
+      def canonical(index)
+        names = index.is_a?(Layered) ? index.names : index.keys
+        names.each_with_object({}) do |name, out|
+          owners = index[name]
+          out[name] = owners.sort if owners
+        end
+      end
+
+      def deeply_frozen?(seed)
+        seed.frozen? && seed.each_value.all?(&:frozen?)
+      end
+
+      # The seed's index, built once per seed table. Two ways, an instance and a singleton seed table.
+      def seed_index(seed)
+        state = TypingState.current
+        slot = state[SEED_INDEX]
+        if slot && slot[0].equal?(seed)
+          return MemoAudit.check("definers index seed", slot[1], seed.size) do
+            build(seed)
+          end
+        end
+
+        slot = state[SEED_INDEX_ALT]
+        if slot && slot[0].equal?(seed)
+          return MemoAudit.check("definers index seed alt", slot[1], seed.size) { build(seed) }
+        end
+
+        index = MemoAudit.key_audit("definers index seed") { build(seed) }
+        state[SEED_INDEX_ALT] = state[SEED_INDEX]
+        state[SEED_INDEX] = [seed, index]
+        index
+      end
+
+      def build(table)
+        index = {}
+        table.each do |class_name, methods|
+          next if class_name == ScopeIndexer::TOP_LEVEL_DEF_KEY
+
+          methods.each_key { |method_name| (index[method_name] ||= []) << class_name }
+        end
+        index
+      end
+    end
+  end
+end