rigortype 0.3.8 → 0.3.9

data/lib/rigor/inference/fork_map.rb

@@ -22,10 +22,10 @@ module Rigor
     module ForkMap
       module_function
 
-      # @param items [Array] work items (file paths, or `[path, ast]` pairs), in caller order.
-      # @param workers [Integer] resolved worker count (≤1, empty items, or no `fork` → sequential).
-      # @yield [Array] a contiguous slice of `items`; must return a **marshalable** object.
-      # @return [Array] the per-slice block results, in original slice order.
+      # @param items — work items (file paths, or `[path, ast]` pairs), in caller order.
+      # @param workers — resolved worker count (≤1, empty items, or no `fork` → sequential).
+      # @yield a contiguous slice of `items`; must return a **marshalable** object.
+      # @return the per-slice block results, in original slice order.
       def call(items:, workers:, &block)
         worker_count = [workers, items.size].min
         return [block.call(items)] unless parallel?(worker_count) && !items.empty?
@@ -55,8 +55,6 @@ module Rigor
       # The directory check is the belt to {.run_worker}'s braces: the offer is only worth taking while the
       # parent still has the directory open, and answering `nil` once it is gone degrades to `Dir.tmpdir`
       # instead of raising `Errno::ENOENT` somewhere far from here.
-      #
-      # @return [String, nil]
       def child_scratch_dir
         return nil unless @child_scratch_dir && File.directory?(@child_scratch_dir)
 
@@ -120,7 +118,7 @@ module Rigor
         end
       end
 
-      # @return [Hash{value: Object}, nil] the child's payload wrapped so a legitimately-nil block result is
+      # @return the child's payload wrapped so a legitimately-nil block result is
       #   distinguishable from an abnormal exit. `Marshal.load` is safe: the blob was written by our own
       #   forked child to a temp file we created.
       def worker_payload(status, out_path)

data/lib/rigor/inference/hkt_reducer.rb

@@ -41,10 +41,9 @@ module Rigor
 
       # Reduce `app` against the registry.
       #
-      # @param app [Rigor::Type::App]
-      # @param fuel [Integer] reduction-step budget (default 64 per ADR-20 WD3). Each visited
+      # @param fuel — reduction-step budget (default 64 per ADR-20 WD3). Each visited
       #   body node costs one unit. On exhaustion the reduction returns `app.bound`.
-      # @return [Rigor::Type] the reduced type, or `app.bound` when reduction is impossible (URI
+      # @return the reduced type, or `app.bound` when reduction is impossible (URI
       #   not defined, arity mismatch, body_tree absent, fuel exhausted).
       def reduce(app, fuel: DEFAULT_FUEL)
         raise ArgumentError, "expected a Rigor::Type::App, got #{app.class}" unless app.is_a?(Type::App)

data/lib/rigor/inference/hkt_registry.rb

@@ -99,8 +99,6 @@ module Rigor
 
       attr_reader :registrations, :definitions
 
-      # @param registrations [Array<Registration>]
-      # @param definitions [Array<Definition>]
       def initialize(registrations: [], definitions: [])
         @registrations = registrations.to_h { |r| [r.uri, r] }.freeze
         @definitions = definitions.to_h { |d| [d.uri, d] }.freeze
@@ -123,7 +121,7 @@ module Rigor
         @definitions[uri]
       end
 
-      # @return [HktRegistry] a new registry whose entries are the union of this registry's and
+      # @return a new registry whose entries are the union of this registry's and
       #   `other`'s. On URI collisions `other`'s entries win (last-write-wins; OQ3 tentative).
       def merge(other)
         raise ArgumentError, "merge target must be an HktRegistry, got #{other.class}" unless other.is_a?(HktRegistry)
@@ -154,13 +152,12 @@ module Rigor
       # diagnostic; the other annotations still apply). That claim was false until issue #785: the
       # production reporter has no `#record`, so every declined directive was dropped silently.
       #
-      # @param rbs_loader [Rigor::Environment::RbsLoader]
-      # @param base [HktRegistry] starting registry (typically the bundled
+      # @param base — starting registry (typically the bundled
       #   `Rigor::Builtins::HktBuiltins.registry`).
-      # @param name_scope [Rigor::Environment::NameScope, nil] threaded through to the bound
+      # @param name_scope — threaded through to the bound
       #   resolver for class-name lookups; safe to omit during scanning since hkt bounds are
       #   typically `untyped` or stdlib classes.
-      # @param reporter [Rigor::RbsExtended::Reporter, #record, nil] same fail-soft reporter contract
+      # @param reporter — same fail-soft reporter contract
       #   the other RBS-extended parsers use; a collecting double that responds only to `#record` /
       #   `#<<` still works (see {Rigor::RbsExtended::HktDirectives.record_hkt_error}).
 

data/lib/rigor/inference/index_write_widening.rb

@@ -27,7 +27,6 @@ module Rigor
 
       module_function
 
-      # @param node [Prism::Node]
       def index_write?(node)
         NODE_CLASSES.any? { |klass| node.is_a?(klass) }
       end
