rigortype 0.4.0 → 0.4.1

data/lib/rigor/inference/definer_resolution.rb

@@ -0,0 +1,266 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Inference
+    # ADR-119 WD2 — the candidate-set read over {Scope::ResolutionChain}, for a reader that can decline. It is
+    # internal (not a `Scope` method, so the pinned public surface is unchanged) and answers one of three
+    # things about a method name on a class:
+    #
+    # - {Known} — every candidate gives the same answer to the question asked;
+    # - {UNKNOWN} — the chain does not stand for this name (a mark not discharged, a fork, a retro world that
+    #   answers otherwise), a candidate disagrees, the walk was cut by the budget, an external ancestor ahead of
+    #   the candidate may answer first (one RBS does not know, or knows and declares the name in; one it knows
+    #   and whose declaration lacks the name is skipped);
+    # - {ABSENT} — no project entry, no external entry and not the implicit `Object` can answer.
+    #
+    # On the singleton side (ADR-119 WD3, errata 2026-10-08) the chain is `K`'s singleton, its extends' instance
+    # chains, then the superclass's singleton chain; an external superclass entry stands for its whole tail and is
+    # tested against RBS's singleton side, an extended external module against its instance side, the implicit tail
+    # after a project superclass against `Object`'s singleton side. A standing chain is then read past
+    # {SingletonHookDecline}' positional decline: a hook's singleton-side edge is recorded on no includer, so the read
+    # declines where one could have landed ahead of its last candidate.
+    #
+    # THE CALL SITE IS A CONTRACT. A result is consumed only by an exhaustive `case/in` that is the call's own
+    # direct predicate, with one arm per answer and no `else` or `in _`, and is never stored, returned or
+    # truth-tested: {UNKNOWN} and {ABSENT} are both truthy, so any other use folds a decline into a firing arm.
+    # `spec/rigor/inference/definer_resolution_case_in_spec.rb` fails on a call site of any other shape.
+    #
+    # It migrates one question at a time: `SourceArity` (C1b) and the relationship lints (C1c) read the instance
+    # side; no production reader reads the singleton side yet (C2-a landed it for C2's typing sites).
+    module DefinerResolution
+      Known = Data.define(:answer, :owner)
+      UnknownResult = Data.define
+      AbsentResult = Data.define
+      UNKNOWN = UnknownResult.new
+      ABSENT = AbsentResult.new
+
+      # One candidate definer as a per-chain answer function reports it: the `answer` to the question, the
+      # `owner` entry's name, the `index` of that entry on the chain and its `side` (`:instance` or `:singleton`).
+      Hit = Data.define(:answer, :owner, :index, :side)
+
+      QUESTIONS = %i[definer visibility arity override own_side].freeze
+      NONE = :rigor_definer_resolution_none
+      STRAY = :rigor_definer_resolution_stray
+      private_constant :NONE, :STRAY
+
+      module_function
+
+      # `answer_in` is the question's per-chain answer function: called with a chain and a position, it returns
+      # the {Hit} of the first project entry at or after the position that defines `method_name`, or nil. `:definer`
+      # and `:visibility` have a default; every other question supplies its own. It is called once per candidate
+      # on the chain, and again on the retro world when the chain has one fork, where `from` is mapped to the
+      # entry it followed.
+      def resolve(scope, class_name, method_name, side, question:, from: 0, &answer_in)
+        raise ArgumentError, "unknown question #{question.inspect}" unless QUESTIONS.include?(question)
+
+        answer_in = override_answer(scope, &answer_in) if question == :override
+        answer_in ||= default_answer(scope, method_name, question)
+        flavor = question == :arity ? :arity : :methods
+        chain = Scope::ResolutionChain.for(scope, class_name.to_s, side, flavor)
+
+        hits = candidates(scope, chain, method_name, from, answer_in)
+        return UNKNOWN if hits.nil?
+
+        verdict = chain.settle(scope, outcomes(hits), owner: hits.first&.owner, unknown_for: method_name) do |retro|
+          retro_from = retro_position(chain, retro, from)
+          outcomes(retro_from && candidates(scope, retro, method_name, retro_from, answer_in))
+        end
+        return UNKNOWN unless verdict == :chain
+        return UNKNOWN if side == :singleton && SingletonHookDecline.decline?(scope, chain, method_name, from, hits)
+
+        collapse(hits)
+      end
+
+      # The `:override` question's answer function, built from the caller's block: that block is NOT a per-chain
+      # function but `|owner_name| value`, called on each project entry in order, and its first non-nil `value` is
+      # the entry's answer, as `[owner_name, value]` (the owner is part of the answer so that two worlds naming
+      # different parents disagree). It is the override lints' parent read: the nearest project ancestor after the
+      # class whose block answers.
+      def override_answer(scope)
+        lambda do |chain, from|
+          first_hit(chain, scope, from) do |entry|
+            value = yield(entry.name)
+            [entry.name, value] unless value.nil?
+          end
+        end
+      end
+
+      # `from` is a position on `chain`; the same position on the retro world is just after the entry it followed.
+      # An entry the chain carries twice cannot be matched, which declines.
+      def retro_position(chain, retro, from)
+        return 0 if from.zero?
+
+        entry = chain.entries[from - 1]
+        return nil if entry.nil? || chain.entries.count(entry) > 1
+
+        found = retro.entries.index(entry)
+        found && (found + 1)
+      end
+
+      # The first definer and, while that definer is `possible`, the next; a nil joins the set when nothing
+      # follows (the absent candidate). A cut chain, and a chain on which an external ancestor ahead of the
+      # candidate (or, with no candidate, the implicit `Object`) may define the name, is a decline, answered by
+      # nil instead of a set.
+      def candidates(scope, chain, method_name, from, answer_in)
+        hits = []
+        position = from
+        loop do
+          hit = answer_in.call(chain, position)
+          hit = past_fold_copies(scope, chain, method_name, hit, answer_in) if chain.side == :singleton
+          return nil if hit.equal?(STRAY)
+
+          raise ArgumentError, "answer function went backwards" if hit && hit.index < position
+          return nil if hit.nil? && chain.truncated?
+
+          hits << hit
+          return decided(scope, chain, method_name, from, hits) if hit.nil? || !possible?(scope, hit, method_name)
+
+          position = hit.index + 1
+        end
+      end
+
+      # A class entry answering through a copy the extends fold made is asked past
+      # (`SingletonHookDecline.copy_kind`), so the module that wrote the `def` answers at its own position; a copy
+      # from a module the chain does not hold on that level is {STRAY}, a decline.
+      def past_fold_copies(scope, chain, method_name, hit, answer_in)
+        while hit
+          case SingletonHookDecline.copy_kind(scope, chain, method_name, hit)
+          when :copy then hit = answer_in.call(chain, hit.index + 1)
+          when :stray then return STRAY
+          else return hit
+          end
+        end
+        hit
+      end
+
+      def decided(scope, chain, method_name, from, hits)
+        external_may_answer?(scope, chain, method_name, from, hits.last) ? nil : hits
+      end
+
+      # An external entry ahead of the last candidate that RBS does not know, or knows and declares the name in,
+      # may be the definer Ruby calls; with no candidate, so may the implicit `Object` (`Kernel`, for the object
+      # that every class is). Both decline. Each tested external files the negative class edge on its spelling.
+      def external_may_answer?(scope, chain, method_name, from, last)
+        stop = last.nil? ? chain.entries.size : last.index
+        recording = Analysis::DependencyRecorder.active?
+        (from...stop).any? do |index|
+          entry = chain.entries[index]
+          next false unless entry.external?
+
+          Analysis::DependencyRecorder.read_missing(:class, entry.raw.to_s.split("::").last) if recording
+          !external_lacks?(scope, entry.candidates, entry.side, method_name)
+        end || (last.nil? && implicit_object_answers?(scope, chain, method_name))
+      end
+
+      # The implicit tail after a chain's last project superclass: `Object` (with `Kernel` and `BasicObject`) on the
+      # instance side, `#<Class:Object>` through `Class`, `Module` and `Kernel` on the singleton side.
+      def implicit_object_answers?(scope, chain, method_name)
+        !external_lacks?(scope, ["Object"], chain.side, method_name)
+      end
+
+      # True only for an ancestor RBS knows whose declaration lacks the name, on the side the entry stands for: an
+      # external superclass on a singleton chain (`:singleton`, its whole tail) is asked for a singleton method, an
+      # extended module (`:instance`) and every instance-side entry for an instance method.
+      def external_lacks?(scope, candidates, side, method_name)
+        return Scope::ResolutionChain::Relevance.external_lacks?(scope, candidates, method_name) if side == :instance
+
+        known = candidates.find { |candidate| Rigor::Reflection.rbs_class_known?(candidate, scope: scope) }
+        return false if known.nil?
+
+        Rigor::Reflection.singleton_method_definition(known, method_name, scope: scope).nil?
+      rescue StandardError
+        false
+      end
+
+      # What a candidate set says, for {Scope::ResolutionChain#settle} to compare across worlds.
+      def outcomes(hits)
+        return NONE if hits.nil?
+
+        hits.map { |hit| hit.nil? ? NONE : hit.answer }
+      end
+
+      def collapse(hits)
+        first = hits.first
+        return ABSENT if hits.all?(&:nil?)
+        return UNKNOWN if hits.any?(&:nil?) || hits.any? { |hit| hit.answer != first.answer }
+
+        Known.new(first.answer, first.owner)
+      end
+
+      # A definer that rests on a fact the walk could not prove executes: the member's `possible` sibling, or a
+      # contested slot of one of the single-valued members.
+      def possible?(scope, hit, method_name)
+        discovery = scope.discovery
+        owner = hit.owner
+        kind = hit.side == :singleton ? :singleton : :instance
+        nodes = kind == :singleton ? :discovered_singleton_def_nodes : :discovered_def_nodes
+        discovery.possible_method?(owner, method_name, kind) ||
+          discovery.contested?(nodes, [owner, method_name.to_sym]) ||
+          discovery.contested?(:discovered_method_visibilities, [owner, method_name.to_sym]) ||
+          discovery.contested?(:discovered_parameter_envelopes, [owner, [kind, method_name.to_sym]])
+      end
+
+      def default_answer(scope, method_name, question)
+        case question
+        when :definer then definer_answer(scope, method_name)
+        when :visibility then visibility_answer(scope, method_name)
+        else raise ArgumentError, "question #{question.inspect} needs an answer function"
+        end
+      end
+
+      # The first project entry with a `def` of the name, as `[def node, owner]`.
+      def definer_answer(scope, method_name)
+        lambda do |chain, from|
+          first_hit(chain, scope, from) do |entry|
+            node = if entry.side == :singleton
+                     scope.singleton_def_for(entry.name,
+                                             method_name)
+                   else
+                     scope.user_def_for(entry.name,
+                                        method_name)
+                   end
+            [node, entry.name] if node
+          end
+        end
+      end
+
+      # The first project entry that records the name (a discovered method, an instance `def` the def table
+      # holds, or a visibility change such as `private :foo` recorded for it), with its visibility (`:public` where
+      # none was stated).
+      def visibility_answer(scope, method_name)
+        lambda do |chain, from|
+          first_hit(chain, scope, from) do |entry|
+            kind = entry.side == :singleton ? :singleton : :instance
+            next unless scope.discovered_method?(entry.name, method_name, kind) ||
+                        (kind == :instance && (scope.user_def_for(entry.name, method_name) ||
+                                               scope.discovered_method_visibility(entry.name, method_name)))
+
+            scope.discovered_method_visibility(entry.name, method_name) || :public
+          end
+        end
+      end
+
+      def first_hit(chain, scope, from)
+        index = from - 1
+        found = nil
+        chain.search(scope, from) do |entry|
+          index += 1
+          next if entry.external?
+
+          answer = yield(entry)
+          next if answer.nil?
+
+          found = Hit.new(answer, entry.name, index, entry.side)
+        end
+        found
+      end
+
+      private_class_method :override_answer, :retro_position, :candidates, :past_fold_copies, :decided,
+                           :external_may_answer?, :implicit_object_answers?, :external_lacks?,
+                           :outcomes, :collapse, :possible?,
+                           :default_answer, :definer_answer, :visibility_answer, :first_hit
+    end
+  end
+end
+
+require_relative "singleton_hook_decline"

