rigortype 0.4.5 → 0.4.7

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:
@@ -191,12 +191,16 @@ module Rigor
         # Runs the real `Kernel#format` when everything is value-pinned. A malformed directive or an
         # argument-count mismatch raises at fold time; the handler declines so the literal-string
         # lift (or the RBS `String` envelope) answers instead. Results larger than the shared
-        # `ConstantFolding::STRING_FOLD_BYTE_LIMIT` decline too, keeping the carrier-size convention.
+        # `ConstantFolding::STRING_FOLD_BYTE_LIMIT` decline too, keeping the carrier-size convention,
+        # and a field width or precision past it declines before the string is built (#2125).
         def fold_format_constant(args)
           return nil unless args.all?(Type::Constant)
           return nil unless args.first.value.is_a?(String)
 
-          result = format(args.first.value, *args.drop(1).map(&:value))
+          values = args.drop(1).map(&:value)
+          return nil if ConstantFolding.format_blow_up?(args.first.value, values)
+
+          result = format(args.first.value, *values)
           return nil if result.bytesize > ConstantFolding::STRING_FOLD_BYTE_LIMIT
 
           Type::Combinator.constant_of(result)

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