rigortype 0.4.6 → 0.4.7

data/lib/rigor/inference/match_rebinding.rb

@@ -12,6 +12,7 @@ require_relative "match_rebinding/frame"
 require_relative "match_rebinding/operands"
 require_relative "match_rebinding/calls"
 require_relative "match_rebinding/self_calls"
+require_relative "match_rebinding/yielding_match"
 require_relative "last_line"
 
 module Rigor
@@ -367,12 +368,21 @@ module Rigor
       #
       # Issue #1429 — the entry also restores a guard's narrowing of a global or constant where the body may run after
       # code that rebinds it ({GuardRebinding.block_entry}).
+      #
+      # Issue #2443 — the block of a call that matches before every yield (`scan`, `gsub`, `sub`, …) on a String or
+      # untyped receiver enters with that call's own match edge, laid over the entry above ({YieldingMatch}); a match
+      # its body runs still rebinds them through the statement-level rules.
       def block_entry(scope, block_node, call_node = nil)
+        operand_scope = scope
         scope = GuardRebinding.block_entry(scope, block_node, call_node)
         return FreshFrameBlocks.entry(scope, call_node) if FreshFrameBlocks.fresh_entry?(call_node, scope)
 
         scope = FreshFrameBlocks.closure_entry(scope, block_node, call_node)
         scope = LastLine.block_entry(scope, block_node, call_node)
+        YieldingMatch.entry(frame_entry(scope, block_node, call_node), block_node, call_node, operand_scope)
+      end
+
+      def frame_entry(scope, block_node, call_node)
         return scope unless scope.match_globals_bound?
         return scope unless scope.match_rebinding_closure? || entry_may_match?(block_node.body, scope, call_node) ||
                             (call_node.is_a?(Prism::CallNode) && operands_may_rebind?(call_node, scope))
@@ -386,7 +396,7 @@ module Rigor
 
         body.is_a?(Prism::Node) && scan(body, scope, base: true)
       end
-      private_class_method :entry_may_match?
+      private_class_method :frame_entry, :entry_may_match?
     end
   end
 end

data/lib/rigor/inference/memo_audit.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Inference
+    # ADR-127 WD3 — the callee floor's memo audit. A memo hit is correct only when the key holds every input the value
+    # was computed from, and a key that misses one answers a caller with another caller's value (#2516, #2524). With the
+    # audit on, every hit in the callee floor's memos (`resolved_census`, the unrecorded hand-off memo, the successor
+    # store and `def_census`) recomputes the value and raises {Mismatch} when it differs from the stored one, so a key
+    # defect fails on the first hit instead of waiting for an order that exposes it.
+    #
+    # Like {BudgetTrace}, a switch for specs and CI (`RIGOR_MEMO_AUDIT=1` in the environment, read once at load, or
+    # {enable!}): off by default, a single boolean check when off. A recomputation
+    # runs with the audit suspended on its thread and the memos bypassed ({suspended?}), so it reads nothing stored.
+    module MemoAudit
+      # A memo hit whose stored value differs from a fresh computation.
+      class Mismatch < StandardError; end
+
+      SUSPENDED_KEY = :rigor_memo_audit_suspended
+
+      @enabled = %w[1 true].include?(ENV["RIGOR_MEMO_AUDIT"].to_s.downcase)
+
+      module_function
+
+      def enabled? = @enabled
+
+      # True while an audit recomputation runs on this thread. The callee floor's memos are then bypassed (read and
+      # write), so the recomputation reads no stored entry of another memo: a defect shared across a table (a stale
+      # `resolved_census(:edges)` entry) would otherwise make the recomputed value match the stored one.
+      def suspended? = Thread.current[SUSPENDED_KEY]
+
+      def enable! = (@enabled = true)
+
+      def disable! = (@enabled = false)
+
+      # `stored`, after checking it against `yield` when the audit is on. `label` and the key parts (`key`, `key2`) name
+      # the memo entry in the failure; they are passed apart so an audit that is off allocates nothing.
+      def check(label, stored, key, key2 = nil, &)
+        return stored unless @enabled && !Thread.current[SUSPENDED_KEY]
+
+        fresh = suspended(&)
+        return stored if fresh == stored
+
+        raise Mismatch, "#{label} memo hit differs from a fresh computation for #{[key, key2].inspect[0, 120]}: " \
+                        "stored #{stored.inspect[0, 200]}, fresh #{fresh.inspect[0, 200]}"
+      end
+
+      def suspended
+        Thread.current[SUSPENDED_KEY] = true
+        yield
+      ensure
+        Thread.current[SUSPENDED_KEY] = nil
+      end
+    end
+  end
+end

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

