rigortype 0.4.5 → 0.4.7

data/lib/rigor/inference/expression_typer.rb

@@ -10,8 +10,10 @@ require_relative "../source/constant_path"
 require_relative "../source/node_children"
 require_relative "../source/node_walker"
 require_relative "../analysis/self_call_resolution_recorder"
+require_relative "../run_scoped_slots"
 require_relative "block_call_timing"
 require_relative "block_repetition"
+require_relative "project_yielder"
 require_relative "block_parameter_binder"
 require_relative "method_parameter_binder"
 require_relative "body_fixpoint"
@@ -344,7 +346,7 @@ module Rigor
         self.class.recorded_inject_accumulator(block, scope)
       end
 
-      INJECT_ACCUMULATOR_KEY = :__rigor_inject_accumulator__
+      INJECT_ACCUMULATOR_KEY = RunScopedSlots.register(:__rigor_inject_accumulator__)
       private_constant :INJECT_ACCUMULATOR_KEY
 
       # The accumulator type {#record_inject_accumulator} stored for `block` when the call was typed from `scope`
@@ -359,13 +361,18 @@ module Rigor
       # recording run to harvest each analyzed callee's observed call keys → return descriptors. Returns an
       # empty hash when no bucket exists (a run that memoised nothing). Class method: the bucket lives on
       # `Thread.current`, independent of any one `ExpressionTyper` instance.
-      def self.harvest_return_memo
-        slot = Thread.current[RETURN_MEMO_KEY]
-        return {} if slot.nil?
+      #
+      # `bucket` defaults to the calling thread's current one; `Runner#run` keeps the bucket its run filled
+      # ({.current_return_memo}) and passes it, since the run releases the thread's slot when it ends.
+      def self.harvest_return_memo(bucket = current_return_memo)
+        return {} if bucket.nil?
 
-        slot[1].transform_values(&:values)
+        bucket.transform_values(&:values)
       end
 
+      # The calling thread's return memo bucket (`{ def_node => { descriptor => MemoEntry } }`), or nil.
+      def self.current_return_memo = Thread.current[RETURN_MEMO_KEY]&.last
+
       # Issue #720 — the value the block passed by the call site currently being re-typed evaluates to, or
       # `nil` outside such a frame. Read by {#type_of_yield}.
       #
@@ -1051,7 +1058,7 @@ module Rigor
       # optimistic-carrier decline) and one terminating-arm rule, and cannot drift apart again. Only the
       # value is read; the post-scope belongs to whichever walk owns the statement.
       def type_of_conditional(node)
-        scope.evaluate(node, tracer: tracer).first
+        LoopValueRecord.fetch(node, scope) || scope.evaluate(node, tracer: tracer).first
       end
 
       def type_of_else(node)
@@ -1099,7 +1106,6 @@ module Rigor
           conditions = when_node.respond_to?(:conditions) ? when_node.conditions : []
           body_scope, next_scope = Narrowing.case_when_scopes(node.predicate, conditions, clause_scope)
           certainty = case_when_branch_certainty(subject_type, when_node)
-          # :no — drop the branch
           candidates << case_arm_type(when_node, body_scope) unless certainty == :no
           if certainty == :yes
             reached_yes = true
@@ -1272,11 +1278,22 @@ module Rigor
         Type::Combinator.bot
       end
 
-      # `while` and `until` loops produce nil unless interrupted by `break VALUE`; the expression value of
-      # `break VALUE` is not yet modeled (scope break-path propagation landed in `eval_loop`). Returning
-      # Constant[nil] is safe and matches Ruby semantics for the common case.
-      def type_of_loop(_node)
-        Type::Combinator.constant_of(nil)
+      # A `while` / `until` / `for` loop in value position. Like {#type_of_conditional}, it delegates to the
+      # statement evaluator, which owns the loop's value: `nil` or a `while` / `until` loop's `break` values
+      # (issue #2031), and a `for` loop's collection or its `break` values (issue #1216).
+      #
+      # A `while` / `until` loop no `break` leaves is `nil` without evaluating its body, as
+      # {StatementEvaluator#loop_value} answers it: a loop that is a call's receiver or argument is typed again by
+      # every narrowing and rule that types that operand, and evaluating it each time re-ran the passes of every loop
+      # nested in it.
+      def type_of_loop(node)
+        return Type::Combinator.constant_of(nil) if break_free_condition_loop?(node)
+
+        LoopValueRecord.fetch(node, scope) || scope.evaluate(node, tracer: tracer).first
+      end
+
+      def break_free_condition_loop?(node)
+        !node.is_a?(Prism::ForNode) && !block_level_jump?(node.statements, Prism::BreakNode)
       end
 
       def type_of_lambda(_node)
