rigortype 0.4.7 → 0.4.8

data/lib/rigor/inference/rbs_type_translator.rb

@@ -3,6 +3,8 @@
 require "rbs"
 
 require_relative "../type"
+require_relative "../typing_state"
+require_relative "../memo_audit"
 
 module Rigor
   module Inference
@@ -36,8 +38,9 @@ module Rigor
     #   `untyped`. `Type::Intersection` stays out of this path: it is the same-base refinement composite
     #   carrier, and the dispatch tiers do not accept it as a receiver.
     #
-    # Interface types still degrade to `Dynamic[Top]`; they are bound to acceptance and dispatch rules
-    # not yet implemented.
+    # Interface types degrade to `Dynamic[Top]`, except an interface in the `Rigor::Plugin` namespace, which
+    # translates to `Dynamic[Type::Interface]` (ADR-130 WD1/WD4): `untyped` to every rule, and resolvable only by a
+    # call of a member it declares (`RbsDispatch`).
     #
     # The optional `self_type:` and `instance_type:` arguments are the Rigor counterparts of RBS's
     # `self` and `instance` tokens:
@@ -78,7 +81,7 @@ module Rigor
         RBS::Types::Alias => :translate_alias,
         RBS::Types::Intersection => :translate_intersection,
         RBS::Types::Variable => :translate_variable,
-        RBS::Types::Interface => :translate_untyped
+        RBS::Types::Interface => :translate_interface
       }.freeze
       private_constant :TRANSLATORS
 
@@ -106,14 +109,12 @@ module Rigor
       # repeat with one frozen String.
       @relative_names = {}
 
-      # #775 — the translated form of a CLOSED alias expansion, keyed by the expansion. Closed means no
-      # `self`, `instance` or type variable anywhere inside, so the caller's context cannot change the
-      # answer; at expansion depth 0 the budget cannot either. rbs compares types by value, so the memo
-      # is per distinct expansion, not per loader (a re-parsed identical alias hits), and the weak keys
-      # let an entry go with the loader whose memo held the expansion. `Rigor::Type::t` on the self-check
-      # is a 21-member union that was re-translated ~13k times, each time re-normalising the union from
-      # scratch; every repeat now shares one Union.
-      @closed_alias_translations = ObjectSpace::WeakKeyMap.new
+      # ADR-130 WD2 — the erasure baseline's flag, installed by {.with_interface_erasure}.
+      INTERFACE_ERASURE = TypingState.frame(
+        :interface_erasure, reason: "a flag installed around an erasure-baseline run (the parity harness)",
+                            witness: "spec/fixtures/typing_state_witnesses/interface_erasure.rb"
+      )
+      private_constant :INTERFACE_ERASURE
 
       class << self
         # @param self_type — substitute for `Bases::Self`.
@@ -130,6 +131,20 @@ module Rigor
           translate_in(rbs_type, Context.new(self_type, instance_type, type_vars, alias_expander, 0))
         end
 
+        # ADR-130 WD2 — the erasure baseline. Inside the block every RBS interface translates to `untyped`, as it did
+        # before ADR-130, whatever carrier the default engine has; the behavioural parity gate
+        # (`spec/integration/interface_parity_spec.rb`) runs its baseline here, so the baseline never comes from the
+        # default engine. {translate_interface} reads {interface_erasure?}, and {translate_alias} bypasses the loader's
+        # closed-alias memo under it, so a translation made in one mode is never served in the other (ADR-130 WD4). The
+        # switch lives in the calling thread's (and fiber's) `TypingState`, so a run under it is sequential: a pooled
+        # run raises (`PoolCoordinator`).
+        def with_interface_erasure(&)
+          MemoAudit.check_run_level_install(:interface_erasure)
+          TypingState.current.with(INTERFACE_ERASURE, true, &)
+        end
+
+        def interface_erasure? = TypingState.current[INTERFACE_ERASURE] == true
+
         private
 
         def translate_in(rbs_type, context)