data/lib/rigor/inference/expression_typer.rb

@@ -2280,8 +2280,8 @@ module Rigor
       def try_user_method_inference(receiver, call_node, arg_types, method_name: call_node.name, block_type: nil)
         return nil unless user_inference_receiver?(receiver)
 
-        def_node, owner = resolve_user_def_with_owner(receiver.class_name, method_name)
-        return nil if def_node.nil?
+        def_node, owner, raising = resolve_typing_def_with_owner(receiver.class_name, method_name)
+        return every_definer_raises_type(raising, receiver, call_node, arg_types, block_type) if def_node.nil?
 
         result = infer_user_method_return(def_node, receiver, arg_types,
                                           self_fold_safe: fold_safe_call_receiver?(call_node, receiver),
@@ -2383,8 +2383,7 @@ module Rigor
         key = method_name.to_sym
         return table[key] if table.key?(key)
 
-        table[key] = scope.singleton_def_through_ancestors(class_name, method_name,
-                                                           name_memo: class_graph_buckets[:name])
+        table[key] = scope.singleton_def_through_ancestors(class_name, method_name)
       end
 
       # The project-side singleton-method band: a `Foo.bar` call resolved against a `class << …` / `def self.…`
@@ -2415,13 +2414,12 @@ module Rigor
         nil
       end
 
-      # ADR-24 slice 2 — resolves `method_name` against `class_name`'s own `def`s, then walks the user-class
-      # ancestor chain: included / prepended modules (transitive) and the superclass chain. RBS-known
-      # ancestors are NOT walked here — the `MethodDispatcher` RBS tier runs before
-      # `try_user_method_inference` and already covers them; an ancestor name that resolves to no
-      # project-discovered class/module ends that branch. Cross-file: the chain is followed through
-      # `Scope#discovered_superclasses` / `#discovered_includes` / `#discovered_def_nodes`, which the runner
-      # seeds from the project-wide pre-pass. The walk is breadth-first, cycle-guarded, and node-count-capped.
+      # ADR-24 slice 2 — resolves `method_name` against the project definers on `class_name`'s
+      # {Scope::ResolutionChain}, in Ruby's order: prepended modules, the class, its included modules, then the
+      # superclass's chain likewise. RBS-known ancestors are NOT answered here — the `MethodDispatcher` RBS
+      # tier runs before `try_user_method_inference` and already covers them; they sit on the chain as
+      # 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__
       private_constant :CLASS_GRAPH_CACHE_KEY
@@ -2464,13 +2462,114 @@ module Rigor
           # is a pure function of the same frozen index — the sibling resolver it walks reads nothing else.
           # `singleton_def` is added lazily by {#singleton_def_through_ancestors}'s caller.
           slot = [discovery,
-                  { name: {}, user_def: {}, self_pure: {}.compare_by_identity,
-                    yields: {}.compare_by_identity }]
+                  { user_def: {}, typing_def: {}, self_pure: {}.compare_by_identity, yields: {}.compare_by_identity }]
           Thread.current[CLASS_GRAPH_CACHE_KEY] = slot
         end
         slot[1]
       end
 