@@ -1507,9 +1524,8 @@ module Rigor
 
       # Stable single-hop chain narrowing — `receiver.method` after an `is_a?` / `kind_of?` / `instance_of?`
       # predicate established the narrowing on the dominated edge. The call MUST be no-arg + no-block +
-      # rooted at a local-var / ivar read; everything else falls through to the standard dispatcher. ROADMAP
-      # § Future cycles — "Method-call receiver narrowing across stable receivers" — Law-of-Demeter-justified
-      # single-hop scope.
+      # rooted at a local-var / ivar read; everything else falls through to the standard dispatcher. The
+      # single hop is Law-of-Demeter-justified.
       def method_chain_narrowing_for(node)
         return nil unless node.is_a?(Prism::CallNode)
         return nil unless node.block.nil?
@@ -1759,7 +1775,23 @@ module Rigor
       def call_type_for(node)
         return safe_navigation_call_type(node) if node.safe_navigation?
 
-        attribute_write_value(node, call_dispatch_type_for(node))
+        memo_object_value(node, attribute_write_value(node, call_dispatch_type_for(node)))
+      end
+
+      # Issue #2411 — `recv.each_with_object(memo) { |x, acc| acc[k] = v }` returns the memo as the block's
+      # stores leave it. The statement evaluator owns that join ({StatementEvaluator#each_with_object_value}),
+      # and reading it here gives every value position the statement's answer: a method's tail is typed through
+      # this typer, and read off the dispatch alone it was the memo argument's literal `{}` / `[]`. A `break` ends
+      # the call with its own value, so the block's break arms ({#call_break_arm_types}) join the memo: the join
+      # alone read `break :stop if x == 2; a << x` as `Array[1 | 2]`, where Ruby answers `:stop`.
+      def memo_object_value(node, result)
+        return result unless node.name == :each_with_object && node.block.is_a?(Prism::BlockNode)
+
+        memo = StatementEvaluator.new(scope: scope, tracer: tracer).each_with_object_value(node, result)
+        return memo if memo.equal?(result)
+
+        breaks = call_break_arm_types(node)
+        breaks.empty? ? memo : Type::Combinator.union(memo, *breaks)
       end
 
       # The RHS-value override for plain attribute / index writes (#520); a non-write call keeps the
@@ -2376,14 +2408,12 @@ module Rigor
       #
       # - the receiver is not `Nominal[T]` for some T;
       # - no def_node is recorded for that class/method (the receiver is foreign or has only an RBS sig);
-      # - the def has no body, or has a parameter shape we cannot bind from the call's positional args;
-      # - the inference is already in progress for this (class, method, signature) tuple — recursion safety
-      #   net.
+      # - the def has no body, or has a parameter shape we cannot bind from the call's positional args.
       # v0.0.3 A — re-types a top-level (or DSL-block-nested) `def` discovered by `ScopeIndexer` under the
       # `TOP_LEVEL_DEF_KEY` sentinel. Mirrors the `infer_user_method_return` shape but uses the current
       # `scope.self_type` (or implicit `Object`) as the receiver carrier so the body's own self is
       # consistent with the call site's. Returns nil when the parameter shape disqualifies the def, when the
-      # body is empty, or when a recursion cycle is detected.
+      # body is empty, or when the inference raises.
       def infer_top_level_user_method(def_node, receiver, arg_types, block_type = nil)
         infer_user_method_return(def_node, receiver, arg_types, yield_type: block_type)
       rescue StandardError
@@ -2430,9 +2460,9 @@ module Rigor
 
       # True when `type` is a concrete value — a `Type::Constant` or a `Type::Tuple` whose elements are
       # (recursively) all value-pinned. ADR-55 slice 1: a value-pinned self-call result is adopted even
-      # inside a class/method body (where WD3 otherwise keeps non-`Bot` returns as `Dynamic[top]`). A
-      # concrete value at a call site is strictly more precise and can never enable an undefined-method or
-      # argument-type false positive — it is FP-neutral by construction.
+      # inside a class/method body (where WD3 otherwise keeps non-`Bot` returns as `Dynamic[top]`). A concrete
+      # value at a call site is strictly more precise and can never enable an undefined-method or argument-type
+      # false positive — it is FP-neutral by construction.
       def fully_value_pinned?(type)
         case type
         when Type::Constant then true