@@ -151,6 +166,28 @@ module Rigor
           Type::Combinator.untyped
         end
 
+        # ADR-130 WD4 — the namespace whose interfaces carry the facet: `::Rigor::Plugin::_Scope` and its siblings.
+        PLUGIN_INTERFACE_PATH = %i[Rigor Plugin].freeze
+        private_constant :PLUGIN_INTERFACE_PATH
+
+        # ADR-130 WD1/WD4 — a `Rigor::Plugin` interface is `Dynamic[Interface]`; every other interface, rbs core's
+        # conversion aliases (`int`, `string`, ...) included, is `untyped` as before. Which one is a pure function of
+        # the `TypeName` (its namespace path, read without allocating), so a closed alias translates alike whichever
+        # file or worker reaches it first. Under {with_interface_erasure} every interface is `untyped`.
+        def translate_interface(rbs_type, context)
+          name = rbs_type.name
+          return Type::Combinator.untyped unless name.namespace.path == PLUGIN_INTERFACE_PATH
+          return Type::Combinator.untyped if interface_erasure?
+
+          carrier =
+            if rbs_type.args.empty?
+              Type::Interface.new(relative_name(name))
+            else
+              Type::Interface.new(relative_name(name), rbs_type.args.map { |arg| translate_in(arg, context) })
+            end
+          Type::Combinator.dynamic(carrier)
+        end
+
         def translate_nil(_rbs_type, _context)
           Type::Combinator.constant_of(nil)
         end
@@ -251,18 +288,34 @@ module Rigor
 
           expanded = expander.expand_type_alias(rbs_type)
           return Type::Combinator.untyped if expanded.nil?
+
           # A nested expansion is translated under its parent's budget, and `rigor trace` records every
-          # union merge as it happens, so neither consults the memo.
-          return translate_in(expanded, context.deeper) unless context.alias_depth.zero? && !FlowTracer.active?
+          # union merge as it happens, so neither consults the memo. Nor does the erasure baseline (ADR-130 WD4): the
+          # memo holds the default engine's translations, where a `Rigor::Plugin` interface keeps its facet.
+          memo = closed_translations_of(expander)
+          unless memo && context.alias_depth.zero? && !FlowTracer.active? && !interface_erasure?
+            return translate_in(expanded, context.deeper)
+          end
 
-          cached = @closed_alias_translations[expanded]
+          cached = memo[expanded]
           return cached if cached
 
           translated = translate_in(expanded, context.deeper)
-          @closed_alias_translations[expanded] = translated if closed_type?(expanded)
+          memo[expanded] = translated if closed_type?(expanded)
           translated
         end
 
+        # #775 — the translated form of a CLOSED alias expansion, keyed by the expansion, lives with the expander.
+        # Closed means no `self`, `instance` or type variable anywhere inside, so the caller's context cannot change
+        # the answer; at expansion depth 0 the budget cannot either. But a nested alias inside the expansion is
+        # expanded through the expander (`type a = b | Integer` holds `b`), so the translation reads the expander's
+        # environment: a memo shared by every expander answered a second loader, whose `b` differs, with the first
+        # loader's translation (equal expansions are equal keys). The expander owns its memo, so it dies with it. An
+        # expander that offers none (anything answering only `expand_type_alias`) is translated afresh each time.
+        def closed_translations_of(expander)
+          expander.closed_alias_translations if expander.respond_to?(:closed_alias_translations)
+        end
+
         # True when nothing in `rbs_type`'s tree reads the translation context: no `self`, no `instance`,
         # no type variable. Every rbs type answers `each_type` (the leaves through `EmptyEachType`).
         def closed_type?(rbs_type)

