rigortype 0.3.9 → 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/element_read_widening.rb

@@ -45,7 +45,7 @@ module Rigor
         widened = widen_through_path(current_scope.local(read.name), steps, call_node.name, arg_types)
         return current_scope if widened.nil?
 
-        current_scope.with_local(read.name, widened)
+        current_scope.with_mutated_local(read.name, widened)
       end
 
       # True when `receiver` is an element read whose target element is a literal-shape carrier —
@@ -62,7 +62,12 @@ module Rigor
       # `[<local read>, [step, …]]` for a chain of element reads rooted at a local variable, or
       # `nil` when the expression is anything else. A step is an Integer position (negative counts
       # from the end, as Ruby's own indexing does) or `:all` when the index is not a literal.
+      #
+      # Every mutation site's receiver is asked, and nearly every one is a plain variable read, so a
+      # receiver that is no call answers before the step list is allocated.
       def element_read_path(node)
+        return nil unless node.is_a?(Prism::CallNode)
+
         steps = []
         cursor = node
         while cursor.is_a?(Prism::CallNode)
@@ -118,22 +123,29 @@ module Rigor
       end
 
       # Rebuilds `type` with the element at `steps` widened against `method_name`, or `nil` when
-      # nothing along the path widened.
-      def widen_through_path(type, steps, method_name, arg_types)
-        return MutationWidening.widen_for_mutator(type, method_name, arg_types: arg_types) if steps.empty?
+      # nothing along the path widened. A block, when given, replaces the straight-line widening of the
+      # element itself: it receives the element's type and answers the widened one, or `nil` to decline.
+      # {UnknownStoreWidening} passes one so a site on an element takes the same unknown-store widening a
+      # site on a variable does.
+      def widen_through_path(type, steps, method_name, arg_types, &element_widening)
+        if steps.empty?
+          return element_widening.call(type) if element_widening
+
+          return MutationWidening.widen_for_mutator(type, method_name, arg_types: arg_types)
+        end
 
         case type
-        when Type::Tuple then widen_tuple_path(type, steps, method_name, arg_types)
-        when Type::Union then widen_union_path(type, steps, method_name, arg_types)
+        when Type::Tuple then widen_tuple_path(type, steps, method_name, arg_types, &element_widening)
+        when Type::Union then widen_union_path(type, steps, method_name, arg_types, &element_widening)
         end
       end
 
-      def widen_tuple_path(tuple, steps, method_name, arg_types)
+      def widen_tuple_path(tuple, steps, method_name, arg_types, &)
         elements = tuple.elements.dup
         rest = steps.drop(1)
         widened_any = false
         tuple_positions(tuple, steps.first).each do |position|
-          inner = widen_through_path(elements[position], rest, method_name, arg_types)
+          inner = widen_through_path(elements[position], rest, method_name, arg_types, &)
           next if inner.nil?
 
           elements[position] = inner
@@ -142,10 +154,10 @@ module Rigor
         widened_any ? Type::Tuple.new(elements) : nil
       end
 
-      def widen_union_path(union, steps, method_name, arg_types)
+      def widen_union_path(union, steps, method_name, arg_types, &)
         widened_any = false
         members = union.members.map do |member|
-          widened = widen_through_path(member, steps, method_name, arg_types)
+          widened = widen_through_path(member, steps, method_name, arg_types, &)
           next member if widened.nil?
 
           widened_any = true

