rigortype 0.4.0 → 0.4.1

data/lib/rigor/analysis/check_rules/source_arity.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../../reflection"
+require_relative "../../inference/definer_resolution"
 require_relative "../../source/parameter_envelope"
 
 module Rigor
@@ -14,9 +15,10 @@ module Rigor
       # Asked in two stages, because every condition past the first can only WITHHOLD a firing:
       #
       # 1. {#owner_envelope} walks the receiver's superclass chain to the first class whose own body, or one of
-      #    whose project mixins, records the name. Every record at that level must agree — `include` and
-      #    `prepend` share one table, so a mixin's definition may shadow the class's own — and none may be
-      #    opaque. A call that fits this envelope is silent, and nothing below is consulted.
+      #    whose project mixins, records the name. Every record at that level must agree — deliberately wider
+      #    than Ruby's order, so a mixin whose definition may shadow the class's own, or a load-order-dependent
+      #    pair (#986), declines instead of answering — and none may be opaque. A call that fits this envelope
+      #    is silent, and nothing below is consulted.
       # 2. {#authoritative?} runs only for a call that would fire. It declines when a `method_missing` /
       #    `respond_to_missing?` hook or a dynamic-surface mark sits anywhere in the chain; when a mixin the
       #    project does not declare is not a known RBS module that lacks the name; when a `pre_eval:` patch or
@@ -24,20 +26,45 @@ module Rigor
       #    project subclass of the receiver — whose instances the receiver's type admits — records a different
       #    or opaque envelope for it.
       #
+      # ADR-119 C1b / C2-c — on both sides stage 1 and the subclass check ask `Inference::DefinerResolution`, and a
+      # chain it declines (`UNKNOWN`) answers no envelope: where Ruby's order depends on a fact the tables cannot
+      # prove, the rule is silent instead of checking the call against master's order (#1570, #1607).
+      #
       # Deliberately NOT in scope: a constructor reached through `Class#new` (nothing records `initialize` as
       # `[:singleton, :new]`, so `.new` finds no owner unless the class writes `def self.new` itself); keyword
       # arity (the envelope's required-keyword flag declines, as `compute_arity_envelope` declines an RBS
       # function with required keywords); and a `class_eval` whose receiver is not a constant, which the
       # discovery walk cannot name.
-      class SourceArity
+      class SourceArity # rubocop:disable Metrics/ClassLength
         MISSING_HOOKS = %i[method_missing respond_to_missing?].freeze
         private_constant :MISSING_HOOKS
 
         # One class on the walk: its own name, the project modules its mixins resolve to (transitively through
         # their own `include`s), and the candidate-name lists of the mixins that resolve to no project module.
+        #
+        # Issue #1570 — the level is a SEGMENT of the receiver's `Scope::ResolutionChain` (`:arity` flavor): the
+        # class with the modules Ruby inserts around it before the superclass's entries begin. Ruby skips an
+        # `include` of a module the superclass chain already carries, so `class C < Base; include M` where
+        # `Base` includes `M` leaves `M` at `Base`'s level; collecting every module a class's own `include`s
+        # name put it at `C`'s level instead, where its `def` answered a call `Base#foo` receives.
         Level = Data.define(:class_name, :modules, :externals)
         private_constant :Level
 
+        # ADR-119 C1b — the answer of a level whose records are not one non-opaque envelope. It equals itself in
+        # every world, so two worlds that both reach such a level agree, and no envelope equals it.
+        AMBIGUOUS = Object.new.freeze
+        private_constant :AMBIGUOUS
+
+        # What `Inference::DefinerResolution` reads off a candidate: the answer, the entry that gave it, its
+        # position on the chain and its side. The same four readers as `DefinerResolution::Hit`, which a call site
+        # may not name (the case/in contract spec allows no other reference to the module).
+        ArityHit = Data.define(:answer, :owner, :index, :side)
+        private_constant :ArityHit
+
+        # A subclass level the walk cannot read: `subclasses_agree?` reads the nil as a decline.
+        NO_LEVELS = [nil].freeze
+        private_constant :NO_LEVELS
+
         def initialize(scope, method_name, kind)
           @scope = scope
           @method_name = method_name.to_sym