+      # ADR-119 C2-b1 — the TYPING read of {#resolve_user_def_with_owner}: the same `[def_node, owner]` pair, but
+      # answered through {DefinerResolution} so a chain that does not stand for the name (a conditional definer,
+      # a conditional include, a fork, an external ancestor that may answer first) is `[nil, nil]` and the call
+      # types `Dynamic` instead of from a definer Ruby may not reach. ABSENT is the same `[nil, nil]`: at a typing
+      # site "no definer" and "cannot say" both fall through to `dispatch_miss_result`. Existence reads
+      # ({#resolve_user_def_through_ancestors}, the self-purity scan) stay on the union memo above: an existence
+      # read turning false there could ADD a `call.undefined-method` firing.
+      #
+      # UNKNOWN carries a third element, the `bot` exception's definers ({#every_project_definer}): the def nodes
+      # of every project entry on the chain that defines the name, or nil where the exception cannot apply.
+      def resolve_typing_def_with_owner(class_name, method_name)
+        cache = class_graph_buckets[:typing_def]
+        table = (cache[class_name.to_s] ||= {})
+        key = method_name.to_sym
+        return table[key] if table.key?(key)
+
+        table[key] =
+          case DefinerResolution.resolve(scope, class_name, method_name, :instance, question: :definer)
+          in DefinerResolution::Known(answer: [node, owner])
+            [node, owner]
+          in DefinerResolution::UNKNOWN
+            [nil, nil, every_project_definer(class_name, method_name)]
+          in DefinerResolution::ABSENT
+            [nil, nil]
+          end
+      end
+
+      # ADR-119 C2-b1 errata (the `bot` exception) — an UNKNOWN chain does not say WHICH definer Ruby calls, but
+      # when every project definer of the name on the chain types `bot` (each raises or exits), the call cannot
+      # return whichever of them runs, so it types `bot` and a guard such as `fail_with 'no' unless count` still
+      # narrows. `defs` is {#every_project_definer}'s list; each is inferred with this call's receiver and
+      # arguments, stopping at the first that returns (the answer is then `Dynamic` whatever the rest say).
+      # Accepted cost: an RBS-unknown external ahead of them that really defines the name and returns is a
+      # narrowing false negative; `bot` reports nothing about a value, and that exposure is master's.
+      def every_definer_raises_type(defs, receiver, call_node, arg_types, block_type)
+        return nil if defs.nil?
+
+        self_fold_safe = fold_safe_call_receiver?(call_node, receiver)
+        defs.each do |def_node|
+          result = infer_user_method_return(def_node, receiver, arg_types,
+                                            self_fold_safe: self_fold_safe, yield_type: block_type)
+          return nil unless result.is_a?(Type::Bot)
+        end
+        Type::Combinator.bot
+      end
+
+      # The def node of every project entry on `class_name`'s instance chain that defines `method_name`, in any
+      # position (the order is what UNKNOWN does not know), or nil where the `bot` exception cannot apply: a cut
+      # chain, no project definer, an entry whose only record of the name has no body (an `attr_*` or a
+      # `define_method` with no `def`), a definer resting on a `possible` or contested fact (another body may be the
+      # one Ruby holds), or an external RBS knows that declares the name. An external RBS does not know is passed
+      # over. Only what the tables hold is read: a `define_method` beside an entry's own `def` of the name, and a
+      # receiver-form `X.include(M)` outside `X`'s body, are not seen (as on the Known path).
+      #
+      # ADR-46: the answer depends on every entry, so each files its class edge and its negative class edge (a new
+      # file reopening it may add a definer or a mixin), and each project entry's {Scope#user_def_for} files the
+      # method edge, positive for a definer and `read_missing(:method, "Owner#name")` for one that lacks the
+      # `def`. `DefinerResolution`'s decline filed none of this past the external that stopped it.
+      def every_project_definer(class_name, method_name)
+        chain = Scope::ResolutionChain.for(scope, class_name.to_s, :instance, :methods)
+        chain.record(scope)
+        return nil if chain.truncated?
+
+        defs = []
+        declined = false
+        chain.entries.uniq.each do |entry|
+          if entry.external?
+            note_missing_class(entry.raw.to_s.split("::").last)
+            declined = true if external_declares?(entry.candidates, method_name)
+            next
+          end
+          note_missing_class(entry.last_segment)
+          node = scope.user_def_for(entry.name, method_name)
+          defs << node if node
+          declined = true if definer_without_single_body?(entry.name, method_name, node)
+        end
+        declined || defs.empty? ? nil : defs.freeze
+      end
+
+      def note_missing_class(segment)
+        Analysis::DependencyRecorder.read_missing(:class, segment) if Analysis::DependencyRecorder.active?
+      end
+
+      def definer_without_single_body?(owner, method_name, node)
+        discovery = scope.discovery
+        key = [owner, method_name.to_sym]
+        (node.nil? && scope.discovered_method?(owner, method_name, :instance)) ||
+          discovery.possible_method?(owner, method_name, :instance) ||
+          discovery.contested?(:discovered_def_nodes, key)
+      end
+
+      # True where RBS knows one of the names the external's spelling can denote and declares the instance method
+      # in it; a lookup that fails counts as declaring (the exception then does not apply).
+      def external_declares?(candidates, method_name)
+        known = candidates.find { |candidate| Rigor::Reflection.rbs_class_known?(candidate, scope: scope) }
+        return false if known.nil?
+
+        !Rigor::Reflection.instance_method_definition(known, method_name, scope: scope).nil?
+      rescue StandardError
+        true
+      end
+
       def resolve_user_def_through_ancestors(class_name, method_name)
         resolve_user_def_with_owner(class_name, method_name).first
       end
