rigortype 0.3.8 → 0.4.0

data/lib/rigor/inference/method_dispatcher/overload_selector.rb

@@ -3,6 +3,9 @@
 require_relative "../../type"
 require_relative "../acceptance"
 require_relative "../rbs_type_translator"
+require_relative "alias_strict_nominals"
+require_relative "facet_distribution"
+require_relative "proven_overload"
 require_relative "receiver_affinity"
 
 module Rigor
@@ -14,6 +17,9 @@ module Rigor
       # 1. Filter overloads by positional arity (required, optional and rest_positionals are honored;
       #    required_keywords disqualify the overload because we do not yet thread keyword args through
       #    `call_arg_types`).
+      # 1a. **Pass 0 — proven, in declared order (#1344).** With only plain-value arguments, the first
+      #    overload they do not rule out wins outright when each of its params names its argument's own
+      #    class and accepts it with a `yes`; every later pass reads the receiver-affinity order instead.
       # 2. **Pass 1 — strict matches first.** Among the arity-matching overloads, prefer the first one
       #    whose every (param, arg) pair returns a `yes` or `maybe` answer AND whose param types do NOT
       #    translate through `RBS::Types::Alias` / `Interface` / `Intersection`. The translator demotes
@@ -38,64 +44,57 @@ module Rigor
       module OverloadSelector
         module_function
 
-        # Canonical RBS-core aliases shipped by `core/builtin.rbs` whose body is `<Nominal> | _DuckType`.
-        # Matching an overload against an Integer literal should pick the `(int) -> Array[Elem]` body over
-        # the `(string) -> String` body because Integer satisfies `int`'s strict arm and not `string`'s.
-        # The translator collapses both aliases to `Dynamic[Top]` (interfaces are not structurally matched
-        # yet), so a dedicated pass 1.5 between strict and gradual consults this map to pick the alias
-        # whose strict arm matches.
-        #
-        # Symbol keys are the alias names as they appear under `RBS::Types::Alias#name.to_s` (the `name` is
-        # a `TypeName` whose `to_s` includes the `::` prefix). Values are an Array of class names whose
-        # Nominal[..] form is the alias's strict-arm matcher.
-        ALIAS_STRICT_NOMINALS = {
-          "::int" => ["Integer"],
-          "::string" => ["String"],
-          "::interned" => %w[Symbol String],
-          "::io" => ["IO"],
-          "::encoding" => %w[Encoding String],
-          "::path" => ["String"],
-          "::boolean" => %w[TrueClass FalseClass],
-          # `range[T] = Range[T] | _Range[T]`. Generic, unlike the others, but the strict arm is still a
-          # single nominal and the args are irrelevant to this pass. rbs 4.1 rewrote `Array#[]`'s slicing
-          # overload from `(::Range[::Integer?])` to `(range[int])`; without the entry both it and the
-          # `(int) -> E` overload look alias-typed, so `a[1..2]` resolved to the element type.
-          "::range" => ["Range"]
-        }.freeze
-        private_constant :ALIAS_STRICT_NOMINALS
-
-        # @param method_definition [RBS::Definition::Method]
-        # @param arg_types [Array<Rigor::Type>] caller-provided types in positional order. Empty when
+        # `ALIAS_STRICT_NOMINALS`, the alias-strict pass's table, lives in `alias_strict_nominals.rb`.
+
+        # @param arg_types — caller-provided types in positional order. Empty when
         #   there are no arguments.
-        # @param self_type [Rigor::Type] substitute for `Bases::Self`.
-        # @param instance_type [Rigor::Type] substitute for `Bases::Instance`.
-        # @param type_vars [Hash{Symbol => Rigor::Type}] substitution map for class-level type variables
+        # @param self_type — substitute for `Bases::Self`.
+        # @param instance_type — substitute for `Bases::Instance`.
+        # @param type_vars — substitution map for class-level type variables
         #   (Slice 4 phase 2d). The selector threads it through to {RbsTypeTranslator} so parameter types
         #   like `::Array[Elem]` substitute Elem before the accepts check, instead of degrading the param
         #   to `Array[Dynamic[Top]]`.