@@ -53,6 +80,7 @@ module Rigor
         def owner_envelope(class_name)
           @owner_entries = []
           @ambiguous = false
+          @unknown = false
           envelope, @withheld = Analysis::DependencyRecorder.withhold { walk_to_owner(class_name) }
           envelope
         end
@@ -67,6 +95,11 @@ module Rigor
         # withhold, so none of these needs the file-level class edge the bucket reads would otherwise record.
         def settle_by_definitions
           return if @withheld.nil?
+          # ADR-119 C1b — a declined chain (`@unknown`) that some level records the name on is silent only until
+          # another file's edit lifts the decline, so its verdict depends on everything the walk read, as an opaque
+          # level's does. A decline over a name no project level records is not `@unknown` (see
+          # {#decline_unless_recorded_nowhere}): it settles by definitions, as an `ABSENT` read does.
+          return settle_by_walk if @unknown
 
           @owner_entries.each do |name, kind|
             if kind == :singleton
@@ -95,20 +128,88 @@ module Rigor
 
         private
 
+        # ADR-119 C1b / C2-c, #1570 / #1607 — the nearest level is asked of {Inference::DefinerResolution}, on the
+        # receiver's own side: the chain stands only where every candidate level gives one envelope in every
+        # world Ruby may have run (a fork, an unproven mixin order, a `possible`-only definer, and on the
+        # singleton side a hook that could have put a definer ahead). Where it does not, the answer is NO
+        # envelope and `@unknown` — the rule stays silent — instead of master's order, which is what #1570 and
+        # #1607 fired on. The levels the walk keeps for {#authoritative?} are the chain's.
         def walk_to_owner(class_name)
           @levels = []
           @passed = []
-          walked_whole_chain?(class_name) do |current|
-            level = level_for(current)
+          @recorded = false
+
+          case Inference::DefinerResolution.resolve(@scope, class_name, @method_name, side,
+                                                    question: :arity) { |chain, from| arity_hit(chain, from) }
+          in Inference::DefinerResolution::Known(answer: _answer, owner: _owner) then nearest_envelope(class_name)
+          in Inference::DefinerResolution::ABSENT then nearest_envelope(class_name) # rubocop:disable Lint/DuplicateBranch
+          in Inference::DefinerResolution::UNKNOWN then decline_unless_recorded_nowhere(class_name)
+          end
+        end
+
+        # A declined read of a name no project level records (`arity_hit` found no level that does, in any world it
+        # was asked) answers no envelope whether or not it stands, so the walk's reads are not the verdict's
+        # dependency: only a `def` appearing can change it, which {#settle_by_definitions} files, as for an
+        # `ABSENT` read. It can leave a stale false negative in a warm run, never a firing. Without this, every
+        # `Widget.new` (the implicit `Class` tail may answer it) would replay the whole walk as a file-level
+        # class edge.
+        def decline_unless_recorded_nowhere(class_name)
+          nowhere = !@recorded && !arity_chain(class_name).truncated?
+          nowhere ? nearest_envelope(class_name) : decline
+        end
+
+        # The chain's nearest level's envelope. `Known#answer` is that envelope, but {#authoritative?} and
+        # {#settle_by_definitions} also read the levels, passed names and owner entries this walk fills, so the
+        # answer is not used on its own. Run only once the candidate-set read has answered, so the chain stands
+        # for the name.
+        def nearest_envelope(class_name) = owner_in(chain_levels(arity_chain(class_name)).first)
+
+        def decline
+          @levels = []
+          @passed = []
+          @owner_entries = []
+          @envelope = nil
+          @unknown = true
+          nil
+        end
+
+        # The first level at or after entry position `from` whose records name the method: its envelope (or
+        # {AMBIGUOUS}), the entry that recorded it and that entry's position and side on the chain. On the
+        # singleton side the class's own record is a `:singleton` entry and an extended module's an `:instance`
+        # one (`owner_entries` names the kind of each).
+        def arity_hit(chain, from)
+          start = 0
+          chain.levels.each_with_index do |raw, index|
+            level = Level.new(*raw)
+            entries = chain.level_entries(index)
+            first = start
+            start += entries.size
+            next if first < from
+
+            found = level_envelopes(level)
+            next if found.empty?
+
+            envelope = found.first
+            answer = found.all?(envelope) && !Source::ParameterEnvelope.opaque?(envelope) ? envelope : AMBIGUOUS
+            owner, owner_kind = owner_entries(level).first
+            position = first + (entries.index { |entry| entry.name == owner && entry.side == owner_kind } || 0)
+            @recorded = true
+            return ArityHit.new(answer, owner, position, owner_kind)
+          end
+          nil
+        end
+
+        def owner_in(levels)
+          levels.each do |level|
             @levels << level
             found = level_envelopes(level)
             if found.empty?