data/lib/rigor/inference/receiver_writer_call.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Inference
+    # Issue #2488 — a writer a class gains from a call on an explicit receiver outside its body: `E.attr_writer :w`,
+    # `E.send(:attr_accessor, :y)`, `E.define_method(:set) { @v = … }` (and `define_method` through `send`). Ruby made
+    # `attr_*` and `define_method` public in 2.5, so each is the receiver class's own declaration, exactly as the same
+    # call in a `E.class_eval { … }` block is. Both ivar censuses read the calls through here: the per-file class-ivar
+    # walk ({ScopeIndexer}) and the cross-file {IvarWriterCensus}. The receiver's name is the caller's to resolve, the
+    # same way each resolves a `class_eval` receiver.
+    module ReceiverWriterCall
+      SEND_CALLS = %i[send __send__ public_send].to_set.freeze
+      WRITER_MACROS = %i[attr_writer attr_accessor].to_set.freeze
+      # The names a direct call spells; a `send` reaches any of them through its literal first argument.
+      CALLS = (WRITER_MACROS | SEND_CALLS | %i[define_method]).freeze
+      NO_ARGUMENTS = [].freeze
+
+      module_function
+
+      # The receiver of `node` when it is one of these calls on a receiver other than `self`, else nil.
+      def receiver(node)
+        return nil unless node.is_a?(Prism::CallNode) && CALLS.include?(node.name)
+
+        recv = node.receiver
+        recv unless recv.nil? || recv.is_a?(Prism::SelfNode)
+      end
+
+      # The ivar names an explicit-receiver `attr_writer` / `attr_accessor` declares (`[:@w]`), or an empty Array.
+      def writer_ivars(node)
+        name, arguments = called(node)
+        return NO_ARGUMENTS unless WRITER_MACROS.include?(name)
+
+        arguments.filter_map do |argument|
+          text = literal_name(argument)
+          :"@#{text}" if text
+        end
+      end
+
+      # The literal block an explicit-receiver `define_method` installs as an instance method, or nil.
+      def define_method_block(node)
+        name, = called(node)
+        block = node.block
+        block if name == :define_method && block.is_a?(Prism::BlockNode)
+      end
+
+      # The method `node` calls and its arguments, seen through a `send` whose first argument spells the name.
+      def called(node)
+        return [nil, NO_ARGUMENTS] if receiver(node).nil?
+
+        arguments = node.arguments&.arguments || NO_ARGUMENTS
+        return [node.name, arguments] unless SEND_CALLS.include?(node.name)
+
+        sent = literal_name(arguments.first)
+        sent ? [sent, arguments.drop(1)] : [nil, NO_ARGUMENTS]
+      end
+
+      def literal_name(argument)
+        return unless argument.is_a?(Prism::SymbolNode) || argument.is_a?(Prism::StringNode)
+
+        text = argument.unescaped
+        text.to_sym if text.valid_encoding?
+      end
+    end
+  end
+end