@@ -2493,11 +2592,10 @@ module Rigor
       # nothing but the frozen discovery index, and the `.with` guard in
       # {MethodDispatcher::StructMaterialization} needs the SAME answer without threading dispatcher state
       # through the dispatcher (#598 review). What stays here is the caching: the run-scoped
-      # `(class_name, method_name)` memo above, plus the per-edge name bucket handed to the walk so a class
-      # whose many methods are resolved pays each ancestor edge once.
+      # `(class_name, method_name)` memo above. The chain itself is memoised per class by
+      # {Scope::ResolutionChain}, so a class whose many methods are resolved builds it once.
       def compute_user_def_with_owner(class_name, method_name)
-        scope.user_def_through_ancestors(class_name, method_name,
-                                         name_memo: class_graph_buckets[:name])
+        scope.user_def_through_ancestors(class_name, method_name)
       end
 
       # ADR-57 N5 — overridable-method adoption gate. A self-call resolved to a project `def` whose owner has
@@ -2671,34 +2769,14 @@ module Rigor
         index
       end
 
-      # True when `candidate`'s transitive ancestor chain (superclasses + included/prepended modules) reaches
-      # `owner` — i.e. `candidate` is a subclass of an owner class or an includer of an owner module. Reuses
-      # the same BFS resolver the method-resolution ancestor walk uses, so name resolution (lexical nesting,
-      # RBS-known-ancestor pruning) is identical.
-      # Delegates to the shared walk's edge step so this BFS and method resolution resolve ancestor names
-      # identically, sharing the per-edge memo bucket.
-      def enqueue_ancestors(current, queue)
-        scope.enqueue_ancestors(current, queue, class_graph_buckets[:name])
-      end
-
+      # True when `candidate`'s ancestor chain (superclasses + included/prepended modules) reaches `owner` —
+      # i.e. `candidate` is a subclass of an owner class or an includer of an owner module. Asked of the same
+      # {Scope::ResolutionChain} method resolution reads, so name resolution (lexical nesting, RBS-known-ancestor
+      # pruning) is identical; a chain cut at the budget that does not reach `owner` answers false, as the walk
+      # it replaced did. Reachability is the same in both of the chain's worlds.
       def related_to_owner?(candidate, owner)
