rigortype 0.3.8 → 0.4.0

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

@@ -214,7 +214,6 @@ module Rigor
         # survives the call.
         CONSTANT_SELF_RETURNERS = %i[freeze itself dup clone].to_set.freeze
 
-        # @return [Rigor::Type::Constant, Rigor::Type::Union, Rigor::Type::IntegerRange, nil]
         def try_dispatch(context)
           receiver = context.receiver
           method_name = context.method_name
@@ -234,15 +233,8 @@ module Rigor
             first_arg = args.first
             return nil unless first_arg.is_a?(Type::Constant) && first_arg.value.is_a?(Symbol)
           end
-          self_return = try_fold_self_return(receiver, method_name, args)
-          return self_return if self_return
-
-          # v0.0.7 — `String#%` against a `Tuple` / `HashShape` argument runs Ruby's format-string engine
-          # when both sides are statically constant. The standard `numeric_set_of` path bails on Tuple /
-          # HashShape arguments because they are not scalar-Constant carriers, so the special-case sits
-          # ahead of the numeric path.
-          format_lift = try_fold_string_format(receiver, method_name, args)
-          return format_lift if format_lift
+          ahead = try_fold_ahead_of_numeric_path(receiver, method_name, args)
+          return ahead if ahead
 
           receiver_set = numeric_set_of(receiver)
           return nil unless receiver_set
@@ -253,6 +245,20 @@ module Rigor
           dispatch_by_arity(receiver_set, method_name, arg_sets)
         end
 
+        # The folds that must answer before `numeric_set_of` gets a say, because the receiver or an
+        # argument is a carrier it declines:
+        #
+        # - the self-returners, whose receiver may be any `Constant`;
+        # - v0.0.7's `String#%` against a `Tuple` / `HashShape` argument, neither a scalar-Constant
+        #   carrier, which runs Ruby's own format-string engine;
+        # - #861's `clamp` on a plain `Integer` / `Float` receiver, a `Nominal` that `numeric_set_of`
+        #   declines outright.
+        def try_fold_ahead_of_numeric_path(receiver, method_name, args)
+          try_fold_self_return(receiver, method_name, args) ||
+            try_fold_string_format(receiver, method_name, args) ||
+            try_fold_unbounded_clamp(receiver, method_name, args)
+        end
+
         # `freeze` / `itself` / `dup` / `clone` on a value-pinned receiver return the receiver carrier.
         #
         # This sits AHEAD of the catalogue path and deliberately bypasses its purity gate, because the gate
@@ -344,11 +350,13 @@ module Rigor
             return type.members.map(&:value) if type.members.all?(Type::Constant)
 
             # A union that mixes `Constant<Integer>` and `IntegerRange` members (e.g. an accumulator's
-            # running fixpoint assumption `1 | int<1, 6>`) folds as the bounding interval. The
+            # running fixpoint assumption `1 | Integer[1..6]`) folds as the bounding interval. The
             # range-arithmetic path (`try_fold_binary_range`) then keeps the result an `IntegerRange`
             # instead of bailing to Dynamic.
             union_integer_bounds(type)
-          when Type::IntegerRange then type
+          # ADR-109 — a bounded Float folds through its own arms (`try_fold_unary_float_range`,
+          # `try_fold_ternary_float_range`, `try_fold_clamp_range`); every other arm declines it.
+          when Type::IntegerRange, Type::FloatRange then type
           end
         end
 
@@ -390,11 +398,15 @@ module Rigor
           case set
           when Array              then try_fold_unary_set(set, method_name)
           when Type::IntegerRange then try_fold_unary_range(set, method_name)
+          when Type::FloatRange   then try_fold_unary_float_range(set, method_name)
           end
         end
 
         def try_fold_binary(left, method_name, right)
           return try_fold_divmod(left, right) if method_name == :divmod
+          return try_fold_clamp_range(left, right) if method_name == :clamp && bounded_range?(left)
+          # ADR-109 — no Float-range arithmetic yet; a bounded Float on either side declines here.
+          return nil if left.is_a?(Type::FloatRange) || right.is_a?(Type::FloatRange)
 
           if left.is_a?(Type::IntegerRange) || right.is_a?(Type::IntegerRange)
             try_fold_binary_range(left, method_name, right)