@@ -7,7 +7,7 @@ module Rigor
         # 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
+        # The translator reads each alias's interface arm as `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.
         #

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # The positional argument lists a call with a precise union argument stands for (#2379): one per combination
+      # of the union arguments' members, since the runtime selects an overload per value. `RbsDispatch` selects an
+      # overload for each list and joins their returns.
+      module ArgumentDistribution
+        # The most lists {.lists} spells out when more than one argument is a union. One union argument is linear in
+        # its members and is not capped.
+        LIMIT = 8
+        private_constant :LIMIT
+
+        # {.lists}' answer past {LIMIT}: the call's overloads cannot be read per value, and it answers `Dynamic[top]`.
+        OVER_LIMIT = :over_limit
+
+        module_function
+
+        # The lists, nil when no argument is a union, or {OVER_LIMIT}.
+        def lists(arg_types)
+          unions = arg_types.count { |arg| arg.is_a?(Type::Union) }
+          return nil if unions.zero?
+
+          if unions > 1
+            count = arg_types.reduce(1) { |product, arg| arg.is_a?(Type::Union) ? product * arg.members.size : product }
+            return OVER_LIMIT if count > LIMIT
+          end
+
+          arg_types.reduce([[]]) do |partials, arg|
+            members = arg.is_a?(Type::Union) ? arg.members : [arg]
+            partials.flat_map { |partial| members.map { |member| partial + [member] } }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -317,7 +317,7 @@ module Rigor
         end
 
         # Returns the receiver's known finite element count, or nil when the carrier does not pin a size.
-        # Tuple and HashShape are pinned by construction; `Constant<…>` exposes the literal's `.size`. Other
+        # Tuple and HashShape are pinned by construction, and a `Constant` Range by its bounds. Other
         # shapes (Array[T], Range[T], Nominal) decline so the RBS tier widens.
         def finite_size(receiver)
           case receiver

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

@@ -192,8 +192,8 @@ module Rigor
 
         # #2115 — the numeric twin of `STRING_FOLD_BYTE_LIMIT`. A folded Integer (and each Integer part of a
         # folded Rational / Complex) is at most this many bits, the largest bit length whose decimal
-        # rendering still fits in `STRING_FOLD_BYTE_LIMIT` digits: `2 ** 13_605` folds, `2 ** 13_606`
-        # (bit length 13_607) does not. Computing `2 ** 100_000_000` takes Ruby milliseconds, but
+        # rendering still fits in `STRING_FOLD_BYTE_LIMIT` digits: `2 ** 13_605` folds,
+        # `2 ** 13_606` (bit length 13_607) does not. Computing `2 ** 100_000_000` takes Ruby milliseconds, but
         # rendering it in decimal — which describing, sorting and printing the `Constant` does — takes
         # minutes. `**` / `pow` / `<<` / `>>` also check their operands before invoking, so the big value
         # is never computed.
@@ -380,7 +380,7 @@ module Rigor
         # Normalises an input type into one of:
         # - `Array<Object>` for a `Constant` (1-element) or `Union[Constant…]` (n-element) — concrete values
         #   to enumerate.
