rigortype 0.4.7 → 0.4.8

data/lib/rigor/inference/remover_holder_scan.rb

@@ -2,9 +2,11 @@
 
 require "prism"
 
-require_relative "../run_scoped_slots"
+require_relative "../typing_state"
+require_relative "../source/node_children"
 require_relative "closure_escape_analyzer"
 require_relative "construction_escape"
+require_relative "../memo_audit"
 
 module Rigor
   module Inference
@@ -55,11 +57,17 @@ module Rigor
         Prism::LocalVariableAndWriteNode
       ].freeze
       ALL = :all
-      # A run-scoped slot ({RunScopedSlots}): emptied when a run ends, so no verdict outlives the body it read.
-      UNSAFE_CACHE_KEY = RunScopedSlots.register(:__rigor_remover_narrowing_unsafe)
+      NO_ARGUMENTS = [].freeze
+      # ADR-129 WD1 — a run-scoped Memo, emptied when a run ends so no verdict outlives the body it read: keyed by
+      # body node, and the unsafe names are a pure function of the body and its frame's parameters.
+      UNSAFE_CACHE = TypingState.memo(
+        :remover_narrowing_unsafe,
+        run_scoped: true, audit: "remover narrowing unsafe",
+        reason: "keyed by the body node; the unsafe local names are a pure function of the body"
+      )
       private_constant :REFLECTIVE_CALLS, :SELF_CONVERSIONS, :PURE_READERS, :IMMEDIATE_BLOCK_CALLS, :FRAME_CALLS,
                        :ANY_RECEIVER_FRAME_CALLS, :NON_WRITER_OPERATORS, :CORE_COLLECTIONS,
-                       :LOCAL_REFERENCES, :LOCAL_WRITES, :ALL, :UNSAFE_CACHE_KEY
+                       :LOCAL_REFERENCES, :LOCAL_WRITES, :ALL, :NO_ARGUMENTS, :UNSAFE_CACHE
 
       module_function
 
@@ -70,30 +78,54 @@ module Rigor
         body = frame&.body
         return true if body.nil?
 
-        table = (Thread.current[UNSAFE_CACHE_KEY] ||= ObjectSpace::WeakKeyMap.new)
-        names = table[body] ||= unsafe_names(body, frame.parameters)
+        names = memoised_unsafe_names(body, frame.parameters)
         names.equal?(ALL) || names.include?(name.to_sym)
       end
 
-      def unsafe_names(body, parameters = nil)
-        names = Set.new
+      # {.unsafe_names} of `body`, memoised for the run.
+      def memoised_unsafe_names(body, parameters)
+        return unsafe_names(body, parameters) if MemoAudit.enabled? && MemoAudit.suspended?
+
+        table = TypingState.current.weak_key_map(UNSAFE_CACHE)
+        stored = table[body]
+        if stored.nil?
+          return table[body] = MemoAudit.key_audit("remover narrowing unsafe") { unsafe_names(body, parameters) }
+        end
+
+        MemoAudit.check("remover narrowing unsafe", stored, body) { unsafe_names(body, parameters) }
+      end
+
+      # `names` collects the locals; a collector that answers `site=` ({AliasMutationFloor}) is told, before each name
+      # it is given, the node that hands the local on, or nil when no single node does (a capture by a closure that may
+      # run later, a zero-argument `super`), reads value positions itself when it answers `value_held` ({.precise?}),
+      # and is told when the walk enters (`enter(node, parent)`) and leaves
+      # (`leave(node)`) each node. One that answers `keeps_arguments?` says which calls' plain arguments it counts as
+      # held.
+      def unsafe_names(body, parameters = nil, names = Set.new)
+        sited = names.respond_to?(:site=)
         catch(ALL) do
-          collect_unsafe(body, false, names)
+          collect_unsafe(body, false, names, sited:)
+          names.site = nil if sited
           parameter_names(parameters, names) if forwards_parameters?(body)
           return names.freeze
         end
         ALL
       end
 
-      def collect_unsafe(node, in_closure, names)
+      def collect_unsafe(node, in_closure, names, sited: false, parent: nil)
         in_closure ||= node.is_a?(Prism::LambdaNode)