@@ -403,6 +415,133 @@ module Rigor
           end
         end
 
+        def bounded_range?(type)
+          type.is_a?(Type::IntegerRange) || type.is_a?(Type::FloatRange)
+        end
+
+        # #834 — `clamp(range)` on a bounded receiver, the one-argument twin of `range_clamp` /
+        # `float_range_clamp`. An exclusive end raises at run time (`cannot clamp with an exclusive
+        # range`), so it declines rather than folding a call that does not return; a missing end keeps
+        # the receiver's own bound on that side. The bracket's endpoints must be literals of the
+        # receiver's class.
+        def try_fold_clamp_range(receiver, right)
+          bracket = clamp_bracket(right)
+          return nil if bracket.nil?
+
+          lower, upper = bracket
+          case receiver
+          when Type::IntegerRange
+            return nil unless clamp_endpoints_are?(Integer, lower, upper)
+
+            range_clamp(receiver, lower || receiver.lower, upper || receiver.upper)
+          when Type::FloatRange
+            return nil unless clamp_endpoints_are?(Numeric, lower, upper)
+
+            float_range_clamp(receiver, lower, upper)
+          end
+        end
+
+        # `[lower, upper]` of a single literal, closed, non-reversed `Range` argument (either side may be
+        # `nil` for an open range); `nil` for any other shape.
+        def clamp_bracket(right)
+          return nil unless right.is_a?(Array) && right.size == 1 && right.first.is_a?(Range)
+
+          bracket = right.first
+          return nil if bracket.exclude_end? && !bracket.end.nil?
+
+          lower = bracket.begin
+          upper = bracket.end
+          return nil if lower && upper && lower > upper
+
+          [lower, upper]
+        end
+
+        def clamp_endpoints_are?(klass, lower, upper)
+          (lower.nil? || lower.is_a?(klass)) && (upper.nil? || upper.is_a?(klass))
+        end
+
+        # #861 — `clamp` on a receiver that carries no bracket of its own. `Comparable#clamp` returns a
+        # value inside the bracket whatever the receiver's bounds are, so a plain `Integer` / `Float`
+        # receiver takes the bracket entire: `i.clamp(1..9)` and `i.clamp(1, 9)` are `Integer[1..9]`
+        # where the RBS tier's `self | A` could only say `Integer` (resp. `1 | 9 | Integer`).
+        #
+        # Endpoints must be literals of the receiver's own class. A mixed bracket is `Comparable`'s
+        # business rather than the fold's: `1.clamp(0.5, 2.5)` returns the receiver OR a bound, so the
+        # run-time class is a union across `Integer` and `Float`, and it declines here.
+        #
+        # `Float` covers `NaN` while a `FloatRange` never does — sound in this direction, because
+        # `clamp` on a NaN receiver raises (`comparison of Float with Float failed`) and the call that
+        # returns is always inside the bracket.
+        #
+        # The two run-time raisers `clamp_bracket` already declines — an exclusive end (`cannot clamp
+        # with an exclusive range`) and a reversed bracket — keep declining here.
+        def try_fold_unbounded_clamp(receiver, method_name, args)
+          return nil unless method_name == :clamp
+
+          klass = unbounded_clamp_receiver_class(receiver)
+          return nil unless klass
+
+          case args.size
+          when 1 then fold_unbounded_clamp_range(klass, args.first)
+          when 2 then fold_unbounded_clamp_pair(klass, args)
+          end
+        end
+
+        # `Integer` / `Float` for a bare nominal receiver of that class; `nil` for everything else,
+        # the bounded carriers included — those keep their own intersecting folds.
+        def unbounded_clamp_receiver_class(receiver)
+          return nil unless receiver.is_a?(Type::Nominal) && receiver.type_args.empty?
+
+          case receiver.class_name
+          when "Integer" then Integer
+          when "Float" then Float
+          end
+        end
+
+        def fold_unbounded_clamp_range(klass, arg)
+          bracket = clamp_bracket(numeric_set_of(arg))
+          return nil if bracket.nil?
+
+          lower, upper = bracket
+          return nil unless clamp_endpoints_are?(klass, lower, upper)
+          return nil if clamp_bound_nan?(lower) || clamp_bound_nan?(upper)
+
+          unbounded_clamp_result(klass, lower, upper)
+        end
+
+        def fold_unbounded_clamp_pair(klass, args)
+          values = args.map { |arg| single_clamp_bound(klass, numeric_set_of(arg)) }
+          lower, upper = values
+          return nil if lower.nil? || upper.nil?
+          return nil if lower > upper
+
+          unbounded_clamp_result(klass, lower, upper)
+        end
+
+        # The two-argument form takes no `nil` bound: `clamp(nil, 9)` is `Comparable`'s own
+        # one-sided form, which the catalogue does not route here.
+        def single_clamp_bound(klass, values)
+          return nil unless values.is_a?(Array) && values.size == 1
+
+          value = values.first
+          return nil unless value.is_a?(klass)
+
+          clamp_bound_nan?(value) ? nil : value
+        end
+
+        # A NaN bound orders against nothing, so `clamp` raises for it — no bracket to fold to.
+        def clamp_bound_nan?(bound)
+          bound.is_a?(Float) && bound.nan?
+        end
+
+        def unbounded_clamp_result(klass, lower, upper)
+          if klass == Integer
+            build_integer_range(lower || -Float::INFINITY, upper || Float::INFINITY)
+          else
+            Type::Combinator.float_range(lower || -Float::INFINITY, upper || Float::INFINITY)
+          end
+        end
+
         # `Integer#divmod` and `Float#divmod` return a 2-element array `[quotient, remainder]`. We project
         # that into `Tuple[Constant[q], Constant[r]]` so downstream rules see the precise element types.
         # Union/range receivers are widened per-position: each tuple slot carries the union of quotients