@@ -2634,9 +2664,63 @@ module Rigor
         found = scope.singleton_def_through_ancestors(class_name, method_name)
         owner = found.last
         found = [nil, nil] if owner && SingletonExternalAhead.withhold?(scope, class_name, method_name, owner)
+        found = [nil, nil] if found.last && dynamic_singleton_definer_ahead?(class_name, method_name, found.last)
         table[key] = found
       end
 
+      SINGLETON_WILDCARD_SLOT = %i[singleton *].freeze
+      private_constant :SINGLETON_WILDCARD_SLOT
+
+      # Issue #2284 — a project entry nearer than the `def`'s owner on the singleton chain may define the name
+      # without a `def`, which the def tables do not hold: `class S < B; define_singleton_method(:x) { "s" }; end`
+      # calls S's block, not `B.x`. The farther `def` is then withheld and the call types `Dynamic`. A class's own
+      # singleton side is read from the visibility-contest census: `define_singleton_method(:x)`,
+      # `singleton_class.define_method(:x)` / `attr_*` and a computed name contest the entry's slot whether or not a
+      # `def` is recorded (#1984, #2013). An `extend`ed module's side is read from `discovered_methods`, which holds
+      # its `attr_*` and `define_method` rows, and the module's `def self.extended` hook may define any name on the
+      # extender, so it withholds too.
+      #
+      # An `inherited` hook anywhere on the chain past the receiver's own entry runs when the receiver's class is
+      # created and may define any singleton method on it (`def self.inherited(s) = s.define_singleton_method(:x)`),
+      # so a `def` the receiver only inherits is withheld then as well: a class's `def self.inherited`, or an
+      # `inherited` an extended module defines.
+      def dynamic_singleton_definer_ahead?(class_name, method_name, owner)
+        name = method_name.to_sym
+        chain = Scope::ResolutionChain.for(scope, class_name.to_s, :singleton, :methods)
+        return true if class_name.to_s != owner.to_s && inherited_hook_on_chain?(chain, class_name.to_s)
+
+        chain.entries.each do |entry|
+          next if entry.external?
+          return false if entry.name == owner.to_s
+          return true if entry_defines_without_def?(entry, name)
+        end
+        false
+      end
+
+      def inherited_hook_on_chain?(chain, receiver_name)
+        chain.entries.any? do |entry|
+          next false if entry.external? || entry.name == receiver_name
+
+          if entry.side == :singleton
+            !scope.singleton_def_for(entry.name, :inherited).nil?
+          else
+            scope.discovered_method?(entry.name, :inherited, :instance)
+          end
+        end
+      end
+
+      def entry_defines_without_def?(entry, name)
+        unless entry.side == :singleton
+          return scope.discovered_method?(entry.name, name, :instance) ||
+                 !scope.singleton_def_for(entry.name, :extended).nil?
+        end
+
+        discovery = scope.discovery
+        # No edge of its own: `singleton_def_through_ancestors`' chain search filed every entry ahead of the owner.
+        discovery.contested?(:discovered_method_visibilities, [entry.name, [:singleton, name]]) ||
+          discovery.contested?(:discovered_method_visibilities, [entry.name, SINGLETON_WILDCARD_SLOT])
+      end
+
       # The project-side singleton-method band: a `Foo.bar` call resolved against a `class << …` / `def self.…`
       # body the project itself wrote. Which of the two tiers applies is decided by the receiver carrier —
       # `Singleton[Foo]` when the constant names a class or module, `Nominal[…]` when it holds an ordinary
@@ -2672,7 +2756,7 @@ module Rigor
       # external entries this lookup passes over. Cross-file: the chain is built from the tables the runner
       # seeds from the project-wide pre-pass, cycle-guarded and capped at `Scope::ANCESTOR_WALK_LIMIT`.
 
-      CLASS_GRAPH_CACHE_KEY = :__rigor_class_graph_cache__
+      CLASS_GRAPH_CACHE_KEY = RunScopedSlots.register(:__rigor_class_graph_cache__)
       private_constant :CLASS_GRAPH_CACHE_KEY
 
       # Memo for the static class-graph resolvers below. They are pure functions of the scope's *frozen*
@@ -2873,7 +2957,7 @@ module Rigor
         dynamic_top
       end
 
-      OVERRIDE_GATE_CACHE_KEY = :__rigor_overridable_method_gate__
+      OVERRIDE_GATE_CACHE_KEY = RunScopedSlots.register(:__rigor_overridable_method_gate__)
       private_constant :OVERRIDE_GATE_CACHE_KEY
 
       # Memo for {#overridden_in_project?}, nested `kind → owner → method_name`. The predicate is a pure
