rigortype 0.4.6 → 0.4.8

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/core_enumerable_receiver.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # Issue #3242 — whether a receiver's `find` / `detect` / `find_index` / `count` / `all?` / `any?` / `none?`
+      # may be other than core's. {BlockFolding}'s constant-block folds for those methods read no receiver shape, so
+      # they answer core's semantics, and they are sound only on a carrier known to be a core collection or
+      # enumerable. Anything else may define the method itself: a project class (`class Bag; def find = (yield; 8);
+      # end`), a subclass of a core class (its own `Nominal`), a class object (`def self.find`), a `Data.define` or
+      # `Struct.new` class, or a scalar that has no such method at all.
+      module CoreEnumerableReceiver
+        module_function
+
+        # The nominal receivers whose methods above are core's: Array's, Hash's, Set's, Range's own, or
+        # Enumerable's. `RBS::Unnamed::ENVClass` is `ENV`, which extends Enumerable.
+        NOMINALS = Ractor.make_shareable(
+          Set[
+            "Array", "Hash", "Set", "Range", "Enumerable", "Enumerator", "Enumerator::Lazy",
+            "Enumerator::ArithmeticSequence", "Enumerator::Chain", "Enumerator::Product", "Dir",
+            "RBS::Unnamed::ENVClass"
+          ].freeze
+        )
+
+        # False only for a carrier known to be a core collection or enumerable: a `Tuple` / `HashShape` literal
+        # shape, a `Constant` `Range` or `Set`, a `Nominal` in {NOMINALS}, `Top`, and a `Dynamic` / `Difference` /
+        # `Refined` / `Union` / `Intersection` over those. Every other receiver is true, so the folds decline.
+        def project_receiver?(receiver)
+          case receiver
+          when Type::Tuple, Type::HashShape, Type::Top then false
+          when Type::Constant then !(receiver.value.is_a?(Range) || receiver.value.is_a?(::Set))
+          when Type::Nominal then !NOMINALS.include?(receiver.class_name)
+          when Type::Difference, Type::Refined then project_receiver?(receiver.base)
+          when Type::Union, Type::Intersection then receiver.members.any? { |member| project_receiver?(member) }
+          when Type::Dynamic then project_receiver?(receiver.static_facet)
+          else true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require_relative "../../reflection"
+require_relative "../../type"
+require_relative "argument_nodes"
+require_relative "overload_selector"
+require_relative "rbs_dispatch"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # Issue #2884 — `X.new` through a `def self.new` that a project, gem or collection signature declares on `X` or
+      # on an ancestor of `X`. RBS models a constructor that answers another class this way (`email_address` declares
+      # `def self.new: (...) -> Address` on `EmailAddress`), and `MethodDispatcher#meta_new` answered `Nominal[X]` for
+      # every `Singleton[X].new` before any RBS tier ran. `meta_new` asks this module only after its curated lifts
+      # (`Array`, `Set`, `Hash`, `Struct`, `Class.new`, …) have declined, and keeps its `Nominal[X]` answer whenever
+      # this one is nil.
+      #
+      # The declaration counts only when it is an explicit `def self.new` (not the `new` RBS builds from `initialize`),
+      # every one of its definitions sits outside the `rbs` gem's core and stdlib trees
+      # ({Environment::RbsLoader#declared_outside_core_stdlib?}), and the class carrying it is not one core or stdlib
+      # declares. Core declares `Data.new: () -> bot` and `Ractor.new: … -> Ractor`, stdlib `Tempfile.new`; a project
+      # class inheriting one of those keeps the `Nominal` answer the curated tiers were written around.
+      #
+      # The declaration is found on `X`'s own RBS (which carries its RBS ancestors' singleton methods), or, for a
+      # Ruby-source class with no RBS of its own, on the first RBS-known class of its singleton
+      # {Scope::ResolutionChain}. A project entry ahead of it that defines `new` ends the walk with no answer: that
+      # method is the one Ruby runs. An inherited declaration that answers the instance
+      # ({Environment::RbsLoader#answers_instance_for_subclass?}) answers `Nominal[X]`; otherwise `instance`, and an
+      # overload returning the declaring class itself, read the receiver class, and `self` reads its class object.
+      #
+      # Nil (so `Nominal[X]`) when no overload takes the arguments (argument checking of `.new` is not this tier's
+      # job), and when the return translates to an untyped, `top` or `bot` answer, which would lose the precision
+      # `Nominal[X]` already has.
+      module DeclaredConstructor
+        # An entry of the singleton chain ahead of any declaring class defines `new` itself (in Ruby source, or as an
+        # `extend`ed module's RBS instance method), so that method is the one Ruby runs and the walk answers nothing.
+        OTHER_NEW = :other_new
+        private_constant :OTHER_NEW
+
+        module_function
+
+        def try_dispatch(class_name, context)
+          environment = context.environment
+          loader = environment&.rbs_loader
+          return nil if loader.nil? || !loader.respond_to?(:honoured_singleton_new?)
+
+          definition = declared_new(class_name, environment, loader, context.scope)
+          return nil if definition.nil? || !overload_matches?(definition, class_name, context)
+
+          owner = definition.defined_in.to_s.delete_prefix("::")
+          # The same test the walk's gate reads ({Environment::RbsLoader#singleton_new_departs_from_instance?}), so
+          # an inherited declaration that answers the instance answers `Nominal[receiver]` whether or not the gate let
+          # the walk run.
+          return nil if owner != class_name && loader.answers_instance_for_subclass?(definition)
+
+          answer = RbsDispatch.declared_singleton_return(context, definition, class_name)
+          answer = repoint_owner(answer, owner, class_name)
+          answer if usable?(answer)
+        end
+
+        class << self
+          private
+
+          def declared_new(class_name, environment, loader, scope)
+            owner = declaring_class(class_name, environment, loader, scope)
+            return nil if owner.nil?
+
+            definition = Rigor::Reflection.singleton_method_definition(owner, :new, environment: environment)
+            definition if definition && loader.honoured_singleton_new?(definition)
+          end
+
+          # `class_name` itself when RBS knows it; else the first RBS-known class on its singleton
+          # {Scope::ResolutionChain}, read in Ruby's order. Nil when a project entry ahead of it defines `new` (a
+          # `def self.new`, or an `extend`ed module's `def new`), when the chain reaches none, and when the chain does
+          # not stand (a fork or an unplaced mixin edge, where the tables cannot say which world ran).
+          #
+          # The walk runs only when some loaded declaration fails {Environment::RbsLoader#answers_instance_for_subclass?}
+          # ({Environment::RbsLoader#singleton_new_departs_from_instance?}); `try_dispatch` answers `Nominal[X]` for an
+          # inherited declaration that passes it, so without one the walk could change nothing. When it runs
+          # it files its reads whatever it answers: a later edit that puts such a declaration on the chain changes
+          # the answer, and the caller must be re-checked then.
+          def declaring_class(class_name, environment, loader, scope)
+            return class_name if Rigor::Reflection.rbs_class_known?(class_name, environment: environment)
+            return nil if scope.nil? || !loader.singleton_new_departs_from_instance?
+
+            chain = Scope::ResolutionChain.for(scope, class_name.to_s, :singleton, :methods)
+            found = first_new_owner(chain, scope, environment)
+            verdict = chain.settle(scope, found, owner: nil) { |retro| first_new_owner(retro, scope, environment) }
+            found unless found.nil? || found == OTHER_NEW || verdict != :chain
+          end
+
+          # The first entry on `chain` that answers `new`: an RBS-known class's name, or {OTHER_NEW} for an entry that
+          # defines it otherwise. An `extend`ed module is not a class object `new` is declared on, but one whose
+          # instance side declares `new` (in Ruby source or in RBS) puts that method ahead of the superclass's, so it
+          # stops the walk.
+          def first_new_owner(chain, scope, environment)
+            chain.search(scope) do |entry|
+              if entry.external?
+                extended_rbs_new = !entry.superclass_edge && rbs_instance_new?(entry.candidates, environment)
+                next OTHER_NEW if extended_rbs_new
+                next unless entry.superclass_edge
+
+                entry.candidates.find { |name| Rigor::Reflection.rbs_class_known?(name, environment: environment) }
+              elsif entry.side == :singleton && Rigor::Reflection.rbs_class_known?(entry.name, environment: environment)
+                entry.name
+              elsif scope.discovered_method?(entry.name, :new, entry.side) ||
+                    (entry.side == :instance && rbs_instance_new?([entry.name], environment))
+                OTHER_NEW
+              end
+            end
+          end
+
+          def rbs_instance_new?(names, environment)
+            names.any? { |name| Rigor::Reflection.instance_method_definition(name, :new, environment: environment) }
+          end
+
+          # A genuine match only: the selector's first-overload fallback would answer a declaration the call does
+          # not take.
+          def overload_matches?(definition, class_name, context)
+            args = context.args || []
+            !OverloadSelector.select_declared(
+              definition, args, Type::Combinator.singleton_of(class_name), Type::Combinator.nominal_of(class_name),
+              {}, !context.block_type.nil?, context.environment, true,
+              ArgumentNodes.keyword_hash_last?(context.call_node, args), nil, true
+            ).empty?
+          end
+
+          # A return naming the declaring class itself (`def self.new: [T] (T) -> Box[T]`) is the constructor's own
+          # class, so a subclass inheriting it answers the subclass, as `instance` does; generic arguments name the
+          # owner's parameters and are dropped with it. A foreign return (`EmailAddress` -> `Address`) stays.
+          def repoint_owner(answer, owner, class_name)
+            return answer if owner == class_name
+
+            case answer
+            when Type::Nominal
+              answer.class_name == owner ? Type::Combinator.nominal_of(class_name) : answer
+            when Type::Union
+              Type::Combinator.union(*answer.members.map { |member| repoint_owner(member, owner, class_name) })
+            else answer
+            end
+          end
+
+          def usable?(answer)
+            !(answer.nil? || answer.is_a?(Type::Dynamic) || answer.is_a?(Type::Top) || answer.is_a?(Type::Bot))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -119,7 +119,7 @@ module Rigor
         # `Dynamic`, the untyped carrier, a facet that is only `nil`, one wider than {MEMBER_LIMIT}, or one with a
         # member that is not sealed, an untyped member included.
         def facet_members(arg)