@@ -870,16 +1009,70 @@ module Rigor
         # could not reach.
         #
         # v0.0.6 — IntegerRange-shaped receivers participate in `Comparable#between?` and
-        # `Comparable#clamp` folds. `int<a,b>.between?(min, max)` decides three-valued via the receiver's
-        # bounds against scalar args; `int<a,b>.clamp` narrows the receiver's bounds against the bracket.
+        # `Comparable#clamp` folds. `Integer[a..b].between?(min, max)` decides three-valued via the receiver's
+        # bounds against scalar args; `Integer[a..b].clamp` narrows the receiver's bounds against the bracket.
         # Other ternary methods over IntegerRange operands still decline.
         def try_fold_ternary(receiver_set, method_name, arg_sets)
           return try_fold_ternary_range(receiver_set, method_name, arg_sets) if receiver_set.is_a?(Type::IntegerRange)
-          return nil if arg_sets.any?(Type::IntegerRange)
+          if receiver_set.is_a?(Type::FloatRange)
+            return try_fold_ternary_float_range(receiver_set, method_name, arg_sets)
+          end
+          return nil if arg_sets.any? { |s| bounded_range?(s) }
 
           try_fold_ternary_set(receiver_set, method_name, arg_sets)
         end
 
+        # ADR-109 — receiver `FloatRange` + two scalar numeric args: `between?` decides three-valued
+        # over the bracket, `clamp` narrows to the bracket (NaN never inhabits the receiver, so the
+        # comparison that would raise on NaN cannot).
+        def try_fold_ternary_float_range(range, method_name, arg_sets)
+          return nil unless arg_sets.all?(Array)
+
+          min_arg = single_real_arg(arg_sets[0])
+          max_arg = single_real_arg(arg_sets[1])
+          return nil if min_arg.nil? || max_arg.nil?
+          return nil if min_arg > max_arg
+
+          case method_name
+          when :between? then float_range_between(range, min_arg, max_arg)
+          when :clamp then float_range_clamp(range, min_arg, max_arg)
+          end
+        end
+
+        def single_real_arg(values)
+          return nil unless values.is_a?(Array) && values.size == 1
+
+          v = values.first
+          return nil unless v.is_a?(Integer) || (v.is_a?(Float) && !v.nan?)
+
+          v
+        end
+
+        def float_range_between(range, min_arg, max_arg)
+          return Type::Combinator.constant_of(false) if range.canonical_max < min_arg || range.min > max_arg
+          return Type::Combinator.constant_of(true) if range.min >= min_arg && range.canonical_max <= max_arg
+
+          bool_union
+        end
+
+        # `Float[a..b].clamp(lo, hi)` (either bound may be `nil` for the one-argument `clamp(lo..)` /
+        # `clamp(..hi)` forms). Keeps the receiver's own end, exclusivity included, where it is the
+        # tighter one. When the bracket lies wholly outside the receiver every value snaps to one bound
+        # and the result is a point Rigor would have to invent, so it declines like the Integer twin.
+        def float_range_clamp(range, min_arg, max_arg)
+          new_min = min_arg.nil? ? range.min : [range.min, min_arg.to_f].max
+          if max_arg.nil? || max_arg.to_f >= range.canonical_max
+            new_max = range.max
+            exclusive = range.exclude_end?
+          else
+            new_max = max_arg.to_f
+            exclusive = false
+          end
+          return nil if new_min > (exclusive ? new_max.prev_float : new_max)
+
+          Type::Combinator.float_range(new_min, new_max, exclude_end: exclusive)
+        end
+
         # Receiver IntegerRange + two scalar `Constant<Integer>` args — the only IntegerRange-aware ternary
         # fold today. `between?` returns Trinary truthiness over the bracket; `clamp` returns the
         # intersected IntegerRange (or a collapsed Constant if the result pins a single point).