-              @passed.concat([current] + level.modules)
+              @passed.concat([level.class_name] + level.modules)
               next
             end
 
             envelope = found.first
-            @owner_entries = owner_entries(level)
+            @owner_entries |= owner_entries(level)
             unless found.all?(envelope) && !Source::ParameterEnvelope.opaque?(envelope)
               @ambiguous = true
               return nil
@@ -155,56 +256,30 @@ module Rigor
           @scope.discovered_classes.key?(name) || Rigor::Reflection.rbs_class_known?(name, scope: @scope)
         end
 
-        # False when the walk stopped at the ADR-41 budget rather than at the top of the chain: budget
-        # exhaustion is uncertainty, and every caller reads it as a reason to decline.
-        def walked_whole_chain?(class_name)
-          current = class_name.to_s
-          seen = {}
-          while current && !seen[current]
-            return false if seen.size >= Scope::ANCESTOR_WALK_LIMIT
-
-            seen[current] = true
-            yield current
-            current = resolve(current, @scope.superclass_of(current))
-          end
-          true
+        # Yields each level of `class_name`'s chain. False when the walk stopped at the ADR-41 budget rather than
+        # ending: budget exhaustion is uncertainty, and every caller reads it as a reason to decline.
+        def walked_whole_chain?(class_name, &)
+          levels, whole = chain_levels(arity_chain(class_name))
+          levels.each(&)
+          whole
         end
 
-        def level_for(class_name)
-          modules = []
-          externals = []
-          collect_mixins(class_name, own_mixins(class_name), modules, externals, {})
-          Level.new(class_name: class_name, modules: modules, externals: externals)
-        end
+        # `[levels, whole]` for one world of the chain, up to the first superclass the project does not declare.
+        def chain_levels(chain) = [chain.levels.map { |level| Level.new(*level) }, !chain.truncated?]
 
-        # Instance methods reach a receiver through `include` / `prepend`; class methods through `extend`, and
-        # an extended module's own `include`s reach the same singleton.
-        def own_mixins(class_name)
-          @kind == :singleton ? (@scope.discovered_extends[class_name] || []) : @scope.includes_of(class_name)
-        end
+        def side = @kind == :singleton ? :singleton : :instance
 