@@ -2946,7 +3030,7 @@ module Rigor
       EMPTY_REDEFINERS = [].freeze
       private_constant :EMPTY_REDEFINERS
 
-      METHOD_DEFINERS_INDEX_KEY = :__rigor_method_definers_index__
+      METHOD_DEFINERS_INDEX_KEY = RunScopedSlots.register(:__rigor_method_definers_index__)
       private_constant :METHOD_DEFINERS_INDEX_KEY
 
       # The second way. Two flat thread slots rather than one slot holding an array of ways: a
@@ -2954,7 +3038,7 @@ module Rigor
       # elements are pinned, and the engine then reads the `way[0].equal?(…)` guards below as always-falsey
       # (`make check` fires `flow.always-truthy-condition` on this very file). Two keys read as two plain
       # `Thread.current` reads and keep the guards analysable.
-      METHOD_DEFINERS_INDEX_ALT_KEY = :__rigor_method_definers_index_alt__
+      METHOD_DEFINERS_INDEX_ALT_KEY = RunScopedSlots.register(:__rigor_method_definers_index_alt__)
       private_constant :METHOD_DEFINERS_INDEX_ALT_KEY
 
       # `method_name (Symbol) → [owner names]` inverted index over the instance / singleton def tables,
@@ -2988,8 +3072,9 @@ module Rigor
       # the singleton index.
       #
       # DELIBERATELY not keyed on the whole {Scope::DiscoveryIndex}, unlike {#class_graph_buckets} and
-      # {#override_gate_buckets} above. {#build_method_definers_index} reads the ONE table it is handed and
-      # nothing else, so the def tables are already the complete key, and the index object is a strictly
+      # {#override_gate_buckets} above. {DefinersIndex.for} reads the ONE table it is handed, and the seed that
+      # table was merged over, and nothing else, so the def tables are already the complete key, and the index
+      # object is a strictly
       # narrower one: the project-seed scope carries a fresh index per file while its def tables stay the
       # same object. Over the 200 synthetic files above, an index-keyed memo misses all 400 times where a
       # def-table-keyed one misses 201 — it would rebuild the seed's 934-entry table once per file and hand
@@ -3007,17 +3092,7 @@ module Rigor
           Thread.current[METHOD_DEFINERS_INDEX_KEY] = way
         end
         singleton = kind == :singleton
-        way[singleton ? 3 : 2] ||= build_method_definers_index(singleton ? singleton_def_nodes : def_nodes)
-      end
-
-      def build_method_definers_index(table)
-        index = {}
-        table.each do |class_name, methods|
-          next if class_name == Inference::ScopeIndexer::TOP_LEVEL_DEF_KEY
-
-          methods.each_key { |method_name| (index[method_name] ||= []) << class_name }
-        end
-        index
+        way[singleton ? 3 : 2] ||= DefinersIndex.for(singleton ? singleton_def_nodes : def_nodes)
       end
 
       # True when `candidate`'s ancestor chain (superclasses + included/prepended modules) reaches `owner` —
@@ -3098,10 +3173,11 @@ module Rigor
       # `[receiver, *args]` descriptor tuple; a callee may appear under at most two node identities per run
       # (the project-index parse every OTHER file resolves through, plus the defining file's own analysis
       # parse). Only the current generation's bucket is retained (single slot) — a rolled-over run's entries
-      # become garbage instead of accumulating across LSP runs. `ExpressionTyper` is rebuilt per
-      # `Scope#type_of`, so the store lives on `Thread.current`; fork-pool workers are separate processes,
-      # so it never crosses a project boundary (ADR-84 WD5).
-      RETURN_MEMO_KEY = :__rigor_user_method_return_memo__
+      # become garbage instead of accumulating across LSP runs, and the run that filled the slot releases it
+      # when it ends ({RunScopedSlots}; `Runner#run` keeps its bucket for `#return_summaries`).
+      # `ExpressionTyper` is rebuilt per `Scope#type_of`, so the store lives on `Thread.current`; fork-pool
+      # workers are separate processes, so it never crosses a project boundary (ADR-84 WD5).
+      RETURN_MEMO_KEY = RunScopedSlots.register(:__rigor_user_method_return_memo__)
       private_constant :RETURN_MEMO_KEY
 
       # ADR-84 WD2 — one memo entry: the final inferred return plus, when the entry was computed under
@@ -3318,21 +3394,34 @@ module Rigor
         cache = class_graph_buckets[:yields]
         return cache[def_node] if cache.key?(def_node)
 
-        cache[def_node] = yield_reachable?(def_node.body)
+        cache[def_node] = yield_reachable?(def_node.body, def_node.parameters&.block&.name)
       end
 