-        # - `Type::IntegerRange` — bounded interval.
+        # - `Type::IntegerRange` / `Type::FloatRange` — bounded interval.
         # - `nil` — the input shape is not foldable.
         def numeric_set_of(type)
           case type

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+require_relative "../rbs_type_translator"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      module OverloadSelector
+        module_function
+
+        # Issue #2379 — every overload a supertype argument may select, when a nominal argument is wider than the
+        # parameter of the overload the call selected, `chosen`: `Integer#-` with a `Numeric` argument matched no
+        # overload and took the first, `(Integer) -> Integer`, although the runtime takes `(Float)`, `(Rational)` or
+        # `(Complex)` for those subclasses. Answers, in affinity order, every strictly typed overload whose every
+        # parameter takes its argument or is taken by a nominal one; nil when no argument is wider than `chosen`'s
+        # parameter or `chosen` is the only such overload.
+        # rubocop:disable-next Metrics/ParameterLists -- the selection inputs.
+        def contested_matches(method_definition, chosen, arg_types:, self_type:, instance_type:, type_vars:,
+                              block_required:, environment:)
+          return nil unless arg_types.any?(Type::Nominal)
+
+          shared = { arg_types: arg_types, self_type: self_type, instance_type: instance_type,
+                     type_vars: type_vars, block_required: block_required,
+                     param_overrides: RbsExtended.param_type_override_map(method_definition, environment: environment),
+                     environment: environment, keywords_last: false }
+          return nil unless wider_argument?(chosen, shared)
+
+          overloads = ReceiverAffinity.reorder(method_definition.method_types, self_type: self_type,
+                                                                               environment: environment)
+          matches = overloads.select do |method_type|
+            engages_block_shape?(method_type, block_required) &&
+              strictly_typed_params?(method_type, shared) && overlaps?(method_type, shared)
+          end
+          matches.empty? || (matches.size == 1 && matches.first.equal?(chosen)) ? nil : matches
+        end
+
+        class << self
+          private
+
+          # Whether a nominal argument is strictly wider than the parameter `method_type` binds it to: the parameter
+          # does not take the whole argument, and the argument takes the parameter (`Numeric` against `(Integer)`).
+          def wider_argument?(method_type, shared)
+            fun = method_type.type
+            arg_types = shared[:arg_types]
+            return false unless fun.respond_to?(:required_positionals) && arity_compatible?(fun, arg_types.size)
+
+            params = positional_params_for(fun, arg_types.size)
+            index = -1
+            params.any? do |param|
+              arg = arg_types[index += 1]
+              next false unless arg.is_a?(Type::Nominal)
+
+              param_type = translate_param(param, shared)
+              !param_type.accepts(arg, mode: :gradual).yes? && arg.accepts(param_type, mode: :gradual).yes?
+            end
+          end
+
+          # The strict pass's test with a nominal argument also counting where it takes the parameter: some value of
+          # a `Numeric` reaches `(Float)`.
+          def overlaps?(method_type, shared)
+            fun = method_type.type
+            ok = KeywordArguments.accepted_by?(fun, shared, true) { |*kv| accepts_param?(*kv, shared, true, true) }
+            return false unless ok
+
+            arg_types = shared[:arg_types]
+            return false unless arity_compatible?(fun, arg_types.size)
+
+            each_param_accepts?(positional_params_for(fun, arg_types.size), arg_types) do |param, arg|
+              accepts_param?(param, arg, shared, true) ||
+                (arg.is_a?(Type::Nominal) && arg.accepts(translate_param(param, shared), mode: :gradual).yes?)
+            end
+          end
+
+          # A parameter's type as the selector reads it: the `rigor:v1:param:` override, else the translated RBS type.
+          def translate_param(param, shared)
+            shared[:param_overrides][param.name] || RbsTypeTranslator.translate(
+              param.type,
+              self_type: shared[:self_type],
+              instance_type: shared[:instance_type],
+              type_vars: shared[:type_vars],
+              alias_expander: shared[:environment]&.rbs_loader
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -105,7 +105,7 @@ module Rigor
         #   throws)
         # - `Hash[K, V]` / `HashShape{...}`                 → Tuple[K, V]
         #   (Ruby yields `[key, value]` pairs as the element)
-        # - `Constant<Array>` / `Constant<Range>` / `Constant<Set>`
+        # - `Constant<Array>` / `Constant<Range>`
         #                                                   → corresponding Constant element
         #
         # Receivers we cannot project (Top, Dynamic, unknown nominals, IO, …) decline so the RBS tier still

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

@@ -11,7 +11,7 @@ module Rigor
       # Kernel intrinsic shape-folding — precision tier for the `Kernel` module-functions whose return type
       # is a function of the argument's *shape*, not just its class.
       #
-      # Today the only catalogued intrinsic is `Kernel#Array`. The default RBS sig is
+      # `Kernel#Array` is the shape-sensitive fold. Its default RBS sig is
       # `Array(untyped) -> Array[untyped]`, which collapses to `Array[Dynamic[top]]` for every caller. This
       # tier short-circuits with a precise answer when the argument's type lattice tells us what the result
       # element type MUST be:

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      module OverloadSelector
+        module_function
+
+        # The overload a call answers when no selection pass matched it. A call with a block, on a method that
+        # declares a block overload, reads the block overloads (`block_call_fallback`, #2429) unless `block_fallback`
+        # is false. Otherwise prefer an overload that does not REQUIRE a block over `overloads.first`: methods like
+        # `Array#filter` / `Enumerable#map` declare the block-bearing overload first (`() { ... } -> Array[Elem]`)
+        # and the bare-call overload second (`() -> Enumerator[...]`), and a no-block `[1, 2].filter` yields an
+        # `Enumerator`.
+        def no_match_fallback(overloads, shared, block_fallback)
+          if block_fallback && shared[:block_required] && overloads.any? { |mt| overload_has_block?(mt) }
+            return block_call_fallback(overloads, shared)
+          end
+
+          [overloads.find { |mt| !overload_requires_block?(mt) } || overloads.first]
+        end
+
+        class << self
+          private
+
+          # Issue #2429 — the block-less arm's return is what the method answers without a block, so
+          # `URI.open(url, read_timeout: 3) { |io| }` read `StringIO | Tempfile` instead of the block's value. The
+          # answer is the block overload whose positional arity admits the call when only one does, or the one every
+          # such overload agrees on; otherwise none (`[]`, which the return path reads as `Dynamic[top]`).
+          # `[3, 1, 2].max_by(2.0) { }` takes `(Integer n) { } -> Array[Elem]`, not `() { } -> Elem?`, and overloads of
+          # differing returns that all admit the call are not decided by position.
+          def block_call_fallback(overloads, shared)
+            admitted = overloads.select { |mt| overload_has_block?(mt) && arity_admits?(mt, shared) }
+            return [] if admitted.empty?
+
+            admitted.map { |mt| mt.type.return_type }.uniq.size == 1 ? [admitted.first] : []
+          end
+
+          # The call's positional count (less a keyword hash the overload takes as keywords) fits `method_type`'s
+          # arity; a splat fits when some count of its elements does (#1801).
+          def arity_admits?(method_type, shared)
+            fun = method_type.type
+            arg_types = KeywordArguments.selection_positional(method_type, shared)
+            splats = shared[:splats]
+            return arity_compatible?(fun, arg_types.size) unless splats
+
+            lists = SplatArity.expansions(fun, arg_types, splats)
+            lists.nil? || lists.any? { |list| arity_compatible?(fun, list.size) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -4,9 +4,11 @@ require_relative "../../type"
 require_relative "../acceptance"
 require_relative "../rbs_type_translator"
 require_relative "alias_strict_nominals"
+require_relative "contested_overloads"
 require_relative "facet_distribution"
 require_relative "imprecise_argument"
 require_relative "keyword_arguments"
+require_relative "no_match_fallback"
 require_relative "proven_overload"
 require_relative "receiver_affinity"
 require_relative "splat_arity"
@@ -43,8 +45,10 @@ module Rigor
       #    otherwise win purely by list position and inject false constants into the flow; they remain
       #    selectable when the argument PROVES the value (strict pass) or when no other overload matches
       #    (step 4's fallback picks the first overload regardless).
-      # 4. If no overload matches at all, fall back to `method_types.first` so existing call sites keep
-      #    their phase 1 / 2b behavior. This preserves the fail-soft invariant of the dispatcher.
+      # 4. If no overload matches at all, fall back to the first overload that does not require a block (else
+      #    `method_types.first`), so existing call sites keep their phase 1 / 2b behavior. This preserves the
+      #    fail-soft invariant of the dispatcher. A call with a block reads the block overloads by arity instead
+      #    (`no_match_fallback`, #2429).
       #
       # The selector is intentionally agnostic about the dispatch kind (instance vs singleton). Both kinds
       # share the same arity and acceptance shape; the difference is only in which `Definition` the caller
@@ -64,10 +68,10 @@ module Rigor
         #   like `::Array[Elem]` substitute Elem before the accepts check, instead of degrading the param
         #   to `Array[Dynamic[Top]]`.
         # @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.
+        #   considered first (Slice 6 phase C sub-phase 1), and a call none of them matches is retried with
+        #   the block ignored. Where nothing matches, a block call answers by arity among the block overloads
+        #   (`block_call_fallback`, #2429), and otherwise the fallback prefers an overload that does not require a
+        #   block over `method_types.first`.
         # @return the chosen overload, or nil when the definition has no method
         #   types at all.
         def select(method_definition, **) = select_candidates(method_definition, member_wise: false, **).first
@@ -88,12 +92,14 @@ module Rigor
         # rubocop:disable-next Metrics/ParameterLists -- the selection keywords plus the member-wise switch.
         # @param keywords_last — the call's last argument is a keyword hash (`f(a, k: 1)`, not `f(a, { k: 1 })`).
         # @param splats — the indices of `arg_types` that are splat arguments (`f(*xs)`), or nil (#1801).
+        # @param block_fallback — false keeps a block call nothing matches on the block-less fallback (#2429): the
+        #   block-parameter probe binds no parameters from an overload the call does not match.
         def select_candidates(definition, arg_types:, self_type:, instance_type:, type_vars: {},
                               block_required: false, environment: nil, member_wise: true, keywords_last: false,
-                              splats: nil)
+                              splats: nil, block_fallback: true)
           unless FacetDistribution.faceted?(arg_types)
             return select_declared(definition, arg_types, self_type, instance_type, type_vars, block_required,
-                                   environment, false, keywords_last, splats)
+                                   environment, false, keywords_last, splats, block_fallback)
           end
 
           FacetDistribution.select(arg_types, definition, member_wise:, environment:) do |args, member|