-        queue = []
-        enqueue_ancestors(candidate, queue)
-        seen = {}
-        visited = 0
-        until queue.empty?
-          current = queue.shift
-          next if current.nil? || seen[current]
-
-          return true if current == owner
-
-          seen[current] = true
-          visited += 1
-          return false if visited > Scope::ANCESTOR_WALK_LIMIT
-
-          enqueue_ancestors(current, queue)
-        end
-        false
+        chain = Scope::ResolutionChain.for(scope, candidate.to_s, :instance, :methods)
+        !chain.search(scope) { |entry| entry.name == owner }.nil?
       end
 
       INFERENCE_GUARD_KEY = :__rigor_user_method_inference_stack__
@@ -3860,15 +3938,28 @@ module Rigor
       # Both are precision-only. A `...` outside a forwarding frame (unreachable in valid Ruby) and a double
       # splat of anything but a Symbol-keyed closed `HashShape` — a shapeless `Hash[Symbol, V]`, an opaque
       # value, a mixed hash — fall back to exactly the pre-#1125 answer.
+      #
+      # Only a list holding a `...` takes the flat_map. Every call is typed through here, and the flat_map's
+      # one-element Array per argument cost `rigor check` about 315K allocations over the v0.3.9 `lib`
+      # ([#1503](https://github.com/rigortype/rigor/issues/1503)).
       def call_arg_types(node)
         arguments_node = node.arguments
         return [] if arguments_node.nil?
 