-      def yield_reachable?(node)
+      def yield_reachable?(node, block_name)
         return false if node.nil?
-        return true if node.is_a?(Prism::YieldNode)
+        return true if node.is_a?(Prism::YieldNode) || forwards_block_argument?(node, block_name)
 
         node.rigor_each_child do |child|
           next if YIELD_BOUNDARY_NODES.include?(child.class)
 
-          return true if yield_reachable?(child)
+          return true if yield_reachable?(child, block_name)
         end
         false
       end
 
+      # Issue #1157 — a call that hands on its method's block (`&`, or `&blk` naming the block parameter) reaches the
+      # caller's block as a `yield` does. Whether `blk` is still the method's own block (not rebound or shadowed) is
+      # decided where it is typed ({#forwarded_block_return_type}); this only keeps the call-site dimension for a def
+      # that might.
+      def forwards_block_argument?(node, block_name)
+        block = node.respond_to?(:block) ? node.block : nil
+        return false unless block.is_a?(Prism::BlockArgumentNode)
+
+        expression = block.expression
+        expression.nil? || (!block_name.nil? && expression.is_a?(Prism::LocalVariableReadNode) &&
+                            expression.name == block_name)
+      end
+
       # The candidate-frame memo path: consult the current run generation's bucket, and on a miss compute
       # and store a FINAL result. Reached only when `memo_candidate?` held (see `infer_user_method_return`).
       # The store gate (ADR-84 WD3): a result is stored when no transient-machinery event during the
@@ -3873,7 +3962,7 @@ module Rigor
       # Consumes one unit from the thread-local unroll-fuel counter and returns the units that were
       # available *before* this consumption (so a positive return means the extended value-key may be used).
       # Fuel is per-outermost inference entry: at the top level (empty guard stack) it seeds to
-      # `RECURSION_UNROLL_FUEL`, and the `ensure` in `infer_user_method_return` clears it once the stack
+      # `RECURSION_UNROLL_FUEL`, and the `ensure` in `evaluate_guarded_user_method_body` clears it once the stack
       # drains back to empty. On exhaustion (return 0) it records a `RECURSION_UNROLL_FUEL` hit so the caller
       # keeps the plain `(receiver, method)` signature — today's behaviour.
       def unroll_fuel_remaining(stack)
@@ -3936,7 +4025,7 @@ module Rigor
       # to the receiver's nominal type, the project-wide accumulators inherited (so the body sees the same
       # `discovered_classes` / `class_ivars` / etc. the caller does), and the call's `arg_types` bound to
       # the parameters. Returns nil when the binding is truly ambiguous (arity mismatch, trailing `post`
-      # params, `...` forwarding).
+      # params).
       #
       # Issue #524 — the binder is per-PARAMETER, not per-signature. The first iteration declined any def
       # with an optional / rest / keyword / block parameter outright, so ONE `options = {}` default zeroed
@@ -3984,7 +4073,7 @@ module Rigor
         body_scope.with_repeated_or_writes(RepeatedOrWrites.straight_line_sites(def_node.body, body_scope))
       end
 
-      # Issue #681 / #707 — the ONE place in `lib/` that answers "what `Module.nesting` was recorded for this
+      # Issue #681 / #707 — the typer's answer to "what `Module.nesting` was recorded for this
       # def node". `Scope::DiscoveryIndex#discovered_def_nestings` is the owner; the resolver memo is that
       # table's REHYDRATION for the one population it cannot hold — a def served from an ADR-85 seed bundle,
       # whose node {Inference::DefNodeResolver} mints from its own parse, so no table keyed by the identities
@@ -3999,7 +4088,7 @@ module Rigor
       # run and an `--incremental` recheck answering the same constant for the same body; the rehydration half
       # is populated only inside `DefNodeResolver.with_run`, and outside it this falls back to the peel.
       def recorded_def_nesting(def_node)
-        scope.discovery.discovered_def_nestings[def_node] || DefNodeResolver.rehydrated_nesting(def_node)
+        scope.discovery.recorded_def_nesting(def_node)
       end
 
       # The body scope's fold-safe set: the body's own struct locals, plus issue #525's `:self` sentinel
@@ -4328,9 +4417,15 @@ module Rigor
 
       # Whether the call may run its block more than once, so a later run reads a captured binding an earlier
       # run rebound — the premise of laying the #587 (b) binding ({#captured_block_bindings}) under the block.