data/lib/rigor/inference/recursion_rebinding.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "../source/node_walker"
+
+module Rigor
+  module Inference
+    # Which of a def's parameters its own recursion rebinds (issue #3115). The bot-collapse retry of
+    # `ExpressionTyper#fixpoint_user_method_return` types the body once for every call the recursion makes, and a
+    # recursive call binds a parameter to whatever it passes: `tog(n: n - 1, f: !f)` gives `f` a value the
+    # outer call never held. A parameter is KEPT only when every call to the def's own name inside the body
+    # passes it the same parameter read unchanged (`cfg(n - 1, mode)` keeps `mode`), and the body never
+    # assigns it; every other parameter is rebound, and the retry binds it `Dynamic[top]`.
+    #
+    # The test is syntactic and reads only the def. A call counts by its method name alone, whatever its
+    # receiver (`child.depth(n + 1)` re-enters the same recursion guard), so a same-named method of another
+    # class is read as a recursive call too, which only rebinds more. The caller supplies the def's other
+    # names (`alias`), since the def does not carry them. A call to ANOTHER method that recurses back (mutual
+    # recursion) is not followed: its parameters are judged by the def's own calls alone.
+    #
+    # Two shapes the test cannot read rebind more instead. A body that calls a method by a computed name
+    # ({REFLECTIVE_CALLS}) may recurse with any arguments, so every parameter is rebound ({ALL}). A name a
+    # block or lambda in the body declares (a parameter, a block-local, `it`) is rebound, because a read of
+    # it inside that block is the block's variable, not the parameter.
+    module RecursionRebinding
+      module_function
+
+      LOCAL_WRITE_NODES = Set[
+        Prism::LocalVariableWriteNode, Prism::LocalVariableOperatorWriteNode, Prism::LocalVariableOrWriteNode,
+        Prism::LocalVariableAndWriteNode, Prism::LocalVariableTargetNode
+      ].freeze
+      private_constant :LOCAL_WRITE_NODES
+
+      # The calls that reach a method by a name the scan cannot read.
+      REFLECTIVE_CALLS = Set[:send, :__send__, :public_send, :method, :instance_method, :define_method].freeze
+      private_constant :REFLECTIVE_CALLS
+
+      # {.rebound_parameters}'s answer when every parameter is rebound.
+      ALL = :all
+
+      # The names the body's recursive calls, its blocks or its own assignments rebind, as a Set, or {ALL}. The
+      # Set may hold a name that is no parameter (any assigned local); the caller looks up parameters only.
+      # `names` is every name the def answers to: its own and its aliases.
+      def rebound_parameters(def_node, names = Set[def_node.name])
+        params = def_node.parameters
+        return Set.new unless params.is_a?(Prism::ParametersNode)
+
+        rebound = Set.new
+        catch(ALL) { collect(def_node.body, names, params, rebound) } == ALL ? ALL : rebound
+      end
+
+      # Every method name the body calls, for the caller to ask which of them are this def's aliases.
+      def called_names(node, names = Set.new)
+        return names if node.nil?
+
+        names << node.name if node.is_a?(Prism::CallNode)
+        node.rigor_each_child { |child| called_names(child, names) }
+        names
+      end
+
+      def collect(node, names, params, rebound)
+        return if node.nil?
+
+        case node
+        when *LOCAL_WRITE_NODES then rebound << node.name
+        when Prism::BlockNode, Prism::LambdaNode then note_block(node, rebound)
+        when Prism::CallNode
+          throw ALL, ALL if REFLECTIVE_CALLS.include?(node.name)
+
+          note_call(node, params, rebound) if names.include?(node.name)
+        end
+        node.rigor_each_child { |child| collect(child, names, params, rebound) }
+      end
+
+      # A block's `locals` are its parameters, its block-locals and the locals it first assigns; `it` is not
+      # among them.
+      def note_block(block, rebound)
+        rebound.merge(block.locals)
+        rebound << :it if block.parameters.is_a?(Prism::ItParametersNode)
+      end
+
+      def note_call(call, params, rebound)
+        args = call.arguments&.arguments || []
+        keywords = args.last if args.last.is_a?(Prism::KeywordHashNode)
+        positional = keywords ? args[0...-1] : args
+        forwarding = args.any?(Prism::ForwardingArgumentsNode)
+        note_positionals(params, positional, rebound)
+        note_keywords(params, keywords, forwarding, rebound)
+      end
+
+      # Positionals correspond by index up to the first `*splat` (or `...`), which may reach every slot from
+      # its own on. The rest parameter is kept only by `*rest` in its own place as the last positional.
+      def note_positionals(params, positional, rebound)
+        slots = params.requireds + params.optionals
+        cut = positional.index { |arg| arg.is_a?(Prism::SplatNode) || arg.is_a?(Prism::ForwardingArgumentsNode) }
+        cut ||= positional.size
+        slots.each_with_index do |param, index|
+          next if param.is_a?(Prism::MultiTargetNode)
+
+          rebound << param.name unless index < cut && reads?(positional[index], param.name)
+        end
+        note_rest(params.rest, positional[slots.size..] || [], cut >= slots.size, rebound)
+      end
+
+      def note_rest(rest, tail, aligned, rebound)
+        return unless rest.is_a?(Prism::RestParameterNode) && rest.name
+
+        splat = tail.first
+        kept = aligned && tail.size == 1 && splat.is_a?(Prism::SplatNode) && reads?(splat.expression, rest.name)
+        rebound << rest.name unless kept
+      end
+
+      # Keywords correspond by name. A keyword the call omits falls back to its default, so it is rebound. A
+      # `**splat` other than the def's own `**rest`, a non-Symbol key or `...` may carry any keyword, so each of
+      # them rebinds every keyword. `**rest` is kept by `**rest` alone, with no key beside it that it would collect.
+      def note_keywords(params, keywords, forwarding, rebound)
+        names = params.keywords.map { |param| param.name.to_s.delete_suffix(":").to_sym }
+        rest_name = keyword_rest_name(params)
+        passed, splats, opaque = keyword_entries(keywords)
+        opaque ||= forwarding || splats.any? { |value| !reads?(value, rest_name) }
+        return rebound.merge(names, [rest_name].compact) if opaque
+
+        names.each { |name| rebound << name unless reads?(passed[name], name) }
+        rebound << rest_name if rest_name && !(splats.size == 1 && (passed.keys - names).empty?)
+      end
+
+      def keyword_rest_name(params)
+        rest = params.keyword_rest
+        rest.name if rest.is_a?(Prism::KeywordRestParameterNode)
+      end
+
+      # The call's keyword hash as `[{ name => value node }, [**splat value nodes], opaque]`, `opaque` when
+      # a key is not a plain Symbol.
+      def keyword_entries(keywords)
+        passed = {}
+        splats = []
+        opaque = false
+        (keywords&.elements || []).each do |element|
+          if element.is_a?(Prism::AssocSplatNode)
+            splats << element.value
+          elsif element.key.is_a?(Prism::SymbolNode) && element.key.unescaped
+            passed[element.key.unescaped.to_sym] = element.value
+          else
+            opaque = true
+          end
+        end
+        [passed, splats, opaque]
+      end
+
+      # Whether `node` is a bare read of the local `name` (`n`, or the `n:` shorthand's implicit read).
+      def reads?(node, name)
+        node = node.value if node.is_a?(Prism::ImplicitNode)
+        !name.nil? && node.is_a?(Prism::LocalVariableReadNode) && node.name == name
+      end
+    end
+  end
+end