@@ -904,7 +1097,7 @@ module Rigor
           v.is_a?(Integer) ? v : nil
         end
 
-        # `int<a,b>.between?(min, max)`:
+        # `Integer[a..b].between?(min, max)`:
         # - Constant[true] when [a,b] ⊆ [min,max] (and finite).
         # - Constant[false] when [a,b] ∩ [min,max] is empty.
         # - bool union otherwise.
@@ -916,7 +1109,7 @@ module Rigor
           bool_union
         end
 
-        # `int<a,b>.clamp(min, max)`:
+        # `Integer[a..b].clamp(min, max)`:
         # - new_lower = max(a, min), new_upper = min(b, max).
         # - When new_lower > new_upper the bracket excluded the range entirely; the call still returns one
         #   of the bracket bounds at runtime, but Rigor is strictly less precise here than Ruby — decline
@@ -1112,8 +1305,8 @@ module Rigor
         end
 
         # Range % Range. Only the `(any range) % (positive constant n)` and `(any range) % (negative
-        # constant n)` cases are folded precisely — the former narrows to `int<0, n-1>`, the latter to
-        # `int<n+1, 0>`. Other shapes fall back to nil.
+        # constant n)` cases are folded precisely — the former narrows to `Integer[0..n-1]`, the latter to
+        # `Integer[n+1..0]`. Other shapes fall back to nil.
         def range_modulo(_left, right)
           return nil unless right.finite? && right.min == right.max
 
@@ -1220,6 +1413,99 @@ module Rigor
         }.freeze
         private_constant :UNARY_RANGE_DIRECT
 