+        if sited
+          names.enter(node, parent)
+          names.site = in_closure ? nil : node
+        end
         names << node.name if in_closure && LOCAL_REFERENCES.any? { |k| node.is_a?(k) }
         record_node(node, names)
 
-        node.compact_child_nodes.each do |child|
+        node.rigor_each_child do |child|
           child_in_closure = in_closure || (child.is_a?(Prism::BlockNode) && deferred_block?(node))
-          collect_unsafe(child, child_in_closure, names)
+          collect_unsafe(child, child_in_closure, names, sited:, parent: node)
         end
+        names.leave(node) if sited
       end
 
       def record_node(node, names) # rubocop:disable Metrics/CyclomaticComplexity
@@ -101,7 +133,9 @@ module Rigor
         when Prism::CallNode then record_call(node, names)
         when Prism::YieldNode, Prism::SuperNode then node.arguments&.arguments&.each { |a| record_held(a, names) }
         when Prism::ArrayNode then node.elements.each { |element| record_held(element, names) }
-        when Prism::AssocNode then [node.key, node.value].each { |part| record_held(part, names) }
+        when Prism::AssocNode
+          record_held(node.key, names)
+          record_held(node.value, names)
         when Prism::SplatNode, Prism::BlockArgumentNode then record_held(node.expression, names)
         when Prism::CaseMatchNode then record_pattern(node.predicate, node.conditions, names)
         when Prism::MatchRequiredNode, Prism::MatchPredicateNode then record_pattern(node.value, [node.pattern], names)
@@ -115,27 +149,42 @@ module Rigor
 
         receiver = unparenthesised(node.receiver)
         names << receiver.name if receiver.is_a?(Prism::LocalVariableReadNode) && REFLECTIVE_CALLS.include?(node.name)
-        arguments = node.arguments&.arguments || []
+        arguments = node.arguments&.arguments || NO_ARGUMENTS
         if writer_call?(node) && !arguments.empty?
-          *keys, value = arguments
-          keys.each { |key| record_held(key, names) }
-          every_read(value, names)
-        else
+          record_writer_call(arguments, names)
+        elsif keeps_arguments?(node, names)
           arguments.each { |argument| record_held(argument, names) }
         end
       end
 
+      def record_writer_call(arguments, names)
+        *keys, value = arguments
+        keys.each { |key| record_held(key, names) }
+        precise?(names) ? names.value_held(value) : every_read(value, names)
+      end
+
+      def keeps_arguments?(node, names) = !names.respond_to?(:keeps_arguments?) || names.keeps_arguments?(node)
+
+      # A collector that reads a value position itself ({AliasMutationFloor}): `value_held(node)` for a value handed
+      # to another holder (an element, an argument, an index or attribute write's value), `value_written(node)` for a
+      # write node, and `value_bound(value, targets)` for a multiple assignment or a pattern. The default collector
+      # reads every local inside the value instead.
+      def precise?(names) = names.respond_to?(:value_held)
+
       # A zero-argument `super` passes every parameter of the method on, implicitly. (A `...` forward passes only the
       # anonymous parameters, which name no local.)
       def forwards_parameters?(node)
-        node.is_a?(Prism::ForwardingSuperNode) || node.compact_child_nodes.any? { |child| forwards_parameters?(child) }
+        return true if node.is_a?(Prism::ForwardingSuperNode)
+
+        node.rigor_each_child { |child| return true if forwards_parameters?(child) }
+        false
       end
 
       def parameter_names(node, names)
         return if node.nil?
 
         names << node.name if node.class.name.end_with?("ParameterNode") && node.respond_to?(:name) && node.name
-        node.compact_child_nodes.each { |child| parameter_names(child, names) }
+        node.rigor_each_child { |child| parameter_names(child, names) }
       end
 
       def frame_call?(node)
@@ -156,6 +205,7 @@ module Rigor
       # A write's value hands on every local read anywhere inside it, and the local it binds holds what it read.
       def record_write(node, names)
         return unless node.class.name.end_with?("WriteNode") && node.respond_to?(:value)
+        return names.value_written(node) if precise?(names)
         return unless every_read(node.value, names)
 
         names << node.name if LOCAL_WRITES.any? { |k| node.is_a?(k) } && !fresh_value?(node.value)
@@ -178,12 +228,14 @@ module Rigor
       end
 
       def record_multi_write(node, names)
