rigortype 0.4.6 → 0.4.8

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

@@ -4,10 +4,13 @@ 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 "singleton_type_params"
 require_relative "receiver_affinity"
 require_relative "splat_arity"
 
@@ -43,12 +46,15 @@ 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
       # fetched.
+      # rubocop:disable-next Metrics/ModuleLength -- the selection passes plus the #2828 overload rewrite wrapper.
       module OverloadSelector
         module_function
 
@@ -64,10 +70,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 +94,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 +109,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,10 +122,20 @@ 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?
 
+          # Issue #2828 — `singleton(T)` over a method type variable reads as a class object (`SingletonTypeParams`).
+          SingletonTypeParams.selecting(declared) do |overloads|
+            select_among(overloads, method_definition, arg_types, self_type, instance_type, type_vars, block_required,
+                         environment, member, keywords_last, splats, block_fallback)
+          end
+        end
+
+        # rubocop:disable-next Metrics/ParameterLists -- {.select_declared}'s inputs plus the overloads it reads.
+        def select_among(declared, method_definition, arg_types, self_type, instance_type, type_vars, block_required,
+                         environment, member, keywords_last, splats, block_fallback)
           # A keyword hash only some overload takes as keywords is a plain positional `Hash` otherwise (#1737).
           keywords_last &&= KeywordArguments.any_declares?(declared)
 
@@ -159,12 +177,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 +243,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 +332,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 +473,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 +489,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