+        # ADR-109 — unary folds over a bounded Float. No bounded range contains NaN, so the predicates
+        # that exist to detect it are decided outright, and the monotone conversions map the two bounds.
+        # An exclusive end is dropped where negation would turn it into an exclusive begin, a shape
+        # Ruby's literal cannot spell: the result is the closed envelope, a superset.
+        FLOAT_RANGE_UNARY = {
+          abs: :float_range_abs,
+          magnitude: :float_range_abs,
+          "-@": :float_range_negate,
+          "+@": :float_range_identity,
+          to_f: :float_range_identity,
+          nan?: :float_range_never_nan,
+          finite?: :float_range_finite,
+          zero?: :float_range_zero,
+          positive?: :float_range_positive,
+          negative?: :float_range_negative,
+          floor: :float_range_to_integer,
+          ceil: :float_range_to_integer,
+          round: :float_range_to_integer,
+          truncate: :float_range_to_integer,
+          to_i: :float_range_to_integer
+        }.freeze
+        private_constant :FLOAT_RANGE_UNARY
+
+        def try_fold_unary_float_range(range, method_name)
+          handler = FLOAT_RANGE_UNARY[method_name]
+          return nil if handler.nil?
+
+          send(handler, range, method_name)
+        end
+
+        def float_range_abs(range, _method_name)
+          lower = range.min
+          upper = range.canonical_max
+          return range if lower >= 0.0
+          return Type::Combinator.float_range(-upper, -lower) if upper <= 0.0
+
+          Type::Combinator.float_range(0.0, [-lower, upper].max)
+        end
+
+        def float_range_negate(range, _method_name)
+          Type::Combinator.float_range(-range.canonical_max, -range.min)
+        end
+
+        def float_range_identity(range, _method_name)
+          range
+        end
+
+        def float_range_never_nan(_range, _method_name)
+          Type::Combinator.constant_of(false)
+        end
+
+        def float_range_finite(range, _method_name)
+          lower = range.min
+          upper = range.canonical_max
+          return Type::Combinator.constant_of(true) if lower.finite? && upper.finite?
+          return Type::Combinator.constant_of(false) if lower == upper
+
+          bool_union
+        end
+
+        def float_range_zero(range, _method_name)
+          return Type::Combinator.constant_of(false) unless range.covers?(0.0)
+          return Type::Combinator.constant_of(true) if range.min.zero? && range.canonical_max.zero?
+
+          bool_union
+        end
+
+        # `Float#positive?` is `self > 0`, `negative?` is `self < 0`.
+        def float_range_positive(range, _method_name)
+          return Type::Combinator.constant_of(true) if range.min > 0.0
+          return Type::Combinator.constant_of(false) if range.canonical_max <= 0.0
+
+          bool_union
+        end
+
+        def float_range_negative(range, _method_name)
+          return Type::Combinator.constant_of(true) if range.canonical_max < 0.0
+          return Type::Combinator.constant_of(false) if range.min >= 0.0
+
+          bool_union
+        end
+
+        # `floor` / `ceil` / `round` / `truncate` / `to_i` are monotone, so the image of the range is the
+        # integer range between the images of its bounds. An infinite bound raises `FloatDomainError` at
+        # run time for the value that reaches it, so the fold declines and the RBS `Integer` stands.
+        def float_range_to_integer(range, method_name)
+          lower = range.min
+          upper = range.canonical_max
+          return nil if lower.infinite? || upper.infinite?
+
+          build_integer_range(lower.public_send(method_name), upper.public_send(method_name))
+        end
+
         def try_fold_unary_range(range, method_name)
           return range_unary_predicate(range, method_name) if RANGE_UNARY_PREDICATES.include?(method_name)
           return range_unary_shift(range, method_name) if RANGE_UNARY_SHIFTS.include?(method_name)

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

@@ -31,7 +31,7 @@ module Rigor
         # and the reader-redefinition guard are shared with {StructFolding}.
         extend MemberShapeProjection
 