data/lib/rigor/inference/refined_dispatch/constructed_class.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require_relative "../../run_scoped_slots"
+require_relative "../../typing_state"
+require_relative "../../memo_audit"
 
 module Rigor
   module Inference
@@ -18,9 +19,16 @@ module Rigor
       # the name itself, and no constant write of it. Any other shape answers false, as does a class a
       # `K = Class.new(...)` write names.
       module ConstructedClass
-        MEMO_KEY = RunScopedSlots.register(:__rigor_constructed_class__)
+        # ADR-129 WD1 — a run-scoped Memo keyed on the run-generation token and the environment, whose tables every
+        # answer reads and which are fixed for a run.
+        MEMO = TypingState.memo(
+          :constructed_class,
+          run_scoped: true,
+          audit: ["constructed class verdict", "constructed class segments", "constructed class names"],
+          reason: "verdicts keyed on the run-generation token and environment identities"
+        )
         EMPTY = [].freeze
-        private_constant :MEMO_KEY, :EMPTY
+        private_constant :MEMO, :EMPTY
 
         module_function
 
@@ -36,9 +44,19 @@ module Rigor
           return false if named.empty?
 
           by_class = (table[:verdicts][class_name] ||= {})
-          return by_class[named] if by_class.key?(named)
+          if by_class.key?(named)
+            return MemoAudit.check("constructed class verdict", by_class[named], class_name, named) do
+              apart_verdict(scope, named, class_name, memo(scope))
+            end
+          end
+
+          by_class[named] = MemoAudit.key_audit("constructed class verdict") do
+            apart_verdict(scope, named, class_name, table)
+          end
+        end
 