-      # {BlockRepetition.may_repeat?} holds the rule, which the statement pass shares (issue #1412).
+      # {BlockRepetition.may_repeat?} holds the rule, which the statement pass shares (issue #1412). A project callee
+      # whose body may run the block more than once on one path ({ProjectYielder.block_value_may_repeat?}) also
+      # counts: a `yield` in a loop or a core iterator's block (`xs.each { |x| v = yield(x) }`, issue #2303), or a
+      # hand-off (`g(x, &)`, issue #2301), whose target may run it many times, so a captured local the block rebinds
+      # must not read its entry binding. A callee that runs it once per path (`f ? yield(1) : yield(2)`,
+      # `then { yield }`) keeps the single-run value.
       def block_may_repeat?(call_node, receiver_type)
-        BlockRepetition.may_repeat?(method_name: call_node.name, receiver_type: receiver_type, scope: scope)
+        BlockRepetition.may_repeat?(method_name: call_node.name, receiver_type: receiver_type, scope: scope) ||
+          ProjectYielder.block_value_may_repeat?(call_node, receiver_type, scope)
       end
 
       EMPTY_BREAK_ARMS = [].freeze
@@ -4426,10 +4521,22 @@ module Rigor
           )
           type_block_body(block_arg, entry, captured: captured)
         when Prism::BlockArgumentNode
-          symbol_block_return_type(block_arg, expected)
+          forwarded_block_return_type(block_arg) || symbol_block_return_type(block_arg, expected)
         end
       end
 
+      # Issue #1157 — `&` / `&blk` hands the callee the block this method was itself called with, so the callee's
+      # `yield` is worth what the CALLER's block returns: the value {.current_yield_value_type} already holds for
+      # this frame (the one a `yield` written here reads). Without it a name resolver that passes its block on
+      # (`def walk(x, &) = first_hit(x, &)`) read as `Dynamic[top]` through the forward and was skipped by
+      # `sig-gen`. Nil when the argument is not a forwarded block or the call site passed no block.
+      def forwarded_block_return_type(block_arg)
+        frame = scope.match_frame
+        return nil unless frame&.forwards_block?(block_arg)
+
+        ExpressionTyper.current_yield_value_type
+      end
+
       # The scope a block body is typed under: the surrounding scope plus the parameter bindings the receiving
       # method's signature implies, with the #587 (b) `captured` binding ({#repeating_captured_bindings}) laid
       # between the two, so the body reads what a captured local, instance variable, class variable or global
@@ -4524,6 +4631,14 @@ module Rigor
       # A failure in the re-answer falls back to the plain tail-only answer, for the reason
       # {#threaded_block_body_type} gives: a raise reaching `block_return_type_for` would report "no block".
       def tail_only_block_body_type(body, block_scope, captured)
+        StatementEvaluator.provisional_returns { tail_only_block_body_type_unrecorded(body, block_scope, captured) }
+      end
+
+      # Issue #2299 — the tail alone, typed from `block_scope`, is not the walk the method's returns are collected
+      # from: a `return` in it reads a name the skipped prefix binds as unbound. Its records are provisional
+      # ({StatementEvaluator.provisional_returns}): the statement walk's record of the same `return` replaces one,
+      # and one stands only for a block the walk never enters (a block in expression position).
+      def tail_only_block_body_type_unrecorded(body, block_scope, captured)
         return block_scope.type_of(body) unless block_body_threading_suppressed? && body.is_a?(Prism::StatementsNode)
 
         answered =
@@ -5520,8 +5635,9 @@ module Rigor
       end
 
       # Records `type` as the accumulator `block` receives when typed from this typer's scope
-      # ({.recorded_inject_accumulator}). The keys are weak, so a finished file's nodes do not stay reachable, and
-      # the values strong, so a record outlives a collection while its node does. Prism nodes compare by identity.
+      # ({.recorded_inject_accumulator}). Prism nodes compare by identity. The keys are weak but the values strong,
+      # and a recorded scope reaches the parse tree that holds the key, so a record never goes on its own (issue
+      # #2412): the map is a run-scoped slot ({RunScopedSlots}), emptied when the run that filled it ends.
       def record_inject_accumulator(block, type)
         (Thread.current[INJECT_ACCUMULATOR_KEY] ||= ObjectSpace::WeakKeyMap.new)[block] = [scope, type].freeze
       end

data/lib/rigor/inference/external_ancestor_resolution.rb

@@ -28,13 +28,12 @@ module Rigor
     # a flag threaded into `Scope`: an ADR-2 plugin-facing bypass of dependency recording would produce
     # a silently stale warm cache that no diagnostic diff can show.
     #