-        # @return [Rigor::Type, nil] the folded result, or nil to defer.
+        # @return the folded result, or nil to defer.
         def try_dispatch(context)
           receiver = context.receiver
 

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

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+require_relative "../../rbs_extended"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # Issue #1350 — how `OverloadSelector` reads a `Dynamic[T]` argument. The internal spec keeps a `Dynamic` whose
+      # static facet is not `top` out of the imprecise arguments because its facet discriminates, but acceptance
+      # short-circuits on the wrapper and takes it against any parameter, so the receiver-affinity pre-sort's first arm
+      # won: `Money#add(Integer(v))` typed `Money` and `.even?` reported `call.undefined-method`.
+      #
+      # Selection therefore reads a narrow facet's members ({.select}), leaving out `nil`: a facet's `nil` is usually
+      # the join of an overload that returns it for some untyped input (`Integer(v)`'s `exception:` form), and chosen
+      # by it `Integer | nil` fell through to the only arm that takes `nil` and `Complex(Integer(v), 1)` turned
+      # `Complex?`. One member left stands in for the argument, pass 0 included, and the return stays unwrapped; two
+      # are selected one by one, and the distinct picks come back together for the dispatch layer's join, wrapped in
+      # `Dynamic` when their returns differ (#521).
+      #
+      # Only sealed members are read ({.sealed?}): a literal, or a plain `Integer`, `Float`, `Rational`, `Complex` or
+      # `Symbol`, core classes whose `new` and `allocate` are undefined. Such a member's runtime value is of exactly its
+      # class, where any other member's may be of a subclass and take an arm the member itself skips: `Numeric` in
+      # `2 ** v`'s `Complex | Numeric` skipped a project `(real) -> Float`, whose `real` alias names `Integer`, for a
+      # catch-all `(untyped) -> nil`, and `.floor` on the call reported `call.undefined-method`. Scanning the parameters
+      # for a subclass of the member caught a plain class name and missed aliases, `instance`, type variables,
+      # intersections, singletons and modules.
+      #
+      # Even a sealed member is read only where acceptance can rule it out ({.provable?}). Acceptance reads class
+      # relations from the analyzer's own process, so it answers `no` for `Integer` against a `(Printable)` that project
+      # RBS or source includes into `Integer` (#1352). A plain argument shares that, but the wrapper hid it from a
+      # `Dynamic` one: with `(Printable) -> String | (Integer) -> Integer`, reading the member typed
+      # `fmt(Integer(v)).upcase` as `Integer` and fired `call.undefined-method` where master read `String`. So every
+      # overload's positional parameters must be spelled as a class RBS declares, `untyped`, `top` or `nil`, through `?`
+      # and `|`, which leaves acceptance only a sealed class's fixed ancestry to read. A literal or `bool` parameter
+      # asks for a value, which a class member cannot prove it holds: `Symbol` skipped `(:json) -> String` for
+      # `(untyped) -> nil`, and a `TrueClass` member was refused by `bool` itself. Anything else, a module, a stubbed
+      # name, an alias, an interface, a type variable, `instance`, `self`, an intersection, a singleton or an untyped
+      # `(?)`, keeps the wrapper too. The list names what is provable rather than what is not, so a form it has not met
+      # falls back to master's reading.
+      #
+      # A wider facet keeps the wrapper and the receiver's arm, as before. It is usually itself a #521 join
+      # (`Dynamic[BigDecimal | Complex | Float | Integer | Rational]` from `n * untyped`), and read member by member it
+      # joined every arm again: 256 call sites across the survey corpus lost a precise type to `Dynamic`, and a
+      # recursion's fuel-exhausted `n * of(n - 1)` stopped reading `Integer`.
+      module FacetDistribution
+        # The most facet members, `nil` aside, that selection reads one by one.
+        MEMBER_LIMIT = 2
+        # Member-wise argument lists beyond this keep their wrappers.
+        CAP = 8
+        # Core classes whose `new` and `allocate` are undefined, so plain Ruby cannot make an instance of a subclass
+        # (`Integer`, `Float` and `Symbol` have no allocator at all; a `Rational` or `Complex` subclass instance takes
+        # `Marshal.load` or a rebound `Class#allocate`). `NilClass` leaves with the facet's `nil`, and `true` and
+        # `false` are read only as literals.
+        SEALED_CLASSES = %w[Integer Float Rational Complex Symbol].freeze
+
+        module_function
+
+        # Whether any argument is a `Dynamic` whose facet selection reads; the cheap guard of the hot path.
+        def faceted?(arg_types) = arg_types.any? { |arg| arg.is_a?(Type::Dynamic) && facet_members(arg) }
+
+        # Selects through the block, called as `yield(arg_types, member)`. It yields once per member-wise list, one
+        # member standing in for each faceted argument, with `member` true so the block answers only a genuine match.
+        # It yields once with the arguments as given instead when the overloads are not {.provable?}, when an argument
+        # has two members and the caller is the singular `select` (`member_wise` false, whose one answer a member order
+        # would decide), when there are more than {CAP} lists, or when any list matches nothing.
+        def select(arg_types, definition, member_wise:, environment:, &)
+          choices = arg_types.map { |arg| facet_members(arg) || [arg] }
+          return yield(arg_types, false) unless member_wise || choices.all? { |members| members.size == 1 }
+          return yield(arg_types, false) unless provable?(definition, environment)
+
+          picks = picks_by_member(choices, &)
+          picks.empty? ? yield(arg_types, false) : picks
+        end
+
+        # The distinct overloads the member-wise lists pick; none past {CAP} or when any list picks nothing.
+        def picks_by_member(choices)
+          return [] if choices.reduce(1) { |count, members| count * members.size } > CAP
+
+          lists = choices.first.product(*choices.drop(1)).map { |combination| yield(combination, true) }
+          lists.any?(&:empty?) ? [] : lists.flatten(1).uniq(&:object_id)
+        end
+
+        # Whether every overload's positional parameters, rest and trailing included, are in a provable form
+        # ({.provable_param?}), where acceptance's answer for a sealed member rests only on the member class's fixed
+        # ancestry; a `rigor:v1:param:` override proves nothing either.
+        def provable?(definition, environment)
+          loader = environment&.rbs_loader
+          return false if loader.nil?
+          return false unless RbsExtended.param_type_override_map(definition, environment: environment).empty?
+
+          definition.method_types.all? do |method_type|
+            fun = method_type.type
+            next false unless fun.respond_to?(:required_positionals)
+
+            params = fun.required_positionals + fun.optional_positionals + fun.trailing_positionals
+            params += [fun.rest_positionals] if fun.rest_positionals
+            params.all? { |param| provable_param?(param.type, loader) }
+          end
+        end
+
+        def provable_param?(rbs_type, loader)
+          case rbs_type
+          when RBS::Types::ClassInstance then declared_class?(rbs_type.name.to_s.delete_prefix("::"), loader)
+          when RBS::Types::Optional then provable_param?(rbs_type.type, loader)
+          when RBS::Types::Union then rbs_type.types.all? { |member| provable_param?(member, loader) }
+          when RBS::Types::Bases::Any, RBS::Types::Bases::Top, RBS::Types::Bases::Nil then true
+          else false
+          end
+        end
+
+        # A class RBS declares, not a module and not a name Rigor stubbed because no RBS declares it: a class cannot be
+        # included, and a sealed member's class has a fixed ancestry, so acceptance's answer against it holds.
+        def declared_class?(name, loader)
+          loader.class_known?(name) && !loader.rbs_module?(name) && !loader.synthesized_type_names.include?(name)
+        end
+
+        # A `Dynamic` argument's facet members other than `nil`, or nil when selection keeps the wrapper: not a
+        # `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)
+
+          facet = arg.static_facet
+          members = (facet.is_a?(Type::Union) ? facet.members : [facet]).reject { |member| nil_value?(member) }
+          members if members.size.between?(1, MEMBER_LIMIT) && members.all? { |member| sealed?(member) }
+        end
+
+        # A member whose runtime value is of exactly its class: a `Constant`, which is a value of that exact class, or a
+        # plain instance of {SEALED_CLASSES}.
+        def sealed?(member)
+          case member
+          when Type::Constant then true
+          when Type::Nominal then member.type_args.empty? && SEALED_CLASSES.include?(member.class_name)
+          else false
+          end
+        end
+
+        def nil_value?(type)
+          return type.value.nil? if type.is_a?(Type::Constant)
+
+          type.is_a?(Type::Nominal) && type.class_name == "NilClass"
+        end
+      end
+    end
+  end
+end

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

@@ -73,7 +73,7 @@ module Rigor
 
         module_function
 
-        # @return [Rigor::Type, nil] folded result, or nil to defer
+        # @return folded result, or nil to defer
         #   to the next dispatcher tier.
         def try_dispatch(context)
           receiver = context.receiver