-          by_class[named] = named.all? { |constant| core_class_apart?(scope, constant, class_name.to_s, table) }
+        def apart_verdict(scope, named, class_name, table)
+          named.all? { |constant| core_class_apart?(scope, constant, class_name.to_s, table) }
         end
 
         def core_class_apart?(scope, constant, class_name, table)
@@ -68,7 +86,18 @@ module Rigor
 
         # The last segment of every class or module the project declares, reopenings included.
         def declared_segments(scope, table)
-          table[:segments] ||= declared_names(scope).each_key.to_set { |key| key.to_s.split("::").last }.freeze
+          segments = table[:segments]
+          if segments.nil?
+            return table[:segments] = MemoAudit.key_audit("constructed class segments") do
+              compute_declared_segments(scope)
+            end
+          end
+
+          MemoAudit.check("constructed class segments", segments, :segments) { compute_declared_segments(scope) }
+        end
+
+        def compute_declared_segments(scope)
+          declared_names(scope).each_key.to_set { |key| key.to_s.split("::").last }.freeze
         end
 
         # The constants `name`'s superclass expression names, or an empty Array; memoised per envelope bucket,
@@ -78,15 +107,18 @@ module Rigor
           return EMPTY if bucket.nil?
 
           names = table[:names]
-          return names[bucket] if names.key?(bucket)
-
-          names[bucket] =
-            if bucket.key?(Scope::DiscoveryIndex::ENVELOPE_META_SUPERCLASS_MARK)
-              EMPTY
-            else
-              kind = Scope::DiscoveryIndex::ENVELOPE_CONSTRUCTED_KIND
-              bucket.each_key.filter_map { |key| key[1] if key.is_a?(Array) && key[0] == kind }.freeze
-            end
+          if names.key?(bucket)
+            return MemoAudit.check("constructed class names", names[bucket], name) { bucket_constructed_names(bucket) }
+          end
+
+          names[bucket] = MemoAudit.key_audit("constructed class names") { bucket_constructed_names(bucket) }
+        end
+
+        def bucket_constructed_names(bucket)
+          return EMPTY if bucket.key?(Scope::DiscoveryIndex::ENVELOPE_META_SUPERCLASS_MARK)
+
+          kind = Scope::DiscoveryIndex::ENVELOPE_CONSTRUCTED_KIND
+          bucket.each_key.filter_map { |key| key[1] if key.is_a?(Array) && key[0] == kind }.freeze
         end
 
         # The run-wide table of declared classes: the seeded `discovered_class_sources`, or a single-file run's
@@ -100,15 +132,21 @@ module Rigor
         # `discovered_def_nodes`, as `ExpressionTyper` falls back) and the environment: every table read here is
         # fixed for a run, so each answer is computed once a run, and a new run replaces the slot.
         def memo(scope)
-          slot = Thread.current[MEMO_KEY]
+          return new_table if MemoAudit.enabled? && MemoAudit.suspended?
+
+          state = TypingState.current
+          slot = state[MEMO]
           generation = scope.run_generation || scope.discovered_def_nodes
           environment = scope.environment
           unless slot && slot[0].equal?(generation) && slot[1].equal?(environment)
-            slot = [generation, environment, { names: {}.compare_by_identity, verdicts: {} }]
-            Thread.current[MEMO_KEY] = slot
+            slot = [generation, environment, new_table]
+            state[MEMO] = slot
           end
           slot[2]
         end
+
+        # Empty tables: a new slot's, and a throwaway set while an audit recomputation bypasses the memo.
+        def new_table = { names: {}.compare_by_identity, verdicts: {} }
       end
     end
   end

data/lib/rigor/inference/refined_dispatch/own_method.rb

@@ -2,7 +2,8 @@
 
 require_relative "../builtins/cruby_definers"
 require_relative "constructed_class"
-require_relative "../../run_scoped_slots"
+require_relative "../../typing_state"
+require_relative "../../memo_audit"
 
 module Rigor
   module Inference