@@ -36,10 +35,7 @@ module Rigor
       # the widening joins the stored value into the carrier's content evidence exactly as a real `[]=` does
       # (issue #560). Empty means "no evidence" and widens without joining.
       #
-      # @param node          [Prism::Node] one of {NODE_CLASSES}
-      # @param current_scope [Rigor::Scope]
-      # @param arg_types     [Array<Rigor::Type::Base>]
-      # @return              [Rigor::Scope]
+      # @param node — one of {NODE_CLASSES}
       def widen(node:, current_scope:, arg_types: MutationWidening::NO_ARG_TYPES)
         MutationWidening.widen_receiver_aliases(node.receiver, MUTATOR, current_scope, arg_types: arg_types)
       end

data/lib/rigor/inference/macro_block_self_type.rb

@@ -28,10 +28,7 @@ module Rigor
     module MacroBlockSelfType
       module_function
 
-      # @param scope         [Rigor::Scope]
-      # @param call_node     [Prism::CallNode]
-      # @param receiver_type [Rigor::Type, nil]
-      # @return [Rigor::Type, nil] the narrowed self-type, or
+      # @return the narrowed self-type, or
       #   `nil` when no registered entry matches the call shape.
       def narrow_self_type_for(scope:, call_node:, receiver_type:)
         return nil if receiver_type.nil?

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

@@ -46,13 +46,8 @@ module Rigor
         # a finitely-sized receiver it is `Constant[size]`.
         COUNT_METHOD = :count
 
-        # @param receiver    [Rigor::Type, nil]
-        # @param method_name [Symbol]
-        # @param args        [Array<Rigor::Type>]
-        # @param block_type  [Rigor::Type, nil] inferred return type of
-        #   the call's block. `nil` means "no block at the call site"
-        #   and disqualifies every rule here.
-        # @return [Rigor::Type, nil]
+        # `context.block_type` is the inferred return type of the call's block; `nil` means "no block at the
+        # call site" and disqualifies every rule here.
         def try_dispatch(context)
           receiver = context.receiver
           method_name = context.method_name
@@ -135,7 +130,6 @@ module Rigor
           end
         end
 
-        # @return [:always_true, :always_false, :bool, nil]
         # rubocop:disable-next Metrics/CyclomaticComplexity
         def predicate_decision(method_name, truthiness, emptiness)
           case method_name
@@ -167,7 +161,6 @@ module Rigor
           )
         end
 
-        # @return [:empty, :non_empty, :unknown]
         def receiver_emptiness(receiver)
           case receiver
           when Type::Tuple

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

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

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/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

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

@@ -16,7 +16,7 @@ module Rigor
       # Each rule mirrors Ruby's actual iteration semantics:
       #
       # - `n.times { |i| … }` yields `i ∈ [0, n-1]` when `n > 0`, nothing otherwise. The block-param type is
-      #   therefore `int<0, n-1>` for a `Constant<Integer>` receiver, `int<0, upper-1>` for a finite
+      #   therefore `Integer[0..n-1]` for a `Constant<Integer>` receiver, `Integer[0..upper-1]` for a finite
       #   `IntegerRange`, and `non_negative_int` for any unbounded-above shape.
       # - `a.upto(b) { |i| … }` yields `i ∈ [a, b]` when `a <= b`. Lower bound from the receiver, upper
       #   bound from the argument.
@@ -25,7 +25,7 @@ module Rigor
       module IteratorDispatch
         module_function
 
-        # @return [Array<Rigor::Type>, nil] block-param types, or
+        # @return block-param types, or
         #   nil to fall through to the next tier.
         def block_param_types(context)
           receiver = context.receiver

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

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

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

@@ -2,6 +2,7 @@
 
 require_relative "../../type"
 require_relative "constant_folding"
+require_relative "random_folding"
 
 module Rigor
   module Inference
@@ -43,7 +44,7 @@ module Rigor
         # every entry is spelling-parity checked. Public (not private_constant) and Ractor-shareable
         # because the gate and the spec both read it.
         INTRINSIC_NAMES = Ractor.make_shareable(
-          Set[:Array, :Integer, :Float, :Rational, :Complex, :p, :pp, :String, :Hash, :format, :sprintf]
+          Set[:Array, :Integer, :Float, :Rational, :Complex, :p, :pp, :String, :Hash, :format, :sprintf, :rand]
         )
 
         # `Kernel#Rational` / `Kernel#Complex` constructor folds. When every argument is a `Type::Constant`
@@ -101,6 +102,11 @@ module Rigor
           return try_string(context) if method_name == :String
           return try_hash(context) if method_name == :Hash
           return try_format(context) if FORMAT_METHODS.include?(method_name)
+          # ADR-109 / #833 — `Kernel#rand(a..b)` lands in the literal range, a bounded carrier of the
+          # range's own class (never a constant: the generator advances). The other argument shapes
+          # stay unfolded on purpose; {RandomFolding} owns the `Random.rand` spelling and the reading.
+          # A splat still declines: the reading needs exactly one literal-Range argument.
+          return RandomFolding.interval_for_args(args) if method_name == :rand
 
           nil
         end