+        return names.value_bound(node.value, [*node.lefts, node.rest, *node.rights]) if precise?(names)
         return unless every_read(node.value, names)
 
         local_targets([*node.lefts, node.rest, *node.rights], names)
       end
 
       def record_pattern(subject, patterns, names)
+        return names.value_bound(subject, patterns) if precise?(names)
         return unless every_read(subject, names)
 
         local_targets(patterns, names)
@@ -195,7 +247,8 @@ module Rigor
 
         found = node.is_a?(Prism::LocalVariableReadNode)
         names << node.name if found
-        node.compact_child_nodes.reduce(found) { |acc, child| every_read(child, names) || acc }
+        node.rigor_each_child { |child| found = true if every_read(child, names) }
+        found
       end
 
       def local_targets(nodes, names)
@@ -208,10 +261,11 @@ module Rigor
       # A held position: every local read inside it but the receiver of a {PURE_READERS} call.
       def record_held(node, names)
         return if node.nil?
+        return names.value_held(node) if precise?(names)
         return if pure_read?(node)
 
         names << node.name if node.is_a?(Prism::LocalVariableReadNode)
-        node.compact_child_nodes.each { |child| record_held(child, names) }
+        node.rigor_each_child { |child| record_held(child, names) }
       end
 
       # A {PURE_READERS} call on a local hands the local on to nothing. Its own arguments are held positions of the

data/lib/rigor/inference/scope_indexer/class_cvars_collector.rb

@@ -6,8 +6,9 @@ module Rigor
   module Inference
     module ScopeIndexer
       # The `class_cvars` discovery table (slice 7 phase 6) as a {DeclarationWalk} collector: every
-      # `@@x = …` a `def` body writes, typed under the census scope and unioned per class. Ruby cvars are
-      # shared by the instance and singleton facets, so every `def` counts, `def self.x` included.
+      # `@@x = …` a `def` body writes, typed under the census scope and unioned per class, joined by what a
+      # `class` / `module` body writes to the same cvar. Ruby cvars are shared by the instance and singleton
+      # facets, so every `def` counts, `def self.x` included.
       class ClassCvarsCollector
         include DeclarationWalk::Collector
 
@@ -15,6 +16,14 @@ module Rigor
           @table = {}
         end
 
+        # Issue #3204 — a `class` / `module` body's own writes, outside its `def`s, under the body's context;
+        # each only joins an entry a `def` body's write creates. An unnameable cref (a header below
+        # `class << expr`) leaves the prefix empty, and the gather skips it.
+        def on_declaration(node, _context, body)
+          ScopeIndexer.collect_body_cvar_writes(node.body, body.prefix, body.scope, @table)
+          DeclarationWalk::DESCEND
+        end
+
         # `@@x` in a `def` resolves through the LEXICAL cref: `Module.nesting` is the same inside a meta-new or
         # eval block, so the context's `prefix` keys the write and its rebound `self` never does —
         # `K = Class.new { def m = @@x }` inside `class C` writes `C::@@x`. The walk goes no further in: the
@@ -25,10 +34,8 @@ module Rigor
           DeclarationWalk::DECLINE
         end
 
-        # The table as the discovery index holds it: each class's entry frozen, then the whole.
-        def table
-          @table.transform_values(&:freeze).freeze
-        end
+        # The table as the discovery index holds it ({ScopeIndexer#finished_cvar_census}).
+        def table = ScopeIndexer.finished_cvar_census(@table)
       end
     end
   end

data/lib/rigor/inference/scope_indexer/declared_param_writes.rb

@@ -4,6 +4,7 @@ require "prism"
 
 require_relative "../../reflection"
 require_relative "../method_parameter_binder"
+require_relative "../../typing_state"
 require_relative "../global_write_census"
 require_relative "unseen_ivar_writers"
 require_relative "derived_param_value"
@@ -58,27 +59,27 @@ module Rigor
                                module_exec].to_set.freeze
         private_constant :OPAQUE_EVAL_CALLS
 