@@ -307,30 +308,54 @@ module Rigor
 
         def unknown_superclass_classes(scope, class_name)
           Analysis::DependencyRecorder.read_name(:subclass_of, "*") if Analysis::DependencyRecorder.active?
-          table = subclass_memo(scope)
-          all = table[:unknown] ||= begin
-            mark = Scope::DiscoveryIndex::ENVELOPE_META_SUPERCLASS_MARK
-            computed = scope.discovered_superclasses.filter_map { |child, parent| child if parent.nil? }
-            meta = scope.discovered_parameter_envelopes.filter_map { |name, bucket| name if bucket.key?(mark) }
-            (computed + meta).uniq.freeze
-          end
+          all = all_unknown_superclass_classes(scope)
           name = class_name.to_s
           all.include?(name) ? all - [name] : all
         end
 
-        SUBCLASS_MEMO_KEY = RunScopedSlots.register(:__rigor_own_method_subclasses__)
-        private_constant :SUBCLASS_MEMO_KEY
+        def all_unknown_superclass_classes(scope)
+          table = subclass_memo(scope)
+          stored = table[:unknown]
+          if stored.nil?
+            return table[:unknown] = MemoAudit.key_audit("own method unknown superclasses") do
+              compute_unknown_superclass_classes(scope)
+            end
+          end
+
+          MemoAudit.check("own method unknown superclasses", stored, :unknown) do
+            compute_unknown_superclass_classes(scope)
+          end
+        end
+
+        def compute_unknown_superclass_classes(scope)
+          mark = Scope::DiscoveryIndex::ENVELOPE_META_SUPERCLASS_MARK
+          computed = scope.discovered_superclasses.filter_map { |child, parent| child if parent.nil? }
+          meta = scope.discovered_parameter_envelopes.filter_map { |name, bucket| name if bucket.key?(mark) }
+          (computed + meta).uniq.freeze
+        end
+
+        # ADR-129 WD1 — a run-scoped Memo keyed on the identities of the discovery index and environment, the only
+        # inputs of the buckets it holds.
+        SUBCLASS_MEMO = TypingState.memo(
+          :own_method_subclasses,
+          run_scoped: true, audit: ["own method unknown superclasses", "own method children"],
+          reason: "subclass buckets keyed on the discovery index and environment identities"
+        )
+        private_constant :SUBCLASS_MEMO
 
         # One thread-local slot keyed on the scope's discovery index (a frozen `Data`) and environment, the only
         # inputs `children_by_parent` and the unknown-superclass list read; neither files a dependency edge
         # (`each_subclass` files its own `subclass_of:` edges on every call), so a hit drops none.
         def subclass_memo(scope)
-          slot = Thread.current[SUBCLASS_MEMO_KEY]
+          return {} if MemoAudit.enabled? && MemoAudit.suspended?
+
+          state = TypingState.current
+          slot = state[SUBCLASS_MEMO]
           discovery = scope.discovery
           environment = scope.environment
           unless slot && slot[0].equal?(discovery) && slot[1].equal?(environment)
             slot = [discovery, environment, {}]
-            Thread.current[SUBCLASS_MEMO_KEY] = slot
+            state[SUBCLASS_MEMO] = slot
           end
           slot[2]
         end
@@ -342,11 +367,20 @@ module Rigor
         end
 
         def children_by_parent(scope)
-          subclass_memo(scope)[:children] ||=
-            scope.discovered_superclasses.each_with_object({}) do |(child, raw_parent), children|
-              parent = scope.ancestor_name_candidates(child, raw_parent).find { |name| known_class?(scope, name) }
-              (children[parent] ||= []) << child if parent
-            end.each_value(&:freeze).freeze
+          table = subclass_memo(scope)
+          stored = table[:children]
+          if stored.nil?
+            return table[:children] = MemoAudit.key_audit("own method children") { compute_children_by_parent(scope) }
+          end
+
+          MemoAudit.check("own method children", stored, :children) { compute_children_by_parent(scope) }
+        end
+
+        def compute_children_by_parent(scope)
+          scope.discovered_superclasses.each_with_object({}) do |(child, raw_parent), children|
+            parent = scope.ancestor_name_candidates(child, raw_parent).find { |name| known_class?(scope, name) }
+            (children[parent] ||= []) << child if parent
+          end.each_value(&:freeze).freeze
         end
 
         def known_class?(scope, name)