-    # There is deliberately NO memo here. The dispatch consumer this module is being extracted FOR does
-    # not exist yet, and a memo keyed on the tables this slice happens to name would be keyed on less
+    # There is deliberately NO memo here. A memo keyed on the tables the walk names would be keyed on less
     # than the walk reads — the ancestor chain resolves names through `known_user_class?`
     # (`discovered_def_nodes`, `discovered_methods`) and `ancestor_name_candidates`
     # (`discovered_header_nestings`). The chain itself is memoised per discovery index
-    # ({Scope::ResolutionChain}); the slice that brings the hot path brings this module's memo, keyed on
-    # what that consumer actually reads.
+    # ({Scope::ResolutionChain}); the dispatch callers in {MethodDispatcher::RbsDispatch} memoise their
+    # own answers, keyed on what they read.
     module ExternalAncestorResolution
       # The owner a name must PRECEDE for its declaration to win an MRO. See {declared_before_object?}.
       OBJECT_OWNER = "Object"

data/lib/rigor/inference/global_write_census.rb

@@ -4,6 +4,8 @@ require "prism"
 
 require_relative "../source/constant_path"
 require_relative "../source/node_children"
+require_relative "ivar_writer_census"
+require_relative "stored_block_call"
 
 module Rigor
   module Inference
@@ -26,6 +28,16 @@ module Rigor
     #   kept apart from `[:defines, …]`.
     # - `[:main_mixin, name]` — a module a top-level `include`, `prepend` or `extend` mixes into `Object` (or
     #   `main`), as written. A module RBS does not know may carry any method, so it reaches every class.
+    # - the instance-variable writer entries of {IvarWriterCensus} (issue #1154): `[:ivar_set, name]`,
+    #   `[:ivar_set_class, class_name]`, `[:own_write, class_name, name, path]` and, issue #2079,
+    #   `[:own_write_type, class_name, name, value, path]`.
+    # - `[:global_writer, name, method]` — issue #2314: a write of the global `name` inside a method body, keyed by
+    #   the `def`'s name (or the literal name a `define_method` block defines), or by nil inside a lambda or a block
+    #   its call keeps to run later ({StoredBlockCall}). A write in a block its call runs at once belongs to the
+    #   enclosing body. A write at the top level or in a class body records nothing, and neither does a write of
+    #   the frame-local `$_` or `$~`. {GlobalWriterReach} reads these.
+    # - `[:method_alias, new, old]` — issue #2314: `alias new old`, `alias_method :new, :old` or `def_delegator
+    #   :@o, :old, :new`, whose new name runs a method named old. {GlobalWriterReach} follows it.
     #
     # The census is a `Set` of those frozen entries, merged by union across files, the project pre-pass and the
     # `pre_eval:` files. It is recorded inside descents that already visit every node ({Collector#visit}), never
@@ -74,12 +86,41 @@ module Rigor
         census.include?(DEFINES_ANY) || names.any? { |name| census.include?([:defines, name]) }
       end
 
+      # #1154 — the {IvarWriterCensus} entries of `census`, for the incremental diff and its readers.
+      IVAR_KINDS = %i[ivar_set ivar_set_class own_write own_write_type].to_set.freeze
+
+      def ivar_set_entries(census) = census.select { |entry| IVAR_KINDS.include?(entry.first) }.to_set
+
+      # The negative-dependency key an {IvarWriterCensus} entry fires, the one `UnseenIvarWriters` records.
+      def ivar_key(entry)
+        case entry.first
+        when :ivar_set then "ivar_set:#{entry[1]}"
+        when :ivar_set_class then "ivar_set_class:#{entry[1]}"
+        when :own_write_type then "own_write_type:#{entry[1]}##{entry[2]}"
+        else "own_write:#{entry[1]}##{entry[2]}"
+        end
+      end
+
       # Whether some refinement may add `write`.
       def refines_write?(census) = census.include?(REFINES_ANY) || census.include?(%i[refines write])
 
       # The module names the top-level mixins spell.
       def main_mixins(census) = census.filter_map { |entry| entry[1] if entry[0] == :main_mixin }
 
+      # Issue #2158 — the `global_census:` dependency key a census entry moves, without the kind prefix: `alias:$x`,
+      # `defines:write`, `refines:write`, `defines_any`, `refines_any`, and `main_mixin` for every top-level mixin: its
+      # reader asks about each, and one shared key is a deliberate precision trade-off (a mixin moving anywhere
+      # re-checks every write that read them). The rules that read the census record these keys
+      # (`CheckRules#record_global_census`), and `Analysis::Incremental.changed_global_census_keys` fires them for
+      # every entry that appeared in or vanished from a file's census.
+      def dependency_key(entry)
+        case entry
+        when DEFINES_ANY then "defines_any"
+        when REFINES_ANY then "refines_any"
+        else entry[0] == :main_mixin ? "main_mixin" : "#{entry[0]}:#{entry[1]}"
+        end
+      end
+
       # A standalone walk, for a file no existing descent visits (a `pre_eval:` entry).
       def scan(root)
         collector = Collector.new(InEffectRefinements.new(root))