-        # @param block_required [Boolean] when `true`, only overloads that declare a block clause are
+        # @param block_required — when `true`, only overloads that declare a block clause are
         #   considered (Slice 6 phase C sub-phase 1). The fallback also prefers a block-bearing overload
         #   over `method_types.first`. When `false` (the Slice 4 phase 2c default) the selector behaves
         #   exactly as before: `find` over arity-compatible overloads, falling back to the first
         #   declaration.
-        # @return [RBS::MethodType, nil] the chosen overload, or nil when the definition has no method
+        # @return the chosen overload, or nil when the definition has no method
         #   types at all.
-        def select(method_definition, **) = select_candidates(method_definition, **).first
+        def select(method_definition, **) = select_candidates(method_definition, member_wise: false, **).first
 
-        # Issue #521 — like {.select}, but when a `Dynamic[Top]` argument reaches the gradual pass it
-        # returns EVERY gradually-matching overload instead of pinning the first. An untyped argument
-        # accepts every param indiscriminately, so "first gradual match" is decided by overload-list
+        # Issue #521 — like {.select}, but when an imprecise argument (`Dynamic[Top]`, or since #1021 a
+        # union with a `Dynamic[Top]` member) reaches the gradual pass it returns EVERY gradually-matching
+        # overload instead of pinning the first. An untyped argument accepts every param
+        # indiscriminately, so "first gradual match" is decided by overload-list
         # position, not by types — `[true] * n` with an untyped `n` pinned `Array#*(string) -> String`
         # and answered a wrong precise type the runtime can contradict. The caller unions the candidates'
-        # returns, which contains the truth whichever overload the runtime takes. Every other path (strict,
-        # alias-resolved, typed-gradual, arity fallback) still yields exactly one candidate, so `select`
-        # keeps its historical single answer.
+        # returns, which contains the truth whichever overload the runtime takes. The member-wise reading of a
+        # two-member `Dynamic` facet (#1350, `FacetDistribution`) returns one candidate per member the same way.
+        # Every other path (strict, alias-resolved, typed-gradual, arity fallback) yields exactly one candidate,
+        # and `select` (`member_wise: false`) keeps its historical single answer.
         #
-        # @return [Array<RBS::MethodType>] matching overloads; empty when the definition declares none.
-        def select_candidates(method_definition, arg_types:, self_type:, instance_type:, type_vars: {},
-                              block_required: false, environment: nil)
-          overloads = method_definition.method_types
-          return [] if overloads.empty?
+        # @return matching overloads; empty when the definition declares none.
+        # rubocop:disable-next Metrics/ParameterLists -- the selection keywords plus the member-wise switch.
+        def select_candidates(definition, arg_types:, self_type:, instance_type:, type_vars: {},
+                              block_required: false, environment: nil, member_wise: true)
+          unless FacetDistribution.faceted?(arg_types)
+            return select_declared(definition, arg_types, self_type, instance_type, type_vars, block_required,
+                                   environment, false)
+          end
+
+          FacetDistribution.select(arg_types, definition, member_wise:, environment:) do |args, member|
+            select_declared(definition, args, self_type, instance_type, type_vars, block_required, environment, member)
+          end
+        end
+
+        # The selection proper, positional so the hot path forwards no keyword hash. A member-wise call (`member`, see
+        # `FacetDistribution.select`) answers only a genuine match, never the first-overload fallback.
+        # rubocop:disable-next Metrics/ParameterLists -- the selection inputs plus the member-wise flag.
+        def select_declared(method_definition, arg_types, self_type, instance_type, type_vars, block_required,
+                            environment, member)
+          declared = method_definition.method_types
+          return [] if declared.empty?
 
           # `rigor:v1:param: <name> <refinement>` annotations on this method override the RBS-declared
           # parameter type at the matching name. The map is consumed inside `accepts_param?` so overload
@@ -105,20 +104,18 @@ module Rigor
           # Pre-sort: demote overloads whose param class is a disjoint sibling of the receiver class (e.g.
           # `Integer#+(BigDecimal) -> BigDecimal` from the `bigdecimal` RBS reopen). Honors the coerce
           # convention so `5 + ?` for unknown `?` resolves to the receiver-class-preserving arm rather than