-        arguments_node.arguments.flat_map do |argument|
+        arguments = arguments_node.arguments
+        return arguments.map { |argument| call_arg_type(argument) } unless forwards_arguments?(arguments)
+
+        arguments.flat_map do |argument|
           forwarded_argument_types(argument) || [call_arg_type(argument)]
         end
       end
 
+      # Whether a call's argument list holds `...`. Ruby accepts it only last; the scan checks every argument
+      # rather than rely on that.
+      def forwards_arguments?(arguments)
+        arguments.any?(Prism::ForwardingArgumentsNode)
+      end
+
       # The frame's argument list when `argument` is `...`, else nil so the caller types it normally.
       def forwarded_argument_types(argument)
         return nil unless argument.is_a?(Prism::ForwardingArgumentsNode)

data/lib/rigor/inference/external_ancestor_resolution.rb

@@ -30,10 +30,11 @@ module Rigor
     #
     # 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
-    # than the walk reads — `Scope#resolve_ancestor_class_name` consults `discovered_def_nodes` and
-    # `discovered_methods` through `known_user_class?`, and `ancestor_name_candidates` reads
-    # `discovered_header_nestings`. The slice that brings the hot path brings the memo, keyed on what
-    # that consumer actually reads.
+    # 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.
     module ExternalAncestorResolution
       # The owner a name must PRECEDE for its declaration to win an MRO. See {declared_before_object?}.
       OBJECT_OWNER = "Object"