data/lib/rigor/inference/error_info.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../reflection"
+require_relative "../source/node_children"
+require_relative "../type"
+require_relative "block_call_timing"
+
+module Rigor
+  module Inference
+    # Issue #1360 — `$!`, the exception being rescued, and `$@`, its backtrace. Ruby does not keep them in the method
+    # frame's special-variable slot, as it keeps `$~` and `$_`: a read of `$!` walks the running execution context's
+    # frames to the nearest rescue frame. So:
+    #
+    # - inside a `rescue` clause, and inside a rescue modifier's fallback, `$!` is the exception that clause rescued,
+    #   in every block the clause runs and every method it calls;
+    # - once the `begin` or the modifier exits, however it exits, `$!` is what it was before it started: `nil` at the
+    #   top of a method called from nowhere special, the outer exception after a nested `begin` in a rescue clause;
+    # - an `else` clause and the body read that earlier value too, and an `ensure` clause reads it when the body or a
+    #   rescue clause finished, but the exception in flight when one raised.
+    #
+    # A method body cannot know what its caller is rescuing, so it starts unbound; a thread's or fiber's root block
+    # runs in an execution context of its own, where `$!` is `nil` ({FreshFrameBlocks.entry}); and a closure's body
+    # runs whenever it is called, usually after the clause it is written in exited ({FreshFrameBlocks.closure_entry}).
+    module ErrorInfo
+      ERROR_INFO = :$!
+      BACKTRACE = :$@
+      NAMES = [ERROR_INFO, BACKTRACE].freeze
+      # The globals a rescue modifier's fallback reads differently from the modifier's entry ({.modifier_entry}).
+      MODIFIER_NAMES = [ERROR_INFO, BACKTRACE, :$?].freeze
+      EXCEPTION_ORDERINGS = Set[:equal, :subclass].freeze
+      DEFINERS = Set[:define_method, :define_singleton_method].freeze
+      # The class guards a clause may put on `$!` ({.guarded?}).
+      GUARDS = Set[:is_a?, :kind_of?, :instance_of?, :respond_to?].freeze
+      private_constant :ERROR_INFO, :BACKTRACE, :NAMES, :MODIFIER_NAMES, :EXCEPTION_ORDERINGS, :GUARDS, :DEFINERS
+
+      module_function
+
+      # The scope a `rescue` clause, or a rescue modifier's fallback, runs from: `$!` bound to the exception it rescued
+      # and `$@` to that exception's backtrace, with `$?` unbound. `exception_type` is what `rescue … => e` binds `e` to
+      # (`StatementEvaluator#rescue_exception_type`): the union of the named classes' instances, `StandardError` for a
+      # bare `rescue`. A member that is not a class RBS or the program places below `Exception` reads `Dynamic[top]`
+      # instead: a rescue list may name a module with its own `===` (`rescue NetworkErrors`), which matches exceptions
+      # that are not instances of it, and a class the analyzer cannot place may be such an object too. So does a class
+      # that it or a project ancestor gives its own singleton `===` (`class Matchy < StandardError; def self.===(o) =
+      # true`).
+      #
+      # `body` is the clause's statements or the fallback, and `reference` the name of the local a `rescue … => e`
+      # clause binds. When the body guards `$!`, or that local, which is the same object, by its class ({.guarded?}),
+      # the clause reads `$!` and `$@` unbound, as it did before issue #1360: `$!.key if e.is_a?(KeyError)` would report
+      # the bound `StandardError` against the guard (ADR-117, point 3), since narrowing `e` does not narrow `$!`. #1429
+      # made a class guard on `$!` itself narrow it; #1447 narrows this decline to the guards that still do not.
+      #
+      # `$@` calls the exception's `backtrace`, which is an `Array[String]` for a raised exception. It is left unbound
+      # in a program that defines a method named `backtrace` anywhere, which may return anything, and in a clause
+      # whose body calls `set_backtrace`, which may set it to nil.
+      #
+      # `$?` is unbound because the exception may have been raised while a subprocess waited: a backtick, `%x` or
+      # `system` sets `$?` to nil before it runs the child, so a `Timeout::Error`, an `Interrupt` or a `Thread#raise`
+      # there leaves it nil.
+      def rescue_entry(scope, exception_type, body = nil, reference = nil)
+        entered = scope.forget_error_info.forget_last_status
+        # Narrowed to the guards #1429 does not narrow in #1447.
+        return entered if guarded?(body, reference)
+
+        entered = entered.with_global(ERROR_INFO, rescued_type(exception_type, scope))
+        return entered if calls_set_backtrace?(body) || BlockCallTiming.project_defines_anywhere?(:backtrace, scope)
+
+        entered.with_global(BACKTRACE, backtrace_type)
+      end
+
+      # The scope a rescue modifier's fallback (`expr rescue fallback`) runs from, which rescues a `StandardError`.
+      def modifier_entry(scope, fallback = nil)
+        rescue_entry(scope, Type::Combinator.nominal_of("StandardError"), fallback)
+      end
+
+      # The class guards on `$!` that {.rescue_entry} declines on, anywhere in `node`: `$!.is_a?`, `kind_of?`,
+      # `instance_of?` or `respond_to?`, a `===` whose argument is `$!` (`KeyError === $!`), and `case $!`, and the
+      # same on a read of the local named `reference`.
+      def guarded?(node, reference = nil)
+        return false unless node.is_a?(Prism::Node)
+        return true if guard?(node, reference)
+
+        found = false
+        node.rigor_each_child { |child| found ||= guarded?(child, reference) }
+        found
+      end
+
+      def guard?(node, reference)
+        case node
+        when Prism::CallNode
+          (GUARDS.include?(node.name) && error_info_read?(node.receiver, reference)) ||
+            (node.name == :=== && error_info_read?(node.arguments&.arguments&.first, reference))
+        when Prism::CaseNode, Prism::CaseMatchNode then error_info_read?(node.predicate, reference)
+        else false
+        end
+      end
+
+      def error_info_read?(node, reference)
+        case node
+        when Prism::GlobalVariableReadNode then node.name == ERROR_INFO
+        when Prism::LocalVariableReadNode then !reference.nil? && node.name == reference
+        else false
+        end
+      end
+
+      # True when `node` calls `set_backtrace` anywhere, on any receiver: `$!.set_backtrace(nil)` makes `$@` nil.
+      def calls_set_backtrace?(node)
+        return false unless node.is_a?(Prism::Node)
+        return true if node.is_a?(Prism::CallNode) && node.name == :set_backtrace
+
+        found = false
+        node.rigor_each_child { |child| found ||= calls_set_backtrace?(child) }
+        found
+      end
+      private_class_method :guard?, :error_info_read?, :calls_set_backtrace?
+
+      # True when `node` reads `$!`, `$@` or `$?` anywhere in it: the gate on typing a rescue modifier's fallback
+      # under {.modifier_entry}, which most fallbacks (`rescue nil`) never need.
+      def read_in?(node)
+        return false unless node.is_a?(Prism::Node)
+        return MODIFIER_NAMES.include?(node.name) if node.is_a?(Prism::GlobalVariableReadNode)
+
+        found = false
+        node.rigor_each_child { |child| found ||= read_in?(child) }
+        found
+      end
+
+      # `scope` with `$!` and `$@` as `entry` binds them, and unbound where `entry` leaves them unbound: the scope past
+      # a `begin` or a rescue modifier that started from `entry`, whichever way it left.
+      def restore(scope, entry)
+        return scope if NAMES.all? { |name| scope.global(name).equal?(entry.global(name)) }
+
+        NAMES.reduce(scope.forget_error_info) do |acc, name|
+          bound = entry.global(name)
+          bound ? acc.with_global(name, bound) : acc
+        end
+      end
+
+      def rescued_type(exception_type, scope)
+        members = exception_type.is_a?(Type::Union) ? exception_type.members : [exception_type]
+        return exception_type if members.all? { |member| exception_instance?(member, scope) }
+
+        Type::Combinator.union(
+          *members.map { |member| exception_instance?(member, scope) ? member : Type::Combinator.untyped }
+        )
+      end
+
+      # True when `type` is an instance of a class below `Exception`: one RBS places there, or a project class whose
+      # superclass chain reaches one (`class MyError < StandardError`), which the RBS environment does not know.
+      def exception_instance?(type, scope)
+        return false unless type.is_a?(Type::Nominal)
+
+        class_name = type.class_name
+        return false if own_case_equality?(class_name, scope)
+        return true if exception_class?(class_name, scope)
+        return false unless scope.known_user_class?(class_name)
+
+        scope.external_ancestor_name_candidates(class_name, mixins: false).any? do |candidates|
+          known = candidates.find { |candidate| Reflection.rbs_class_known?(candidate, scope: scope) }
+          !known.nil? && exception_class?(known, scope)
+        end
+      rescue StandardError
+        false
+      end
+
+      # True when the program gives `class_name`, or a project ancestor of it, a singleton `===`, which `rescue` calls
+      # to match and which may accept an exception that is not an instance of it: a `def self.===` or `class << self`
+      # `def ===`, or, anywhere in the file being read, a `define_method` or `define_singleton_method` naming `===`
+      # ({.defines_case_equality?}), which the discovery tables do not place on a class, so it counts for every class.
+      def own_case_equality?(class_name, scope)
+        scope.discovery.defines_case_equality ||
+          !scope.singleton_def_through_ancestors(class_name, :===).first.nil?
+      end
+
+      # True when `node` is a `define_method` or `define_singleton_method` call whose literal name is `===`.
+      # `Inference::ScopeIndexer` records whether a file holds one ({Scope::DiscoveryIndex#defines_case_equality}).
+      def defines_case_equality?(node)
+        return false unless node.is_a?(Prism::CallNode) && DEFINERS.include?(node.name)
+
+        name = node.arguments&.arguments&.first
+        (name.is_a?(Prism::SymbolNode) || name.is_a?(Prism::StringNode)) && name.unescaped == "==="
+      end
+
+      def exception_class?(class_name, scope)
+        EXCEPTION_ORDERINGS.include?(scope.environment.class_ordering(class_name, "Exception"))
+      end
+
+      def backtrace_type
+        Type::Combinator.nominal_of("Array", type_args: [Type::Combinator.nominal_of("String")])
+      end
+      private_class_method :rescued_type, :exception_instance?, :own_case_equality?, :exception_class?, :backtrace_type
+    end
+  end
+end