-        WRITER_SCOPE_KEY = :__rigor_declared_param_writer_scope__
-        private_constant :WRITER_SCOPE_KEY
+        # ADR-129 WD1 — a Frame: the scope is installed around a census and restored on the way out.
+        WRITER_SCOPE = TypingState.frame(
+          :declared_param_writer_scope,
+          reason: "the scope whose project tables the writer gates read, installed per census",
+          # G1′: the census types its defaults under the Frame, but only the writer gates, outside `type_of`, read it.
+          typing_never_reads: true
+        )
+        private_constant :WRITER_SCOPE
 
         module_function
 
         # Runs the block with `scope` as the one whose project tables the unseen-writer and single-file gates read, in
         # place of the census's own scope. `rigor sig-gen` indexes each file over the project tables less the member
         # layouts; this scope carries all of them, so another file's writer, ancestor or reopening is seen.
-        def with_writer_scope(scope)
+        def with_writer_scope(scope, &)
           return yield if scope.nil?
 
-          previous = Thread.current[WRITER_SCOPE_KEY]
-          Thread.current[WRITER_SCOPE_KEY] = scope
-          begin
-            yield
-          ensure
-            Thread.current[WRITER_SCOPE_KEY] = previous
-          end
+          TypingState.current.with(WRITER_SCOPE, scope, &)
         end
 
-        def writer_scope(scope) = Thread.current[WRITER_SCOPE_KEY] || scope
+        def writer_scope(scope) = TypingState.current[WRITER_SCOPE] || scope
 
         # `{InstanceVariableWriteNode => Rigor::Type}` for `def_node`'s creditable writes, or {EMPTY}. The caller
         # passes only an instance `def`: a singleton body's `@x` is the class object's.

data/lib/rigor/inference/scope_indexer/ivar_contributions.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
 require_relative "../../analysis/dependency_recorder"
-require_relative "../../run_scoped_slots"
+require_relative "../../typing_state"
+require_relative "../../memo_audit"
 require_relative "../../type"
-require_relative "../refined_dispatch/own_method"
+require_relative "../census_foreign_block"
+require_relative "../ivar_writer_census"
 
 module Rigor
   module Inference
@@ -13,10 +15,10 @@ module Rigor
       #
       # - the writes another file's reopening of `K` makes;
       # - the writes of every project module and superclass on `K`'s instance resolution chain (`include`,
-      #   `prepend`, transitively, and `<`), from this file's own census of that ancestor where it declares one
-      #   (`writes`, taken before the read-before-write `nil` is added, so an ancestor's `initialize` exempts nothing
-      #   and its read-before-write adds nothing, and only for an ivar an instance body of the ancestor writes in this
-      #   file) and from every other file's entries for it.
+      #   `prepend`, transitively, and `<`; for a module `K`, the modules it includes or prepends), from this file's
+      #   own census of that ancestor where it declares one (`writes`, taken before the read-before-write `nil` is
+      #   added, so an ancestor's `initialize` exempts nothing and its read-before-write adds nothing, and only for an
+      #   ivar an instance body of the ancestor writes in this file) and from every other file's entries for it.
       #
       # Another file's write comes from its `[:own_write_type, owner, ivar, value, path]` census entry
       # ({IvarWriterCensus}): a literal joins as its `Constant`, anything else as `Dynamic[top]`. An ivar the census
@@ -29,9 +31,23 @@ module Rigor
       # incremental session fires when a file's entries for the pair appear, vanish or change value; and the chain
       # files its class edges ({Scope::ResolutionChain#record}), so an `include` added or removed re-checks the reader.
       module IvarContributions
-        TABLE_KEY = RunScopedSlots.register(:__rigor_ivar_contributions_table__)
+        # ADR-129 WD1 — a run-scoped Memo: the table is a pure function of the census it is keyed on by identity.
+        TABLE = TypingState.memo(
+          :ivar_contributions_table,
+          run_scoped: true, audit: "ivar contributions table",
+          reason: "the contribution table of one census; keyed on the census's identity"
+        )
         EMPTY = {}.freeze
-        private_constant :TABLE_KEY, :EMPTY
+        NONE = [].freeze
+        BINDINGS = :bindings
+        CANDIDATE_KEYS = :candidate_keys
+        ANCESTOR_ROOTS = CensusForeignBlock::ANCESTOR_ROOTS.to_a.freeze
+        # The one implicit root a class whose superclass chain stops at `BasicObject` keeps.
+        BASIC_ROOTS = %w[BasicObject].freeze
+        SEPARATOR = CensusForeignBlock::CANDIDATE_SEPARATOR
+        OBJECT_MARK = CensusForeignBlock::OBJECT_MARK
+        private_constant :TABLE, :EMPTY, :NONE, :BINDINGS, :CANDIDATE_KEYS, :ANCESTOR_ROOTS, :BASIC_ROOTS, :SEPARATOR,
+                         :OBJECT_MARK
 
         module_function
 