@@ -67,13 +68,12 @@ module Rigor
       # `include Enumerable` so that slice 2's measurement stays its own, and the narrowing belongs to
       # the CALLER rather than to this module: the implicit-self veto must keep walking both edges,
       # because Ruby reaches an included module's methods too.
-      # rubocop:disable-next Metrics/ParameterLists
-      def resolve(class_name, method_name, kind = :instance, scope:, environment: nil, name_memo: nil,
-                  record_dependencies: true, mixins: true)
+      def resolve(class_name, method_name, kind = :instance, scope:, environment: nil, record_dependencies: true,
+                  mixins: true)
         return nil if class_name.nil? || scope.nil?
         return nil unless kind == :instance
 
-        compute(class_name, method_name, scope, environment, name_memo, record_dependencies, mixins)
+        compute(class_name, method_name, scope, environment, record_dependencies, mixins)
       end
 
       # The RBS method definition for `class_name`, or nil for a class the environment does not know, a
@@ -133,7 +133,7 @@ module Rigor
         []
       end
 
-      def compute(class_name, method_name, scope, environment, name_memo, record_dependencies, mixins)
+      def compute(class_name, method_name, scope, environment, record_dependencies, mixins)
         kind = :instance
         own = method_definition(class_name, method_name, kind, scope: scope, environment: environment)
         if own
@@ -144,7 +144,7 @@ module Rigor
           end
         end
 
-        groups = ancestor_candidate_groups(scope, class_name, name_memo, record_dependencies, mixins)
+        groups = ancestor_candidate_groups(scope, class_name, record_dependencies, mixins)
         farther_ancestors = {}
         groups.each_with_index do |candidates, index|
           answer = first_known_candidate_answer(candidates, method_name, kind, scope, environment)
@@ -244,14 +244,11 @@ module Rigor
       # The walk, with its ADR-46 reads attached or detached. `withhold` returns `[result, read_set]`
       # and the read set is dropped: a caller that suppresses is saying these reads are not a dependency
       # of its answer, not that they should be replayed somewhere else.
-      def ancestor_candidate_groups(scope, class_name, name_memo, record_dependencies, mixins)
-        memo = name_memo || {}
-        if record_dependencies
-          return scope.external_ancestor_name_candidates(class_name, name_memo: memo, mixins: mixins)
-        end
+      def ancestor_candidate_groups(scope, class_name, record_dependencies, mixins)
+        return scope.external_ancestor_name_candidates(class_name, mixins: mixins) if record_dependencies
 
         Analysis::DependencyRecorder.withhold do
-          scope.external_ancestor_name_candidates(class_name, name_memo: memo, mixins: mixins)
+          scope.external_ancestor_name_candidates(class_name, mixins: mixins)
         end.first
       end
       private_class_method :ancestor_candidate_groups