@@ -107,12 +148,18 @@ module Rigor
         def initialize(in_effect)
           @census = Set.new
           @refine_ranges = []
+          @ivar_writers = IvarWriterCensus.new(@census)
           @in_effect = in_effect
+          @bodies = []
         end
 
         # A node the collector cannot read must not fail the analysis of its file, nor of every file the pre-pass
         # feeds: the census then counts it as a definition of every name, which only declines a report.
-        def visit(node, top_level:)
+        # `owner` is the qualified name of the class whose body the node sits in, for {IvarWriterCensus} (nil where
+        # the host walk does not track it, or no class owns an instance there).
+        def visit(node, top_level:, owner: nil)
+          @ivar_writers.visit(node, owner)
+          visit_global_writer(node)
           case node
           when Prism::AliasGlobalVariableNode then visit_global_alias(node)
           when Prism::DefNode then record(node, node.name)
@@ -125,6 +172,68 @@ module Rigor
 
         private
 
+        # Issue #2314 — tracks the method bodies, lambdas and stored blocks of a pre-order descent as flat
+        # `start, end, label` triples (`@bodies`, innermost last), and records a global write inside one
+        # ({GlobalWriterReach}). A body ending before the write starts is closed. Only those nodes read their location.
+        def visit_global_writer(node)
+          case node
+          when Prism::DefNode then open_body(node, node.name)
+          when Prism::LambdaNode then open_body(node, nil)
+          when Prism::AliasMethodNode then record_method_alias(node.new_name, node.old_name)
+          when Prism::CallNode
+            open_stored_block(node)
+            visit_alias_call(node)
+          when Prism::GlobalVariableWriteNode, Prism::GlobalVariableOrWriteNode, Prism::GlobalVariableAndWriteNode,
+               Prism::GlobalVariableOperatorWriteNode, Prism::GlobalVariableTargetNode
+            record_global_writer(node)
+          end
+        end
+
+        # `$_` and `$~` are the frame's own: a method's write to one never reaches its caller.
+        FRAME_LOCAL_GLOBALS = %i[$_ $~].freeze
+        private_constant :FRAME_LOCAL_GLOBALS
+
+        def record_global_writer(node)
+          return if FRAME_LOCAL_GLOBALS.include?(node.name)
+
+          start = node.location.start_offset
+          bodies = @bodies
+          bodies.pop(3) while !bodies.empty? && bodies[-2] <= start
+          index = bodies.size - 3
+          index -= 3 while index >= 0 && !(bodies[index] <= start && start < bodies[index + 1])
+          @census << [:global_writer, node.name, bodies[index + 2]].freeze if index >= 0
+        end
+
+        def open_body(node, label)
+          location = node.location
+          @bodies.push(location.start_offset, location.end_offset, label)
+        end
+
+        # `alias_method :new, :old`, and `def_delegator :@o, :old, :new` (and its instance and single spellings), whose
+        # new name runs a method of the old name.
+        def visit_alias_call(node)
+          arguments = node.arguments&.arguments
+          case node.name
+          when :alias_method then record_method_alias(arguments[0], arguments[1]) if arguments&.size == 2
+          when :def_delegator, :def_instance_delegator, :def_single_delegator
+            record_method_alias(arguments[2], arguments[1]) if arguments&.size == 3
+          end
+        end
+
+        def record_method_alias(new_node, old_node)
+          new_name = literal_name(new_node)
+          old_name = literal_name(old_node)
+          @census << [:method_alias, new_name, old_name].freeze if new_name && old_name && new_name != old_name
+        end
+
+        def open_stored_block(node)
+          block = node.block
+          return unless block.is_a?(Prism::BlockNode) && StoredBlockCall.stores_block?(node)
+
+          definer = %i[define_method define_singleton_method].include?(node.name)
+          open_body(block, definer ? literal_name(node.arguments&.arguments&.first) : nil)
+        end
+
         def visit_global_alias(node)
           [node.new_name, node.old_name].each do |side|
             @census << GlobalWriteCensus.alias_entry(side.name) if side.is_a?(Prism::GlobalVariableReadNode)