-          # an arbitrary sibling-class arm that only wins by overload-list position.
-          overloads = ReceiverAffinity.reorder(overloads, self_type: self_type, environment: environment)
-
-          alias_expander = environment&.rbs_loader
-          passes = lambda do |require_block|
-            run_selection_passes(
-              overloads,
-              { arg_types: arg_types, self_type: self_type, instance_type: instance_type,
-                type_vars: type_vars, block_required: require_block, param_overrides: param_overrides,
-                alias_expander: alias_expander }
-            )
-          end
-
-          matches = passes.call(block_required)
+          # an arbitrary sibling-class arm that only wins by overload-list position. The proven pass keeps
+          # the declared order (see `run_selection_passes`).
+          overloads = ReceiverAffinity.reorder(declared, self_type: self_type, environment: environment)
+
+          # One keyword bundle for the pass pipeline (see `run_selection_passes`); a block retry rebuilds it
+          # with the block flag cleared. Built once and passed positionally -- the previous lambda plus a
+          # `**shared` splat per pass allocated three objects per selection (#775).
+          shared = { arg_types: arg_types, self_type: self_type, instance_type: instance_type,
+                     type_vars: type_vars, block_required: block_required, param_overrides: param_overrides,
+                     alias_expander: environment&.rbs_loader, environment: environment }
+
+          matches = run_selection_passes(declared, overloads, shared)
           return matches unless matches.empty?
 
           # A block at the call site that no block-declaring overload matched: Ruby ignores a block handed
@@ -127,9 +124,10 @@ module Rigor
           # `define_command(:x) do … end` against `def define_command: (Symbol) -> Symbol`) degraded to
           # `Dynamic[Top]` — and on a self-send suppressed the whole method's return type.
           if block_required
-            matches = passes.call(false)
+            matches = run_selection_passes(declared, overloads, shared.merge(block_required: false))
             return matches unless matches.empty?
           end
+          return [] if member
 
           # No (usable) block at the call site: prefer an overload that does not REQUIRE a block over
           # `overloads.first`. Methods like `Array#filter` / `Enumerable#map` declare the block-bearing
@@ -154,18 +152,30 @@ module Rigor
         class << self
           private
 
-          # Three-pass overload search:
-          # - Pass 1 (strict): skipped when any arg is `Dynamic[Top]`, because gradual acceptance against
-          #   an untyped arg accepts every param indiscriminately and would let pass 1 lock in an arbitrary
-          #   strict overload (e.g. `Regexp#=~(nil) -> nil` over the `(::interned?) -> Integer?` overload).
+          # Overload search after pass 0 (`find_proven_overload`):
+          # - Pass 1 (strict): skipped when any arg is imprecise (`imprecise_arg?`), because gradual
+          #   acceptance against an untyped arg accepts every param indiscriminately and would let pass 1
+          #   lock in an arbitrary strict overload (e.g. `Regexp#=~(nil) -> nil` over the
+          #   `(::interned?) -> Integer?` overload).
           # - Pass 1.5 (alias-resolved): consults each `RBS::Types::Alias`'s strict arm so e.g.
           #   `Array#*(int)` wins over the `Array#*(string) -> String` overload for Integer args.
           # - Pass 2 (gradual): the original gradual matcher so overloads that legitimately rely on
           #   duck-typed params still resolve when nothing stricter applies.
           # `shared` is the caller-assembled keyword bundle for `find_matching_overload` — hash-shaped
           # because the pass pipeline forwards it twice and RuboCop's parameter-list budget is real.