-        # Issue #986 — a name the compact-header rename collision left ambiguous resolves to no ONE class,
-        # but BOTH classes it names are ancestors at runtime; only their MRO order is unknowable. Taking
-        # both as levels is what keeps this rule alive for the rest of the receiver: a method only one of
-        # them declares still has one envelope and still fires, a method they disagree about lands two on
-        # `#envelope_for`'s join and declines there, and the class's own `def`s, its superclass's and its
-        # unambiguous mixins are untouched. Letting the decline arrive as an unknown EXTERNAL mixin instead
-        # suppressed the rule for every level of the receiver.
-        def collect_mixins(owner, raw_names, modules, externals, seen)
-          raw_names.each do |raw|
-            resolved = resolve(owner, raw)
-            names = resolved ? [resolved] : @scope.ambiguous_ancestor_resolutions(owner, raw)
-            next externals << @scope.ancestor_name_candidates(owner, raw) if names.empty?
-
-            names.each do |name|
-              next if seen[name]
-
-              seen[name] = true
-              modules << name
-              collect_mixins(name, @scope.includes_of(name), modules, externals, seen)
-            end
-          end
-        end
+        # Instance methods reach a receiver through `include` / `prepend`; class methods through `extend`, and
+        # an extended module's own `include`s reach the same singleton — the chain's singleton side.
+        #
+        # Issue #986 — the `:arity` flavor expands a name the compact-header rename collision left ambiguous
+        # to BOTH classes it names: both are ancestors at runtime and only their MRO order is unknowable. Taking
+        # both into the level is what keeps this rule alive for the rest of the receiver: a method only one of
+        # them declares still has one envelope and still fires, a method they disagree about lands two on the
+        # level's join and declines there, and the class's own `def`s, its superclass's and its unambiguous
+        # mixins are untouched. Letting the decline arrive as an unknown EXTERNAL mixin instead suppressed the
+        # rule for every level of the receiver.
+        def arity_chain(class_name) = Scope::ResolutionChain.for(@scope, class_name.to_s, side, :arity)
 
         def resolve(owner, raw)
           return nil if raw.nil?
@@ -273,8 +348,8 @@ module Rigor
         # A hook anywhere in the chain, including above the owner, and on either side: a class that answers
         # names it does not define is a class whose `def`s are not the whole story of what a call reaches.
         def chain_free_of_hooks?(class_name)
-          walked_whole_chain?(class_name) do |current|
-            ([current] + level_for(current).modules).each do |name|
+          walked_whole_chain?(class_name) do |level|
+            ([level.class_name] + level.modules).each do |name|
               envelopes = @scope.parameter_envelopes_of(name)
               return false if dynamic_surface?(name)
               return false if MISSING_HOOKS.any? { |hook| hook_recorded?(envelopes, hook) }
@@ -290,13 +365,42 @@ module Rigor
         # receiver may be any of them, and each one's own definition of the name is what runs for it.
         def subclasses_agree?(class_name, envelope)
           each_subclass(class_name) do |subclass|
-            level = level_for(subclass)
-            return false unless clean_level?(level)
-            return false unless level_envelopes(level).all?(envelope)
+            subclass_levels(subclass).each do |level|
+              # A subclass whose own level the budget cut cannot be read, which is a reason to decline.
+              return false if level.nil?
+              return false unless clean_level?(level)
+              return false unless level_envelopes(level).all?(envelope)
+            end
           end
           true
         end
 
+        # A subclass's own level (nil where the budget cut it or the chain does not stand for the name). It asks
+        # {Inference::DefinerResolution} on the receiver's side (ADR-119 C1b, C2-c): the subclass's own level
+        # answers, and a fork, an unproven mixin order, a `possible`-only definer or a hook there is `UNKNOWN`,
+        # which `subclasses_agree?` reads as a reason to decline.
+        def subclass_levels(subclass)
+          case Inference::DefinerResolution.resolve(@scope, subclass, @method_name, side, question: :arity,
+                                                    &own_level_answer(subclass))
+          in Inference::DefinerResolution::Known(answer: _answer, owner: _owner) then [first_level(subclass)]
+          in Inference::DefinerResolution::ABSENT then [nil]
+          in Inference::DefinerResolution::UNKNOWN then NO_LEVELS
+          end
+        end
+
+        # The subclass's own level, always a candidate (an empty answer where it records nothing), so that the
+        # read asks whether the chain stands for the subclass and never whether an ancestor defines the name.
+        def own_level_answer(subclass)
+          lambda do |chain, from|
+            next nil unless from.zero? && !chain.levels.empty?
+
+            level = Level.new(*chain.levels.first)
+            ArityHit.new(level_envelopes(level).uniq, subclass, 0, side)
+          end
+        end
+
+        def first_level(class_name) = chain_levels(arity_chain(class_name)).first.first
+
         def each_subclass(class_name)
           children = children_by_parent
           queue = children.fetch(class_name.to_s, []).dup