@@ -42,34 +58,148 @@ module Rigor
           path = canonical(path)
 
           table = table(scope.discovered_global_write_census)
+          resolution = nil
           accumulator.each do |class_name, entries|
             next unless class_name.is_a?(String) && !entries.empty?
 
-            owners = chain_owners(scope, class_name)
+            resolution ||= memoized_resolution(scope, table)
+            owners = chain_owners(scope, class_name, resolution)
+            any = any_ivar_types(owners, table)
             entries.each_key do |ivar|
               joined = contributed(owners, class_name, ivar, table, writes, path)
+              joined = joined ? Type::Combinator.union(joined, any) : any if any
               entries[ivar] = Type::Combinator.union(entries[ivar], joined) if joined
             end
           end
         end
 
         # `K` and the project classes and modules on its instance chain, in chain order, with their class edges filed.
-        # A module's own census takes no chain: its ancestors' writes land on whatever includes it.
-        def chain_owners(scope, class_name)
-          return [class_name] if RefinedDispatch::OwnMethod.module_name?(scope, class_name)
+        # A module's chain holds the modules it includes or prepends (#2487): each is on the chain of every class that
+        # includes the module, so its writes land on every object a read in the module's own methods sees. `extend`
+        # is no instance chain entry, for a module as for a class.
+        #
+        # Issue #2983 — the chain is read under the `:constants` flavor, so a project class or module with no method of
+        # its own (`class Anc; end`, whose writer a `class_eval` installs) is an owner too. {ANCESTOR_ROOTS}
+        # (`Object`, `BasicObject`, `Kernel`) follow, as every instance has them, except that a class whose superclass
+        # chain stops at `BasicObject` keeps `BasicObject` alone; then each owner's alias and instance constants
+        # (`[:binds_class, …]` entries), and every candidate key that resolves to an owner ({.resolution}), under which
+        # a `class_eval` rooted at that constant files its code.
+        def chain_owners(scope, class_name, resolution)
+          ancestors, reaches_object = ancestor_names(scope, class_name)
+          names = [class_name, *ancestors, *(reaches_object ? ANCESTOR_ROOTS : BASIC_ROOTS)].uniq
+          aliases, bound = resolution
+          bound_names = names.flat_map do |name|
+            segment = name.split("::").last
+            Analysis::DependencyRecorder.read_name(:binds_class, segment) if Analysis::DependencyRecorder.active?
+            bound[name] || NONE
+          end
+          (names + bound_names).uniq.flat_map { |owner| [owner, *(aliases[owner] || NONE)] }.uniq
+        end
 
-          chain = Scope::ResolutionChain.for(scope, class_name, :instance, :methods)
+        # The project ancestors on `class_name`'s instance chain, and whether the chain reaches `Object`: false when a
+        # superclass edge names `BasicObject`, which has neither `Object` nor `Kernel` among its ancestors.
+        def ancestor_names(scope, class_name)
+          chain = Scope::ResolutionChain.for(scope, class_name, :instance, :constants)
           # A guard: the class body's own `include` / `<` resolution already files these edges; kept so the read
           # states its own dependency.
           chain.record(scope) if Analysis::DependencyRecorder.active?
-          ancestors = chain.entries.filter_map do |entry|
+          names = chain.entries.filter_map do |entry|
             # An external entry has no name, so `filter_map` drops it. The side check is a guard: an instance chain
             # holds only instance-side entries.
             entry.name if entry.side == :instance && entry.name != class_name
           end