@@ -101,7 +107,7 @@ module Rigor
             # gradually matches every arm and the strict pass's pick is the first by position, so the member-wise answer
             # is every gradual match (`:joined`), as the block probe reads it (#1750); the caller joins their returns.
             select_declared(definition, args, self_type, instance_type, type_vars, block_required, environment,
-                            member || (member_wise && :joined), keywords_last, splats)
+                            member || (member_wise && :joined), keywords_last, splats, block_fallback)
           end
         end
 
@@ -114,7 +120,7 @@ module Rigor
         # first-overload fallback, as the return path's reading of the arguments as given always has (#1782).
         # 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, keywords_last, splats = nil)
+                            environment, member, keywords_last, splats, block_fallback)
           declared = method_definition.method_types
           return [] if declared.empty?
 
@@ -159,12 +165,7 @@ module Rigor
           end
           return [] if member && member != :joined
 
-          # 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
-          # overload first (`() { ... } -> Array[Elem]`) and the bare-call overload second
-          # (`() -> Enumerator[...]`). Without this, a no-block `[1, 2].filter` would adopt the block
-          # overload's `Array[Elem]` return when the call actually yields an `Enumerator`.
-          [overloads.find { |mt| !overload_requires_block?(mt) } || overloads.first]
+          no_match_fallback(overloads, shared, block_fallback)
         end
 
         def overload_has_block?(method_type)