data/lib/rigor/inference/refined_dispatch.rb

@@ -126,6 +126,19 @@ module Rigor
         out
       end
 
+      # ADR-121 WD7 — a names-wildcard row counts as a refinement of every name. True when a row `list` puts in
+      # effect names `method_name` (or the wildcard) for ANY refined class — which class the row refines is not
+      # decided here — or `list` carries {InEffectRefinements::UNKNOWN} and any row names it. {ExpressionTyper}
+      # asks it for a `&:name` block, whose receiver is not known; {SelfPreservingBlock} for the yielding method
+      # (issue #2909).
+      def refined_anywhere?(scope, method_name, list)
+        refinements = scope.discovered_refinements
+        return true if list.include?(InEffectRefinements::UNKNOWN) &&
+                       refinements.any? { |_refined, methods| methods.key?(method_name) || methods.key?(wildcard) }
+
+        !targets(refinements, method_name, list).nil? || !targets(refinements, wildcard, list).nil?
+      end
+
       # The refinement table records every name a `refine` argument's spelling can denote (`refine String` inside
       # `module M` records `M::String` and `String`), which only withholds a check. To type, a key must be the class
       # Ruby's lexical lookup resolves: one the project or RBS knows, with no longer spelling of the same last segment

data/lib/rigor/inference/reflective_ivar_write.rb

@@ -3,6 +3,7 @@
 require "prism"
 
 require_relative "../type"
+require_relative "../typing_state"
 
 module Rigor
   module Inference
@@ -26,8 +27,13 @@ module Rigor
       IVAR_NAME = /\A@[A-Za-z_]\w*\z/
       private_constant :IVAR_NAME
 
-      REPEATING_KEY = :__rigor_reflective_ivar_write_repeating__
-      private_constant :REPEATING_KEY
+      # ADR-129 WD1 — a Frame: the depth is installed for a region and restored on the way out.
+      REPEATING = TypingState.frame(
+        :reflective_ivar_write_repeating,
+        reason: "the repeat depth of `for` bodies and loop predicates, installed per region",
+        witness: "spec/fixtures/typing_state_witnesses/reflective_ivar_write_repeating.rb"
+      )
+      private_constant :REPEATING
 
       module_function
 
@@ -69,18 +75,20 @@ module Rigor
       # rebind fixpoint, and a predicate runs before every iteration but is walked once, so a literal-name write there
       # must not replace the binding with one pass's value ({.apply}). A `while` / `until` body does not enter it: its
       # fixpoint widens the ivar (issue #1930).
-      def in_repeating_body
-        depth = Thread.current[REPEATING_KEY] || 0
-        Thread.current[REPEATING_KEY] = depth + 1
-        begin
-          yield
-        ensure
-          Thread.current[REPEATING_KEY] = depth
-        end
+      def in_repeating_body(&)
+        state = TypingState.current
+        state.with(REPEATING, (state[REPEATING] || 0) + 1, &)
+      end
+
+      # Runs the block at repeat depth zero, restoring the depth on exit. A user-method body re-typed for its return
+      # starts from its own scope and reads its own write, so a caller's `for` body does not repeat it
+      # ({ExpressionTyper.with_call_site_frame}).
+      def outside_repeating_body(&)
+        TypingState.current.with(REPEATING, 0, &)
       end
 
       def repeating_body?
-        (Thread.current[REPEATING_KEY] || 0).positive?
+        (TypingState.current[REPEATING] || 0).positive?
       end
 
       # `scope` after `node` runs. A literal name binds that ivar to the value's type (yielded), as `@n = v` does.