-          return nil unless arg.is_a?(Type::Dynamic) && !arg.static_facet.is_a?(Type::Top)
+          return nil unless arg.is_a?(Type::Dynamic) && !Type::Combinator.untyped?(arg)
 
           facet = arg.static_facet
           members = (facet.is_a?(Type::Union) ? facet.members : [facet]).reject { |member| nil_value?(member) }

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

@@ -20,12 +20,12 @@ module Rigor
         module_function
 
         # The literal `untyped` carrier, `Dynamic[top]`.
-        def untyped?(type) = type.is_a?(Type::Dynamic) && type.static_facet.is_a?(Type::Top)
+        def untyped?(type) = Type::Combinator.untyped?(type)
 
         # The untyped carrier itself, or a union or `Dynamic` holding it at any depth.
         def imprecise?(type)
           case type
-          when Type::Dynamic then type.static_facet.is_a?(Type::Top) || imprecise?(type.static_facet)
+          when Type::Dynamic then Type::Combinator.untyped?(type) || imprecise?(type.static_facet)
           when Type::Union then type.members.any? { |member| imprecise?(member) }
           else false
           end

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

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../../type"
+require_relative "../../typing_state"
+require_relative "../../memo_audit"
+require_relative "argument_nodes"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # ADR-130 WD3 — the overload-shape rule for a call on a `Rigor::Plugin` interface value. The argument rules
+      # never check a call on a `Dynamic` receiver, so nothing else would notice a call no overload of the member
+      # takes; without this rule dispatch took whichever overload the selector's fallback picked, and that
+      # overload's return made the next call wrong (`xs.each.with_index` read the block overload's
+      # `Array[Integer]`). A call resolves only through the overloads that take its shape:
+      #
+      # - a block when the call passes one, and no required block when it does not;
+      # - the positional count, within required plus optional unless the overload has a rest parameter;
+      # - no required keyword the call omits.
+      #
+      # A shape the AST cannot state, a splat (`*xs`), a keyword splat (`**opts`) or a forwarded `...`, is taken
+      # by no overload, so the call reads `untyped` as it does on master.
+      module InterfaceShape
+        # ADR-130 WD5 — the dispatch-off flag {.without_dispatch} installs (`RbsDispatch.without_interface_dispatch`).
+        DISPATCH_OFF = TypingState.frame(
+          :interface_dispatch_off, reason: "a flag installed around a dispatch-off run (sig-gen, the parity harness)",
+                                   witness: "spec/fixtures/typing_state_witnesses/interface_erasure.rb"
+        )
+        private_constant :DISPATCH_OFF
+
+        module_function
+
+        # Runs the block with interface dispatch switched off.
+        def without_dispatch(&)
+          MemoAudit.check_run_level_install(:interface_dispatch_off)
+          TypingState.current.with(DISPATCH_OFF, true, &)
+        end
+
+        # False inside {.without_dispatch}.
+        def dispatch? = TypingState.current[DISPATCH_OFF] != true
+
+        # `definition` narrowed to the overloads that take the call's shape (the definition itself when every
+        # overload does), or nil when none does.
+        #
+        # Nil too when more than one overload takes the shape and one of them has a parameter that mentions `self`
+        # (`(self other)`, `(Array[self] others)`): which of them the call reaches depends on whether an argument is
+        # the receiver's kind, and the interface names no class acceptance could decide that against. Read as a
+        # precise overload, `x.same(1)` against `(self) -> Integer | (Integer) -> String` answered the first one's
+        # `Integer`; the call reads `untyped` instead.
+        def accepting(definition, args, block:, call_node:)
+          shape = call_shape(args, call_node)
+          return nil if shape.nil?
+
+          positional, keywords = shape
+          defs = definition.defs.select { |type_def| takes?(type_def.type, positional, keywords, block) }
+          return nil if defs.empty?
+          return nil if defs.size > 1 && defs.any? { |type_def| self_parameter?(type_def.type.type) }
+
+          defs.size == definition.defs.size ? definition : definition.update(defs: defs)
+        end
+
+        # True when a parameter type of `function` mentions RBS `self`, at any depth.
+        def self_parameter?(function)
+          return false unless function.respond_to?(:required_positionals)
+
+          params = function.required_positionals + function.optional_positionals + function.trailing_positionals +
+                   function.required_keywords.values + function.optional_keywords.values
+          params << function.rest_positionals if function.rest_positionals
+          params << function.rest_keywords if function.rest_keywords
+          params.any? { |param| mentions_self?(param.type) }
+        end
+
+        def mentions_self?(rbs_type)
+          return true if rbs_type.is_a?(RBS::Types::Bases::Self)
+
+          rbs_type.each_type { |inner| return true if mentions_self?(inner) }
+          false
+        end
+
+        # True when the call's block is a block-pass whose value may be nil at runtime, so the call may run
+        # block-less: `&blk` unless `blk` is provably not nil ({.never_nil?}), and an anonymous `&`, which forwards
+        # the enclosing method's own block. `&:sym` is never nil.
+        def nilable_block_pass?(call_node, scope)
+          block = call_node.respond_to?(:block) ? call_node.block : nil
+          return false unless block.is_a?(Prism::BlockArgumentNode)
+
+          expression = block.expression
+          return true if expression.nil?
+          return false if expression.is_a?(Prism::SymbolNode)
+          return true if scope.nil?
+
+          !never_nil?(scope.type_of(expression))
+        end
+
+        # The classes a value of which may be `nil`: `NilClass` and its ancestors.
+        NIL_ANCESTORS = %w[NilClass Object BasicObject Kernel].freeze
+        private_constant :NIL_ANCESTORS
+
+        # True only for a type that provably excludes `nil`: a non-nil literal, an instance of a class `nil` is not
+        # (a `Proc`, a `Method`), a class object, or a shape. `top`, `Dynamic`, `Object` and anything this does not
+        # list may be `nil` (ADR-130 WD3, as amended).
+        def never_nil?(type)
+          case type
+          when Type::Union then type.members.all? { |member| never_nil?(member) }
+          when Type::Constant then !type.value.nil?
+          when Type::Nominal then !NIL_ANCESTORS.include?(type.class_name)
+          when Type::Refined, Type::Difference then never_nil?(type.base)
+          when Type::Singleton, Type::Tuple, Type::HashShape, Type::BoundMethod, Type::IntegerRange, Type::FloatRange,
+               Type::DataInstance, Type::StructInstance, Type::DataClass, Type::StructClass then true
+          else false
+          end
+        end
+
+        # `[positional count, keyword names or nil]`, or nil for a shape the AST cannot state, which includes a keyword
+        # hash whose keys are not all literal symbols. The keyword names are nil when the call passes no keyword hash.
+        def call_shape(args, call_node)
+          arguments = call_node.respond_to?(:arguments) ? call_node.arguments&.arguments : nil
+          return [args.size, nil] if arguments.nil? || arguments.size != args.size
+          return nil if arguments.any? { |node| opaque_argument?(node) }
+          return [args.size, nil] unless ArgumentNodes.keyword_hash_last?(call_node, args)
+
+          names = keyword_names(arguments.last)
+          names && [args.size - 1, names]
+        end
+
+        def opaque_argument?(node)
+          case node
+          when Prism::SplatNode, Prism::ForwardingArgumentsNode then true
+          when Prism::KeywordHashNode then node.elements.any?(Prism::AssocSplatNode)
+          else false
+          end
+        end
+
+        # The literal keyword names of a keyword hash, or nil when one is not a literal symbol.
+        def keyword_names(hash_node)
+          hash_node.elements.map do |element|
+            key = element.key
+            return nil unless key.is_a?(Prism::SymbolNode)
+
+            key.unescaped.to_sym
+          end
+        end
+
+        def takes?(method_type, positional, keywords, block)
+          function = method_type.type
+          # `(...) -> T`: an untyped parameter list takes every call.
+          return block_taken?(method_type.block, block) unless function.respond_to?(:required_positionals)
+
+          block_taken?(method_type.block, block) && arguments_taken?(function, positional, keywords)
+        end
+
+        def block_taken?(declared, block)
+          block ? !declared.nil? : (declared.nil? || !declared.required)
+        end
+
+        def arguments_taken?(function, positional, keywords)
+          return positional_taken?(function, positional) && function.required_keywords.empty? if keywords.nil?
+          # A keyword hash an overload declares no keywords for is its last positional argument.
+          return positional_taken?(function, positional + 1) unless keywords?(function)
+
+          positional_taken?(function, positional) && function.required_keywords.keys.all? do |key|
+            keywords.include?(key)
+          end
+        end
+
+        def positional_taken?(function, count)
+          required = function.required_positionals.size + function.trailing_positionals.size
+          return false if count < required
+
+          !function.rest_positionals.nil? || count <= required + function.optional_positionals.size
+        end
+
+        def keywords?(function)
+          !function.required_keywords.empty? || !function.optional_keywords.empty? || !function.rest_keywords.nil?
+        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