@@ -230,13 +231,25 @@ module Rigor
             # and the dispatch layer unions their returns (#521).
             matches = find_matching_overload(overloads, shared, strict: false)
             every_match = gradual || ImpreciseArgument.any_in?(shared[:arg_types], shared[:keywords_last])
-            return matches.first(1) unless every_match
+            return [first_read_match(matches, shared)].compact unless every_match
 
             # Issue #1675 — and every overload the arguments' untyped parts reach on their own, after the
             # whole-argument matches so the singular `select` keeps its answer.
             ImpreciseArgument.with_stand_ins(matches, shared) { find_matching_overload(overloads, it, strict: false) }
           end
 
+          # Issue #2428 — the single winner of pass 2 is the first match that does not rest on a tuple's `maybe` for
+          # an `Array` of unknown arity, when there is one. Pass 1 declines a strict overload against a competitor
+          # whose parameter is an alias, an interface or `untyped`, and taking the tuple overload by list position
+          # then typed redis's `hmget(key, Array[String])` as `[String?]`, where its `(arg, Array[arg])` overload
+          # says `Array[String?]`. Only the tuple's `maybe` is re-asked; a record's `maybe` for an unread hash keeps
+          # its documented gradual-pass answer.
+          def first_read_match(matches, shared)
+            return matches.first if matches.size < 2 || !Acceptance.unread_array_in?(shared[:arg_types])
+
+            matches.find { |mt| Acceptance.refusing_unread_arrays { matches?(mt, shared) } } || matches.first
+          end
+
           # 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