data/lib/rigor/analysis/check_rules.rb

@@ -6,6 +6,7 @@ require_relative "../reflection"
 require_relative "../source/node_walker"
 require_relative "../source/constant_path"
 require_relative "../inference/singleton_object_constant"
+require_relative "shadow_harness"
 require_relative "../type"
 require_relative "diagnostic"
 require_relative "dependency_recorder"
@@ -60,10 +61,9 @@ module Rigor
       # ADR-87 WD4 — the canonical rule-id table lives in the light `check_rules/rule_ids.rb` (required at the
       # top of this file) so {Analysis::RuleCatalog} can read it without loading the engine.
 
-      # ADR-35 slice 1 — bound for the `def.override-visibility-reduced`
-      # ancestor walk, and the public > protected > private ordering
-      # used to decide whether an override reduces visibility.
-      OVERRIDE_ANCESTOR_WALK_LIMIT = 100
+      # ADR-35 slice 1 — the public > protected > private ordering used to decide whether an override reduces
+      # visibility. The override rules' ancestor walk is bounded by `Scope::ANCESTOR_WALK_LIMIT`, the
+      # resolution chain's.
       VISIBILITY_RANK = { public: 2, protected: 1, private: 0 }.freeze
 
       # Resolves a user-supplied rule token (`undefined-method`,
@@ -216,7 +216,7 @@ module Rigor
       def run_node_collectors(path, root, scope_index)
         collectors = build_node_collectors(path, scope_index, root)
         RuleWalk.run(root, collectors.values)
-        shadow_verify_node_collectors(path, root, scope_index, collectors) if ENV["RIGOR_SHADOW_RULE_WALK"]
+        shadow_verify_node_collectors(path, root, scope_index, collectors) if ShadowHarness.enabled?
         collectors
       end
 
@@ -2631,6 +2631,9 @@ module Rigor
         #   `Prism::SelfNode` are also skipped — Ruby 2.7+ permits `self.foo` for private methods.
         # - Receiver MUST resolve to a `Type::Nominal` so the rule has a single class identity to query.
         #   Unions / Dynamic / shape carriers are skipped.
+        # - Issue #1568 — a module the class PREPENDS sits ahead of it in Ruby's order, so a definition there
+        #   is what the call reaches; the class's own private `def` answers only when nothing prepended
+        #   defines the name ({#reached_definer_visibility}).
         def visibility_mismatch_diagnostic(path, call_node, scope_index)
           return nil unless explicit_non_self_receiver?(call_node.receiver)
 
@@ -2647,9 +2650,33 @@ module Rigor
           visibility = scope.discovered_method_visibility(receiver_type.class_name, call_node.name)
           return nil unless visibility == :private
 
+          reached = reached_definer_visibility(scope, receiver_type.class_name, call_node.name)
+          return nil if reached == :undecided
+          return nil unless reached.nil? || reached == :private
+
           build_visibility_mismatch_diagnostic(path, call_node, receiver_type)
         end
 
+        # Issue #1568, ADR-119 C1c — the recorded visibility of the definition a call on `class_name` reaches: the
+        # first project entry on the class's {Scope::ResolutionChain} from its head that records the name, so a
+        # module the class PREPENDS answers ahead of the class. `Inference::DefinerResolution` reads it with the
+        # `:visibility` question's default answer. It is `:undecided` wherever the chain does not settle the order
+        # (an unpositioned or forked mixin, a conditional include) or an ancestor ahead of the definer may define
+        # the name (one RBS does not know), and the caller declines; a definer whose visibility slot ADR-119's
+        # producers contest is not alone (`DefinerResolution` asks the next candidate too), so it is `:undecided`
+        # there without a read of the table here. nil is nothing recording the name at all, and the class's own
+        # visibility stands. An ancestor the project does not declare is passed over, as the method lookup passes it.
+        def reached_definer_visibility(scope, class_name, method_name)
+          case Inference::DefinerResolution.resolve(scope, class_name, method_name, :instance, question: :visibility)
+          in Inference::DefinerResolution::Known(answer:)
+            answer
+          in Inference::DefinerResolution::UNKNOWN
+            :undecided
+          in Inference::DefinerResolution::ABSENT
+            nil
+          end
+        end
+
         def explicit_non_self_receiver?(receiver)
           return false if receiver.nil?
           return false if receiver.is_a?(Prism::SelfNode)
