rigortype 0.4.6 → 0.4.7

data/lib/rigor/inference/expression_typer.rb

@@ -10,6 +10,7 @@ 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"
@@ -345,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`
@@ -360,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}.
       #
@@ -1100,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
@@ -1519,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?
@@ -1771,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
@@ -2388,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
@@ -2442,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
@@ -2646,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
@@ -2684,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*
@@ -2885,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
@@ -2958,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
@@ -2966,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,
@@ -3000,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
@@ -3019,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` —
@@ -3110,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
@@ -3898,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)
@@ -3961,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
@@ -4009,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
@@ -4024,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
@@ -4353,13 +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). Issue #2301 — a
-      # project callee that hands the block on ({ProjectYielder.hands_block_on?}) also counts: the block's value is what
-      # the forward's target `yield`s, and that target may run it many times, so a captured local the block rebinds must
-      # not read its entry binding.
+      # {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) ||
-          ProjectYielder.hands_block_on?(call_node, receiver_type, scope)
+          ProjectYielder.block_value_may_repeat?(call_node, receiver_type, scope)
       end
 
       EMPTY_BREAK_ARMS = [].freeze
@@ -5569,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

@@ -5,6 +5,7 @@ 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
@@ -28,7 +29,15 @@ module Rigor
     # - `[: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]` and `[:own_write, class_name, name, path]`.
+    #   `[: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
@@ -78,7 +87,7 @@ module Rigor
       end
 
       # #1154 — the {IvarWriterCensus} entries of `census`, for the incremental diff and its readers.
-      IVAR_KINDS = %i[ivar_set ivar_set_class own_write].to_set.freeze
+      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
 
@@ -87,6 +96,7 @@ module Rigor
         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
@@ -140,6 +150,7 @@ module Rigor
           @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
@@ -148,6 +159,7 @@ module Rigor
         # 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)
@@ -160,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)