@@ -307,7 +320,10 @@ module Rigor
               next false unless engages_block_shape?(method_type, shared[:block_required])
 
               fun = method_type.type
-              ok = KeywordArguments.accepted_by?(fun, shared, false) { |*kv| accepts_param?(*kv, shared, false, true) }
+              # Issue #2428 — a tuple keyword's `maybe` for an unread Array is no evidence here; pass 2 decides.
+              ok = Acceptance.refusing_unread_arrays do
+                KeywordArguments.accepted_by?(fun, shared, false) { |*kv| accepts_param?(*kv, shared, false, true) }
+              end
               next false unless ok
 
               arg_types = KeywordArguments.selection_positional(method_type, shared)
@@ -445,13 +461,7 @@ module Rigor
 
           # `shared` is the keyword bundle `select_candidates` assembled (see `find_matching_overload`).
           def accepts_param?(param, arg, shared, strict, keyword = false) # rubocop:disable Style/OptionalBooleanParameter
-            param_type = shared[:param_overrides][param.name] || RbsTypeTranslator.translate(
-              param.type,
-              self_type: shared[:self_type],
-              instance_type: shared[:instance_type],
-              type_vars: shared[:type_vars],
-              alias_expander: shared[:environment]&.rbs_loader
-            )
+            param_type = translate_param(param, shared)
             # 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
             # overloads purely by list position. Decline the pair; only the strict pass (where the arg
@@ -467,8 +477,10 @@ module Rigor
             # 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)
+            # A tuple's `maybe` for an `Array` of unknown arity is the same: `([Integer, Integer]) -> Symbol |
+            # (Array[Integer]) -> String` answers `String` for an `Array[Integer]`. A `maybe` that survives with
+            # those shapes answering `no` has another source, and still counts.
+            return false if strict && result.maybe? && Acceptance.maybe_rests_on_unread_shape?(param_type, arg)
 
             result.yes? || result.maybe?
           end

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

@@ -20,7 +20,7 @@ module Rigor
       # (`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
+      # oracle first. The `Kernel` spelling is folded by {KernelDispatch.try_dispatch} behind ADR-91's
       # ownership gate; this module owns `Singleton[Random]` and the shared interval reading.
       module RandomFolding
         module_function