@@ -3609,8 +3636,11 @@ module Rigor
           self_type = scope.self_type
           return nil unless self_type.respond_to?(:class_name)
 
+          side = def_node.receiver.nil? ? receiverless_def_side(scope, self_type.class_name, def_node) : :singleton
+          return nil if side.nil?
+
           method_def =
-            if def_node.receiver.nil? && !singleton_context_def?(scope, self_type.class_name, def_node.name)
+            if side == :instance
               Reflection.instance_method_definition(self_type.class_name, def_node.name, scope: scope)
             else
               Reflection.singleton_method_definition(self_type.class_name, def_node.name, scope: scope)
@@ -3624,14 +3654,26 @@ module Rigor
           declared_return_union(method_def, scope.environment)
         end
 
-        # A receiverless `def` inside `class << self` is a singleton def; the def NODE alone cannot say
-        # so, but the discovery walk recorded it under the singleton kind (and not the instance kind).
-        # Without this, `class << self; def load` compared its body against `Kernel#load: -> bool` — the
-        # inherited INSTANCE method — instead of its own `def self.load` signature. A name defined on
-        # both facets stays on the instance lookup (the pre-existing conservative reading).
-        def singleton_context_def?(scope, class_name, method_name)
-          scope.discovered_method?(class_name, method_name, :singleton) &&
-            !scope.discovered_method?(class_name, method_name, :instance)
+        # Which side a receiverless `def` defines, from the indexer's own record of THAT node: the instance table
+        # holding it makes it an instance def, the singleton table (`class << self` bodies, and a `def` under
+        # `Const.instance_eval` that the indexer attributes to the singleton) a singleton def. A node neither table
+        # holds (a `def` in a block whose `self` the engine does not model, such as `E.class_eval do` inside
+        # `class << self`, a redefinition a later `def` replaced) or both do is `nil`, and the caller declines: no
+        # world is consulted, but the record cannot say which signature the body answers to.
+        def receiverless_def_side(scope, class_name, def_node)
+          instance = same_def_node?(scope.user_def_for(class_name, def_node.name), def_node)
+          singleton = same_def_node?(scope.singleton_def_for(class_name, def_node.name), def_node)
+          return :instance if instance && !singleton
+          return :singleton if singleton && !instance
+
+          nil
+        end
+
+        # The tables hold the live node or one re-resolved from a `DefHandle`, so identity is the name and span.
+        def same_def_node?(recorded, def_node)
+          recorded.is_a?(Prism::DefNode) && recorded.name == def_node.name &&
+            recorded.location.start_offset == def_node.location.start_offset &&
+            recorded.location.end_offset == def_node.location.end_offset
         end
 
         # `type_vars:` — ADR-35 WD9 tier 1. When the caller supplies a generic-instantiation
@@ -3739,82 +3781,57 @@ module Rigor
           override_rank < parent_rank
         end
 