-          def run_selection_passes(overloads, shared)
-            strict = find_matching_overload(overloads, **shared, strict: true)
+          #
+          # Pass 0 (#1344) comes first and reads the overloads in declared order; every later pass reads them
+          # in receiver-affinity order (`ReceiverAffinity`). RBS resolves two arms that both take an argument by
+          # declaration order: `Rational#+` declares `(Float) -> Float` before `(Numeric) -> Rational`, and the
+          # affinity order, which moves the `(Numeric)` arm first, typed `Rational(1, 2) + 0.5` as `Rational`
+          # where Ruby answers `1.0`. The affinity order stays for every call pass 0 declines: read in declared
+          # order, the strict pass let the `bigdecimal` reopen's `(BigDecimal) -> BigDecimal` arm, which it
+          # matches on a `maybe`, take `Integer#+` of a `bot`, a `Dynamic[Integer | Float | …]` or an
+          # unloadable class (612 call sites across the survey corpus).
+          def run_selection_passes(declared, overloads, shared)
+            # Unreordered, pass 0 can only pick what the strict pass picks, so it is skipped (#1344's allocations).
+            proven = find_proven_overload(declared, shared) unless overloads.equal?(declared)
+            strict = proven || find_matching_overload(overloads, shared, strict: true)
             return strict unless strict.empty?
 
             alias_hit = find_matching_overload_via_aliases(
@@ -174,36 +184,58 @@ module Rigor
             return [alias_hit] if alias_hit
 
             # Pass 2, array-valued. With every argument carrying real type information the first gradual
-            # match keeps its historical single-winner contract. With a `Dynamic[Top]` argument in play the
+            # match keeps its historical single-winner contract. With an imprecise argument in play the
             # matches are indistinguishable by types — position alone would pick — so ALL of them come back
             # and the dispatch layer unions their returns (#521).
-            matches = find_matching_overload(overloads, **shared, strict: false)
-            return matches.first(1) unless shared[:arg_types].any? { |t| untyped_arg?(t) }
+            matches = find_matching_overload(overloads, shared, strict: false)
+            return matches.first(1) unless shared[:arg_types].any? { |t| imprecise_arg?(t) }
 
             matches
           end
 
-          # rubocop:disable-next Metrics/ParameterLists
-          def find_matching_overload(overloads, arg_types:, self_type:, instance_type:, type_vars:, block_required:,
-                                     param_overrides:, strict:, alias_expander: nil)
-            return [] if strict && arg_types.any? { |t| untyped_arg?(t) }
+          # Pass 0. With every argument a plain value (a `Constant`, or a `Nominal` with no type arguments), the
+          # first overload in declared order that the arguments do not rule out is the one RBS would take, and
+          # the pass takes it only when that is certain: every parameter is a lone class naming its argument's
+          # own class, and accepts it with a `yes`. Any doubt declines to the affinity-ordered passes. A `maybe`
+          # is doubt — the analyzer process cannot load a project class, so a declared `(Base)` only maybe
+          # takes a `Sub`, and taking a later `(top)` arm instead typed the call wrong. So is a union or
+          # supertype parameter, which takes the argument through a declaration upstream RBS can get wrong:
+          # `Rational#divmod`'s `(Integer | Float | Rational) -> [Integer, Rational]` for a Float remainder.
+          def find_proven_overload(declared, shared)
+            args = shared[:arg_types]
+            return nil unless ProvenOverload.applies?(args)
+
+            index = declared.index { |mt| engages_block_shape?(mt, shared[:block_required]) && matches?(mt, shared) }
+            first = index && declared[index]
+            proven = first && strictly_typed_params?(first, args.size) && matches?(first, shared, strict: :proven)
+            [first] if proven && !ProvenOverload.contested?(declared, index, args, shared[:environment])
+          end
+
+          # The shared "no overload matched" answer; every consumer only reads the list.
+          NO_MATCH = [].freeze
+          private_constant :NO_MATCH
 
-            predicate = lambda do |method_type|
-              next false unless engages_block_shape?(method_type, block_required)
-              next false if strict && !strictly_typed_params?(method_type, arg_types.size)
-
-              matches?(
-                method_type, arg_types,
-                self_type: self_type, instance_type: instance_type,
-                type_vars: type_vars, param_overrides: param_overrides,
-                alias_expander: alias_expander
-              )
-            end
+          # `shared` is the keyword bundle `select_candidates` assembled (arg_types, self_type, instance_type,
+          # type_vars, block_required, param_overrides, alias_expander).
+          def find_matching_overload(overloads, shared, strict:)
+            arg_types = shared[:arg_types]
+            return NO_MATCH if strict && arg_types.any? { |t| imprecise_arg?(t) }
+
+            block_required = shared[:block_required]
             # Strict keeps its historical first-match short-circuit (a dispatch hot path); the gradual
             # pass needs the full candidate list for the #521 union.
-            return [overloads.find(&predicate)].compact if strict
+            if strict
+              found = overloads.find do |method_type|
+                engages_block_shape?(method_type, block_required) &&
+                  strictly_typed_params?(method_type, arg_types.size) &&
+                  matches?(method_type, shared, strict: true)
+              end
+              return found ? [found] : NO_MATCH
+            end
 
-            overloads.select(&predicate)
+            overloads.select do |method_type|
+              engages_block_shape?(method_type, block_required) && matches?(method_type, shared)
+            end
           end
 
           # Whether the overload's block clause is compatible with the call site's block shape: a
@@ -218,8 +250,17 @@ module Rigor
           # Treats the literal `untyped` carrier (`Dynamic[Top]`) as too imprecise to drive a strict-pass
           # match. Other `Dynamic`-wrapped types with a concrete static facet carry enough information to
           # pick a sensible overload.
-          def untyped_arg?(type)
-            type.is_a?(Type::Dynamic) && type.static_facet.is_a?(Type::Top)
+          def untyped_arg?(type) = type.is_a?(Type::Dynamic) && type.static_facet.is_a?(Type::Top)
+
+          # Issue #1021 — the strict and alias passes must not discriminate on an argument whose type
+          # cannot rule an overload out: the bare untyped carrier, or a union with an untyped member. That
+          # member may reach any overload at runtime, so a strict match is decided by the union's other
+          # members alone — `Dynamic[top] | nil` pinned `Regexp#match?(nil) -> false` and typed a live
+          # predicate as the literal `false`. The gradual pass still accepts against the whole union, so
+          # `Dynamic[top] | nil` keeps both `match?` overloads and the #521 join answers `Dynamic[bool]`.
+          # A `Dynamic` with a concrete static facet stays out: its facet discriminates.
+          def imprecise_arg?(type)
+            untyped_arg?(type) || (type.is_a?(Type::Union) && type.members.any? { |member| untyped_arg?(member) })
           end
 
           # Pass 1.5: for arity-compatible overloads whose every positional param is either a strict
@@ -232,7 +273,7 @@ module Rigor
             # Issue #521 — an untyped argument "maybe"-accepts EVERY alias's strict arm, so it cannot
             # discriminate between overloads here any more than in the strict pass; without this guard a
             # Dynamic arg pinned `Array#*(string) -> String` purely by declaration order.
-            return nil if arg_types.any? { |t| untyped_arg?(t) }
+            return nil if arg_types.any? { |t| imprecise_arg?(t) }
 
             overloads.find do |method_type|
               next false unless engages_block_shape?(method_type, block_required)
@@ -243,10 +284,19 @@ module Rigor
               params = positional_params_for(fun, arg_types.size)
               next false unless params.size == arg_types.size
 
-              params.zip(arg_types).all? { |param, arg| alias_param_accepts?(param.type, arg) }
+              each_param_accepts?(params, arg_types) { |param, arg| alias_param_accepts?(param.type, arg) }
             end
           end
 
+          # `params.zip(arg_types).all? { |param, arg| ... }` without the pair arrays: a formal beyond the
+          # actuals meets `nil`, exactly as `zip` pads. Selection zips once per overload per pass, so the
+          # pairs were a top allocation site of dispatch (#775). The counter is a captured local, so the
+          # walk allocates nothing (a Range or an Enumerator would be one object per overload per pass).
+          def each_param_accepts?(params, arg_types)
+            index = -1
+            params.all? { |param| yield(param, arg_types[index += 1]) }
+          end
+
           # Checks the param's RBS type against an arg using alias-strict-arm matching. Optional / Union
           # wrappers are flattened; alias resolution is one level deep (the canonical core aliases all have
           # non-alias strict arms).
@@ -317,25 +367,17 @@ module Rigor
             end
           end
 
-          def matches?(method_type, arg_types, self_type:, instance_type:, type_vars:, param_overrides:,
-                       alias_expander: nil)
+          # `shared` is the keyword bundle `select_candidates` assembled (see `find_matching_overload`).
+          # `strict:` is `false` (gradual), `true` (strict pass) or `:proven` (pass 0; see `find_proven_overload`).
+          def matches?(method_type, shared, strict: false)
             return false if method_type.respond_to?(:type_params) && rejects_keyword_required?(method_type)
 
+            arg_types = shared[:arg_types]
             fun = method_type.type
             return false unless arity_compatible?(fun, arg_types.size)
 
             params = positional_params_for(fun, arg_types.size)
-            params.zip(arg_types).all? do |param, arg|
-              accepts_param?(
-                param,
-                arg,
-                self_type: self_type,
-                instance_type: instance_type,
-                type_vars: type_vars,
-                param_overrides: param_overrides,
-                alias_expander: alias_expander
-              )
-            end
+            each_param_accepts?(params, arg_types) { |param, arg| accepts_param?(param, arg, shared, strict) }
           end
 
           # Slice 4 phase 2c does not pass keyword arguments through the call site (caller passes only
@@ -376,8 +418,12 @@ module Rigor
             rest = fun.rest_positionals
             trailing = fun.trailing_positionals
 
+            optional_needed = [actual_count - required.size - trailing.size, 0].max
+            # Nothing to append: the declaration's own list is the answer, read-only (the common
+            # required-positionals-only overload -- no copy, #775).
+            return required if optional_needed.zero? && trailing.empty? && (rest.nil? || actual_count <= required.size)
+
             head = required.dup
-            optional_needed = [actual_count - head.size - trailing.size, 0].max
             head.concat(optional.first(optional_needed))
 
             absorbed_by_rest = actual_count - head.size - trailing.size
@@ -387,14 +433,14 @@ module Rigor
             head
           end
 
-          def accepts_param?(param, arg, self_type:, instance_type:, type_vars:, param_overrides:,
-                             alias_expander: nil)
-            param_type = param_overrides[param.name] || RbsTypeTranslator.translate(
+          # `shared` is the keyword bundle `select_candidates` assembled (see `find_matching_overload`).
+          def accepts_param?(param, arg, shared, strict)
+            param_type = shared[:param_overrides][param.name] || RbsTypeTranslator.translate(
               param.type,
-              self_type: self_type,
-              instance_type: instance_type,
-              type_vars: type_vars,
-              alias_expander: alias_expander
+              self_type: shared[:self_type],
+              instance_type: shared[:instance_type],
+              type_vars: shared[:type_vars],
+              alias_expander: shared[:alias_expander]
             )
             # An `untyped` arg gradually accepts against every param, so a value-pinning param would be
             # "matched" with zero evidence and its value-precise return (`(nil) -> []`) would beat broader
@@ -404,6 +450,14 @@ module Rigor
             return false if untyped_arg?(arg) && value_pinning?(param_type)
 
             result = param_type.accepts(arg, mode: :gradual)
+            return result.yes? && ProvenOverload.names_arg_class?(param_type, arg) if strict == :proven
+
+            # A record's `maybe` for a `Hash` with a gradual arm or an open shape is no evidence for the overload:
+            # with `({ a: Integer }) -> Integer | (Hash[Symbol, untyped]) -> String`, `{ **o, b: 2 }` has a key the
+            # closed record forbids, yet the first overload won by list position. The gradual pass still takes it.
+            # A `maybe` that survives with those records answering `no` has another source, and still counts.
+            return false if strict && result.maybe? && Acceptance.maybe_rests_on_unread_hash?(param_type, arg)
+
             result.yes? || result.maybe?
           end
 

data/lib/rigor/inference/method_dispatcher/process_folding.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+require_relative "singleton_folding"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # `Process` class-method calls that read flow state.
+      #
+      # `Process.last_status` answers the thread's last child status, the slot `$?` reads (both are
+      # `rb_last_status_get` in CRuby's `process.c`). `data/core_overlay/process.rbs` declares it
+      # `() -> Process::Status?`, which is right where nothing is known. But past a statement that certainly
+      # ran a subprocess the flow engine has already bound `$?` to a non-nil `Process::Status`
+      # ({Inference::LastStatus}); answering the declared return there would put back the possible nil
+      # receiver the binding exists to remove as soon as the code reaches the status through the method
+      # rather than the global (`system("make"); Process.last_status.success?`). The same reasoning, for
+      # `Regexp.last_match` and `$~`, is {RegexpFolding.fold_last_match}.
+      #
+      # A bound `$?` is answered as it stands, so the method reads what the global reads in every body the
+      # binding rules reach, `Dynamic[top]` in a `define_method` body included. The consult never invents a
+      # binding: where `$?` is unbound (rescue clauses, closures, thread roots, joins with a path that ran no
+      # subprocess) it declines to the declaration. It also declines an argument-bearing call, whose arity
+      # the RBS tier reports.
+      #
+      # A project that defines `Process.last_status` itself answers `Dynamic[top]`: its method may return
+      # anything, and declining would hand the call to the overlay's declaration, which outranks a
+      # discovered method. A definition the discovery pass does not record — `def Process.last_status` outside
+      # `module Process`, `define_singleton_method`, `alias_method`, a prepended module — keeps the binding's answer.
+      module ProcessFolding
+        module_function
+
+        # @return the answer, or nil to defer.
+        def try_dispatch(context)
+          return nil unless SingletonFolding.receiver?(context.receiver, "Process")
+          return nil unless context.method_name == :last_status && context.args.empty?
+
+          scope = context.scope
+          return nil if scope.nil?
+          return Type::Combinator.untyped if project_defines_last_status?(scope)
+
+          scope.global(:$?)
+        end
+
+        def project_defines_last_status?(scope)
+          return true if scope.discovered_method?("Process", :last_status, :singleton)
+          return true if scope.discovered_singleton_def_nodes["Process"]&.key?(:last_status)
+
+          patched = scope.environment&.project_patched_methods
+          !patched.nil? && !patched.lookup(class_name: "Process", method_name: :last_status, kind: :singleton).nil?
+        end
+        private_class_method :project_defines_last_status?
+      end
+    end
+  end
+end

data/lib/rigor/inference/method_dispatcher/proven_overload.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # The value tests of `OverloadSelector`'s pass 0 (#1344), which reads the overloads in declared order and
+      # takes the first one plain-value arguments do not rule out, when that one names each argument's own class.
+      #
+      # Acceptance reads class relations from the analyzer's own process, which cannot load a project class or
+      # module, so it can rule an arm out wrongly: `(Printable)` against `1`, where project RBS includes
+      # `Printable` into `Integer`, answers `no`, and taking the `(Integer)` arm declared after it typed the call
+      # as that arm's return and fired `call.undefined-method` on correct code. {.contested?} therefore trusts
+      # an earlier arm to be out only when it can prove it: every positional parameter, rest included, is a plain
+      # class (through `?` and `|`), and both orderings — `Environment#class_ordering`, which asks the host class
+      # registry first, and the RBS loader's own — call it disjoint from every argument's class. A type alias,
+      # interface or variable proves nothing, and the host registry alone calls `Integer` and `Enumerable`
+      # disjoint where project RBS includes one into the other. Nor does a module, or a name Rigor stubbed because
+      # no RBS declares it: the source can include a module into the argument's class where no RBS says so, and
+      # neither ordering sees a source-only `include` (#1351). A class cannot be included, so a declared class
+      # stays provable.
+      module ProvenOverload
+        module_function
+
+        # Every argument is a plain value: a `Constant`, or a `Nominal` with no type arguments.
+        def applies?(arg_types)
+          !arg_types.empty? && arg_types.all? do |arg|
+            arg.is_a?(Type::Constant) || (arg.is_a?(Type::Nominal) && arg.type_args.empty?)
+          end
+        end
+
+        def names_arg_class?(param, arg) = param.is_a?(Type::Nominal) && param.class_name == class_name_of(arg)
+
+        def class_name_of(arg) = arg.is_a?(Type::Constant) ? arg.value.class.name : arg.class_name
+
+        # Whether an overload declared before `declared[index]` may take the arguments after all.
+        def contested?(declared, index, arg_types, environment)
+          loader = environment&.rbs_loader
+          return true if loader.nil?
+
+          arg_names = arg_types.map { |arg| class_name_of(arg) }
+          (0...index).any? { |position| !proven_out?(declared[position], arg_names, environment, loader) }
+        end
+
+        def proven_out?(method_type, arg_names, environment, loader)
+          fun = method_type.type
+          return false unless fun.respond_to?(:required_positionals)
+
+          params = fun.required_positionals + fun.optional_positionals + fun.trailing_positionals
+          params += [fun.rest_positionals] if fun.rest_positionals
+          params.all? { |param| disjoint_param?(param.type, arg_names, environment, loader) }
+        end
+
+        def disjoint_param?(rbs_type, arg_names, environment, loader)
+          case rbs_type
+          when RBS::Types::ClassInstance
+            name = rbs_type.name.to_s.delete_prefix("::")
+            return false if loader.rbs_module?(name) || loader.synthesized_type_names.include?(name)
+
+            arg_names.all? do |arg|
+              environment.class_ordering(arg, name) == :disjoint && loader.class_ordering(arg, name) == :disjoint
+            end
+          when RBS::Types::Optional then disjoint_param?(rbs_type.type, arg_names, environment, loader)
+          when RBS::Types::Union then rbs_type.types.all? { |member| disjoint_param?(member, arg_names, environment, loader) }
+          else false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rigor/inference/method_dispatcher/random_folding.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+require_relative "singleton_folding"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # ADR-109 — the interval a random draw over a literal range lands in. `Random.rand` and
+      # `Kernel#rand` advance a generator, so no call folds to a constant ({Builtins::RANDOM_CATALOG}
+      # says why); but a draw over `a..b` returns a value the range covers, and that is a bounded
+      # carrier of the range's own class, keeping its written end:
+      #
+      #   rand(1..6)              -> Integer[1..6]
+      #   rand(1...6)             -> Integer[1..5]
+      #   rand(0.0...1.0)         -> Float[0.0...1.0]
+      #   Random.rand(1.0..2.0)   -> Float[1.0..2.0]
+      #
+      # An empty range (`rand(5..1)` returns nil, `Random.rand(5..1)` raises), an unbounded one
+      # (`Errno::EDOM`) and a non-literal argument decline to the RBS envelope. The other argument
+      # shapes (`rand`, `rand(n)`, `rand(1.5)`) are deliberately NOT folded: the corpus uses them as its
+      # "unknown Integer / Float" oracle, and their intervals belong to a change that replaces that
+      # oracle first. The `Kernel` spelling is folded by {KernelDispatch#try_rand} behind ADR-91's
+      # ownership gate; this module owns `Singleton[Random]` and the shared interval reading.
+      module RandomFolding
+        module_function
+
+        def try_dispatch(context)
+          return nil unless SingletonFolding.receiver?(context.receiver, "Random")
+          return nil unless context.method_name == :rand
+
+          interval_for_args(context.args)
+        end
+
+        # The bounded carrier a one-argument draw over a literal range lands in, or `nil` for any other
+        # argument shape.
+        def interval_for_args(args)
+          return nil unless args.size == 1
+
+          arg = args.first
+          return nil unless arg.is_a?(Type::Constant) && arg.value.is_a?(Range)
+
+          range_interval(arg.value)
+        end
+
+        def range_interval(range)
+          lower = range.begin
+          upper = range.end
+          return nil unless real_endpoint?(lower) && real_endpoint?(upper)
+
+          if lower.is_a?(Integer) && upper.is_a?(Integer)
+            integer_range_interval(lower, upper, range.exclude_end?)
+          else
+            float_range_interval(lower.to_f, upper.to_f, range.exclude_end?)
+          end
+        end
+
+        # A finite Integer or Float; a missing end is `Errno::EDOM` at run time.
+        def real_endpoint?(value)
+          case value
+          when Integer then true
+          when Float then value.finite?
+          else false
+          end
+        end
+
+        def integer_range_interval(lower, upper, exclusive)
+          upper -= 1 if exclusive
+          return nil if lower > upper
+
+          Type::Combinator.integer_range(lower, upper)
+        end
+
+        def float_range_interval(lower, upper, exclusive)
+          return nil if lower > (exclusive ? upper.prev_float : upper)
+
+          Type::Combinator.float_range(lower, upper, exclude_end: exclusive)
+        end
+      end
+    end
+  end
+end