-          [class_name, *ancestors.uniq]
+          [names, chain.entries.none? { |entry| basic_object_edge?(entry) }]
+        rescue StandardError
+          [NONE, true]
+        end
+
+        def basic_object_edge?(entry)
+          entry.external? && entry.superclass_edge &&
+            (entry.raw.to_s.delete_prefix("::") == "BasicObject" || entry.candidates.include?("BasicObject"))
+        end
+
+        # Review round 1 of #3001 — the candidate keys ({CensusForeignBlock.candidate_key}) resolved against the
+        # project: each to its first candidate the project declares as a class or module, or binds as a constant, else
+        # to its last (top-level) spelling, as Ruby's lexical lookup finds the nearest. Answers `[aliases, bound]`:
+        # `{ resolved owner => [candidate key, ...] }` over the census's owners, and `{ resolved class => [bound
+        # constant, ...] }` over its `[:binds_class, …]` entries.
+        #
+        # Review round 2: a candidate a signature declares (`sig/`, a gem's RBS) counts as existing too, so a nearer
+        # `N::Anc` only RBS knows wins over a top-level project `Anc` and credits no project class; and a key carrying
+        # {OBJECT_MARK} joins only when it resolves to an instance binding.
+        def resolution(scope, table)
+          bindings = table[BINDINGS] || NONE
+          constants = bindings.to_set { |_, name, _| name }
+          instances = bindings.filter_map { |_, name, kind| name if kind == :instance }.to_set
+          bound = {}
+          bindings.each { |key, name, _| (bound[resolve(scope, key, constants)] ||= []) << name }
+          aliases = {}
+          (table[CANDIDATE_KEYS] || NONE).each do |key|
+            resolved = resolve(scope, key.delete_prefix(OBJECT_MARK), constants)
+            next if key.start_with?(OBJECT_MARK) && (!instances.include?(resolved) || module?(scope, resolved))
+
+            (aliases[resolved] ||= []) << key
+          end
+          [aliases, bound]
+        end
+
+        def resolve(scope, key, constants)
+          candidates = key.split(SEPARATOR)
+          candidates.find do |name|
+            constants.include?(name) || scope.discovered_classes.key?(name) ||
+              scope.discovered_superclasses.key?(name) || scope.discovered_includes.key?(name) || declared?(scope, name)
+          end || candidates.last
+        end
+
+        # Review round 3 of #3001 — {.resolution} for `table`, computed once per run: it reads only the census and the
+        # project-wide declaration tables and signatures, which no file changes within a run. The value rides the
+        # {TABLE} slot beside the table it was computed from, keyed on the discovery index it read.
+        def memoized_resolution(scope, table)
+          slot = TypingState.current[TABLE]
+          return resolution(scope, table) unless slot && slot[1].equal?(table)
+
+          discovery = scope.discovery
+          cached = slot[2]
+          return cached[1] if cached && cached[0].equal?(discovery)
+
+          value = resolution(scope, table)
+          slot[2] = [discovery, value]
+          value
+        end
+
+        # Review round 3 of #3001 — whether `name` is a class or module the project or a signature declares, whose
+        # `.class` / `.singleton_class` no instance of it runs, whatever a constructor binding says. A guard beside
+        # {CensusForeignBlock.binding_entry}'s meta-class check, which records no such binding to begin with.
+        def module?(scope, name)
+          scope.discovered_classes.key?(name) || scope.discovered_superclasses.key?(name) ||
+            scope.discovered_includes.key?(name) || scope.environment&.rbs_loader&.class_known?(name) || false
         rescue StandardError
-          [class_name]
+          true
+        end
+
+        # Whether a loaded signature declares `name` as a class, module or constant.
+        def declared?(scope, name)
+          loader = scope.environment&.rbs_loader
+          return false if loader.nil?
+
+          loader.class_known?(name) || !loader.constant_declaration(name).nil?
+        rescue StandardError
+          false
+        end
+
+        # Issue #2983 — what the owners' string `class_eval`s contribute to every ivar (`[:own_write_type, owner, :*,
+        # :dynamic]`), from every file, this one included: the per-file census reads no String either.
+        def any_ivar_types(owners, table)
+          types = []
+          owners.each do |owner|
+            # A guard: a String `class_eval` also gives its module the discovery index's dynamic mark, whose edge
+            # re-checks the reader when one comes or goes; kept so the read states its own dependency.
+            if Analysis::DependencyRecorder.active?
+              Analysis::DependencyRecorder.read_name(:own_write_type, "#{owner}##{IvarWriterCensus::ANY_IVAR}")
+            end
+            add_entry_types(types, table.dig(owner, IvarWriterCensus::ANY_IVAR) || EMPTY, nil)
+          end
+          types.empty? ? nil : Type::Combinator.union(*types)
         end
 
         # The union of what the owners contribute to `ivar`, or nil for nothing.