-        # Breadth-first walk of the project-discovered ancestor chain (included / prepended modules first,
-        # then the superclass — Ruby's MRO ordering), yielding each resolved ancestor class name
-        # nearest-first. Returns the first truthy value the block produces, or nil. Cross-file: the chain
-        # is followed through the scope tables the runner seeds from the project pre-pass (ADR-24 WD1).
-        # Cycle-guarded and node-count-capped. Mirrors `ExpressionTyper#resolve_user_def_through_ancestors`.
-        def each_project_ancestor(scope, class_name)
-          queue = ancestor_class_names(scope, class_name)
-          seen = { class_name.to_s => true }
-          visited = 0
-          until queue.empty?
-            current = queue.shift
-            next if current.nil? || seen[current]
-
-            seen[current] = true
-            visited += 1
-            return nil if visited > OVERRIDE_ANCESTOR_WALK_LIMIT
-
-            result = yield current
-            return result if result
-
-            ancestor_class_names(scope, current).each { |name| queue.push(name) }
-          end
-          nil
+        # The project ancestors whose definitions `class_name`'s own `def` OVERRIDES are the entries AFTER the
+        # class on its {Scope::ResolutionChain}, nearest first; {#nearest_ancestor_visibility} and
+        # {#nearest_ancestor_method_def} each read the first of them that answers their question through
+        # `Inference::DefinerResolution` (ADR-119 C1c), `from:` the position after the class. Both are instance
+        # side only: the singleton override rules do not exist, and the singleton side's own read lands with
+        # ADR-119's singleton design.
+        #
+        # Issue #1568 — the walk this replaced was breadth-first from the class's direct ancestors, and those
+        # include the modules the class PREPENDS. A prepended module sits BEFORE the class in Ruby's order: its
+        # `def` overrides the class's, not the other way round, so `prepend P` with a public `P#foo` and a
+        # private `C#foo` reported `C#foo` as reducing `P#foo`'s visibility. It also reached `Base` before a
+        # module included through an included module (#1567's order).
+        #
+        # ADR-119 WD3 — for the two override lints *absent* always counts: a chain that does not settle (a mixin
+        # whose position the tables cannot vouch for, a fork whose worlds disagree, a conditional or
+        # block-scoped `include`), or an external ancestor ahead of the parent that RBS does not know or knows
+        # and declares the name in, is `UNKNOWN`, and the lint stays silent rather than answer from the
+        # breadth-first order the walk used before (`Scope::ResolutionChain::MasterOrder`) where the order is
+        # not known. The two lints read only the `[owner, value]` of a `Known`.
+        #
+        # ADR-46 slice 3 — an ancestor the project does not declare ends the walk's reach into it, and a class
+        # defined LATER under that name would change the answer; `DefinerResolution` files the negative class
+        # edge of each external entry it tests.
+        def overridden_ancestors_start(scope, class_name)
+          own = Scope::ResolutionChain.for(scope, class_name.to_s, :instance, :methods).index_of(class_name.to_s)
+          own && (own + 1)
         end
 
         # `[defining_class, visibility]` for the nearest user-source ancestor that defines an instance
         # method `method_name`, or nil.
         def nearest_ancestor_visibility(scope, class_name, method_name)
-          each_project_ancestor(scope, class_name) do |ancestor|
-            # Stop at the nearest ancestor that DEFINES the method; its visibility may be nil (unknown) —
-            # the caller treats unknown as "cannot prove a reduction" and stays silent. Never fabricate
-            # `:public` from a missing entry (that produced a large false-positive cluster on cross-file
-            # Rails concerns).
-            [ancestor, scope.discovered_method_visibility(ancestor, method_name)] if scope.user_def_for(ancestor,
-                                                                                                        method_name)
-          end
-        end
-
-        # Direct ancestors of `class_name` as project-discovered, qualified names: included / prepended
-        # modules first, then the superclass. As-written names are resolved against the nesting the
-        # subclass's declaration header is written in (`Scope#ancestor_name_candidates`, the single owner of
-        # that order); names that resolve to no project class/module (RBS-known / third-party) are dropped.
-        def ancestor_class_names(scope, class_name)
-          names = []
-          scope.includes_of(class_name).each do |raw|
-            resolved = resolve_override_ancestor_name(scope, class_name, raw)
-            names << resolved if resolved
-          end
-          raw_super = scope.superclass_of(class_name)
-          if raw_super
-            resolved_super = resolve_override_ancestor_name(scope, class_name, raw_super)
-            names << resolved_super if resolved_super
+          from = overridden_ancestors_start(scope, class_name)
+          return nil if from.nil?
+
+          case Inference::DefinerResolution.resolve(scope, class_name, method_name, :instance,
+                                                    question: :override, from: from) do |ancestor|
+                 # Stop at the nearest ancestor that DEFINES the method; its visibility may be nil (unknown) —
+                 # the caller treats unknown as "cannot prove a reduction" and stays silent. Never fabricate
+                 # `:public` from a missing entry (that produced a large false-positive cluster on
+                 # cross-file Rails concerns). The `:unrecorded` marker stands for that nil in the answer.
+                 next unless scope.user_def_for(ancestor, method_name)
+
+                 scope.discovered_method_visibility(ancestor, method_name) || :unrecorded
+               end
+          in Inference::DefinerResolution::Known(answer: [owner, visibility])
+            [owner, visibility == :unrecorded ? nil : visibility]
+          in Inference::DefinerResolution::UNKNOWN # the case/in contract needs one arm per answer
+            nil
+          in Inference::DefinerResolution::ABSENT # rubocop:disable Lint/DuplicateBranch -- see above
+            nil
           end
-          names
-        end
-
-        # Issue #732 — the predicate is asked of the SCOPE, not re-implemented here. This rule kept its own
-        # three-table copy until #723 widened the scope's with `discovered_methods` and left this one behind,
-        # so the two disagreed about exactly one shape (a project class with no instance def, no superclass
-        # and no include — `class Base; def self.build = :built; end`) with nothing observing the fork. #682
-        # made `Scope` the single owner of the candidate ORDER; this makes it the single owner of the
-        # predicate that filters those candidates too.
-        def resolve_override_ancestor_name(scope, subclass_qualified, raw_ancestor)
-          resolved = scope.ancestor_name_candidates(subclass_qualified, raw_ancestor)
-                          .find { |candidate| scope.known_user_class?(candidate) }
-          return resolved if resolved
-
-          # ADR-46 slice 3 — the override checker reads the class graph
-          # directly (not through the recorder's `Scope` choke points), and
-          # short-circuits when the ancestor resolves to no project class, so
-          # an incremental re-check has no edge telling it to re-check this
-          # subclass when that ancestor is later defined. Record a negative
-          # class edge (keyed on the unqualified name) so the appeared-class
-          # widening picks it up.
-          DependencyRecorder.read_missing(:class, raw_ancestor.to_s.split("::").last) if DependencyRecorder.active?
-          nil
         end
 
         def build_override_visibility_diagnostic(path, def_node, parent_class, parent_visibility, override_visibility)
@@ -3894,9 +3911,23 @@ module Rigor
         # `[defining_class, RBS::Definition::Method]` for the nearest project-discovered ancestor whose
         # RBS declares `method_name` (not the starting class's own declaration), or nil.
         def nearest_ancestor_method_def(scope, class_name, method_name)
-          each_project_ancestor(scope, class_name) do |ancestor|
-            method_def = safe_instance_method_definition(ancestor, method_name, scope)
-            [ancestor, method_def] if method_def && !defined_on?(method_def, class_name)
+          from = overridden_ancestors_start(scope, class_name)
+          return nil if from.nil?
+
+          case Inference::DefinerResolution.resolve(scope, class_name, method_name, :instance,
+                                                    question: :override, from: from) do |ancestor|
+                 method_def = safe_instance_method_definition(ancestor, method_name, scope)
+                 # The signature text is the answer two worlds compare: an `RBS::Definition::Method` has no
+                 # structural equality of its own.
+                 method_def.method_types.map(&:to_s) if method_def && !defined_on?(method_def, class_name)
+               end
+          in Inference::DefinerResolution::Known(owner:)
+            method_def = safe_instance_method_definition(owner, method_name, scope)
+            method_def && [owner, method_def]
+          in Inference::DefinerResolution::UNKNOWN # the case/in contract needs one arm per answer
+            nil
+          in Inference::DefinerResolution::ABSENT # rubocop:disable Lint/DuplicateBranch -- see above
+            nil
           end
         end