@@ -80,19 +210,25 @@ module Rigor
               Analysis::DependencyRecorder.read_name(:own_write_type, "#{owner}##{ivar}")
             end
             by_path = table.dig(owner, ivar) || EMPTY
-            # This file's census of an ancestor counts only an ivar an instance body of it writes here: the census
-            # also holds a `def self.` write of a module (#1958), which runs on the module object.
+            # This file's census of an ancestor counts only an ivar an instance body of it writes here. `writes` leaves
+            # out an ivar a `def self.` of the ancestor also writes (the census files that write under it, #1958, and it
+            # runs on the module object); this file's census entries for it join instead, as in another file (#2931).
             own = writes.dig(owner, ivar) if owner != class_name && by_path.key?(path)
             types << own if own
-            by_path.each do |value_path, values|
-              next if value_path == path
-
-              values.each { |value| types << value_type(value) }
-            end
+            add_entry_types(types, by_path, own || owner == class_name ? path : nil)
           end
           types.empty? ? nil : Type::Combinator.union(*types)
         end
 
+        # Each census entry's value type, except those of `skipped_path` (the file whose census already holds them).
+        def add_entry_types(types, by_path, skipped_path)
+          by_path.each do |value_path, values|
+            next if value_path == skipped_path
+
+            values.each { |value| types << value_type(value) }
+          end
+        end
+
         # A String literal joins as `String`, not its `Constant`: a write elsewhere cannot see an in-place mutation of
         # the String (`@s << "abc"`) in this file, in another or in an ancestor, so the value would be pinned too
         # narrowly. Every other literal kind is immutable and joins as its `Constant`.
@@ -114,21 +250,45 @@ module Rigor
         # `{ owner => { ivar => { path => [value, ...] } } }` over `census`'s path-tagged `:own_write_type` entries,
         # built once per census and kept in one run-scoped slot keyed by its identity.
         def table(census)
-          slot = Thread.current[TABLE_KEY]
-          return slot[1] if slot && slot[0].equal?(census)
+          return build_table(census) if MemoAudit.enabled? && MemoAudit.suspended?
+
+          state = TypingState.current
+          slot = state[TABLE]
+          if slot && slot[0].equal?(census)
+            return MemoAudit.check("ivar contributions table", slot[1], census.size) { build_table(census) }
+          end
 
+          table = MemoAudit.key_audit("ivar contributions table") { build_table(census) }
+          state[TABLE] = [census, table]
+          table
+        end
+
+        # Issue #2983 — `table[BINDINGS]` lists `[class candidate key, constant name, kind]` over the census's
+        # `[:binds_class, …]` entries, and `table[CANDIDATE_KEYS]` the owners that are candidate keys; no class is named
+        # by a Symbol.
+        def build_table(census)
           table = {}
           canonical_paths = {}
           census.each do |entry|
+            next (table[BINDINGS] ||= []) << entry.drop(1) if entry[0] == :binds_class
             next unless entry.size == 5 && entry[0] == :own_write_type
 
-            by_path = ((table[entry[1]] ||= {})[entry[2]] ||= {})
+            by_path = (owner_slot(table, entry[1])[entry[2]] ||= {})
             (by_path[canonical_paths[entry[4]] ||= canonical(entry[4])] ||= []) << entry[3]
           end
-          Thread.current[TABLE_KEY] = [census, table]
           table
         end
-        private_class_method :chain_owners, :contributed, :value_type, :canonical, :table
+
+        def owner_slot(table, owner)
+          table[owner] ||= begin
+            (table[CANDIDATE_KEYS] ||= []) << owner if owner.include?(SEPARATOR) || owner.start_with?(OBJECT_MARK)
+            {}
+          end
+        end
+
+        private_class_method :chain_owners, :ancestor_names, :basic_object_edge?, :resolution, :resolve, :declared?,
+                             :memoized_resolution, :module?, :any_ivar_types, :contributed, :add_entry_types,
+                             :value_type, :canonical, :table, :build_table, :owner_slot
       end
     end
   end