rigortype 0.1.8 → 0.1.10

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

@@ -48,11 +48,21 @@ module Rigor
       module ConstantFolding # rubocop:disable Metrics/ModuleLength
         module_function
 
-        NUMERIC_BINARY = Set[:+, :-, :*, :/, :%, :<, :<=, :>, :>=, :==, :!=, :<=>].freeze
-        STRING_BINARY  = Set[:+, :*, :==, :!=, :<, :<=, :>, :>=, :<=>].freeze
+        NUMERIC_BINARY = Set[
+          :+, :-, :*, :/, :%, :**, :&, :|, :^, :<<, :>>,
+          :<, :<=, :>, :>=, :==, :!=, :<=>,
+          :gcd, :lcm, :fdiv
+        ].freeze
+        STRING_BINARY  = Set[
+          :+, :*, :==, :!=, :<, :<=, :>, :>=, :<=>,
+          :start_with?, :end_with?, :include?,
+          :delete_prefix, :delete_suffix,
+          :match?, :index, :rindex, :center, :ljust, :rjust
+        ].freeze
         SYMBOL_BINARY  = Set[:==, :!=, :<=>, :<, :<=, :>, :>=].freeze
-        BOOL_BINARY    = Set[:&, :|, :^, :==, :!=].freeze
+        BOOL_BINARY    = Set[:&, :|, :^, :==, :!=, :===].freeze
         NIL_BINARY     = Set[:==, :!=].freeze
+        RATIONAL_BINARY = Set[:div, :modulo, :%, :remainder, :fdiv].freeze
 
         # v0.0.3 C — pure unary catalogue. Each method must:
         # - take zero arguments,
@@ -74,20 +84,23 @@ module Rigor
           :odd?, :even?, :zero?, :positive?, :negative?,
           :succ, :pred, :next, :abs, :magnitude,
           :bit_length, :to_s, :to_i, :to_int, :to_f,
+          :floor, :ceil, :round, :truncate, :chr,
           :inspect, :hash, :-@, :+@, :~
         ].freeze
         FLOAT_UNARY = Set[
           :zero?, :positive?, :negative?,
           :nan?, :finite?, :infinite?,
           :abs, :magnitude, :floor, :ceil, :round, :truncate,
+          :next_float, :prev_float,
           :to_s, :to_i, :to_int, :to_f,
           :inspect, :hash, :-@, :+@
         ].freeze
         STRING_UNARY = Set[
           :upcase, :downcase, :capitalize, :swapcase,
           :reverse, :length, :size, :bytesize,
-          :empty?, :strip, :lstrip, :rstrip, :chomp,
+          :empty?, :strip, :lstrip, :rstrip, :chomp, :chop,
           :to_s, :to_str, :to_sym, :intern,
+          :to_i, :to_f, :ord, :chr, :hex, :oct, :succ, :next,
           :inspect, :hash
         ].freeze
         SYMBOL_UNARY = Set[
@@ -97,6 +110,11 @@ module Rigor
         ].freeze
         BOOL_UNARY = Set[:!, :to_s, :inspect, :hash, :&, :|, :^].freeze
         NIL_UNARY  = Set[:nil?, :!, :to_s, :to_a, :to_h, :inspect, :hash].freeze
+        RATIONAL_UNARY = Set[
+          :zero?, :integer?, :real, :abs2,
+          :conj, :conjugate, :nonzero?
+        ].freeze
+        COMPLEX_UNARY = Set[:zero?, :nonzero?].freeze
 
         STRING_FOLD_BYTE_LIMIT = 4096
 
@@ -283,6 +301,18 @@ module Rigor
           pathname_lift = try_fold_pathname_unary(receiver_values, method_name)
           return pathname_lift if pathname_lift
 
+          regexp_lift = try_fold_regexp_array_unary(receiver_values, method_name)
+          return regexp_lift if regexp_lift
+
+          set_lift = try_fold_set_array_unary(receiver_values, method_name)
+          return set_lift if set_lift
+
+          integer_lift = try_fold_integer_array_unary(receiver_values, method_name)
+          return integer_lift if integer_lift
+
+          numeric_lift = try_fold_numeric_array_unary(receiver_values, method_name)
+          return numeric_lift if numeric_lift
+
           # Type-level allow check on every receiver. If one member's
           # type does not have the method in its allow list (e.g.
           # `Union[String, nil].nil?` — `:nil?` is not in
@@ -309,7 +339,7 @@ module Rigor
         # Only fires on a single-receiver Range with finite integer
         # endpoints; mixed unions fall through so the existing
         # union-of-Constants path keeps the rest of the arms.
-        RANGE_FOLD_METHODS = Set[:to_a, :first, :last, :min, :max, :count, :size, :length].freeze
+        RANGE_FOLD_METHODS = Set[:to_a, :first, :last, :min, :max, :count, :size, :length, :entries, :minmax].freeze
         RANGE_TO_A_LIMIT = 16
         private_constant :RANGE_FOLD_METHODS, :RANGE_TO_A_LIMIT
 
@@ -326,10 +356,11 @@ module Rigor
 
         def range_constant_unary(range, method_name)
           case method_name
-          when :to_a then range_to_a_tuple(range)
+          when :to_a, :entries then range_to_a_tuple(range)
           when :first, :min then range_endpoint_constant(range, :first)
           when :last, :max then range_endpoint_constant(range, :last)
           when :count, :size, :length then Type::Combinator.constant_of(range.to_a.size)
+          when :minmax then range_minmax_tuple(range)
           end
         end
 
@@ -348,6 +379,21 @@ module Rigor
           Type::Combinator.constant_of(edge == :first ? values.first : values.last)
         end
 
+        def range_minmax_tuple(range)
+          values = range.to_a
+          if values.empty?
+            return Type::Combinator.tuple_of(
+              Type::Combinator.constant_of(nil),
+              Type::Combinator.constant_of(nil)
+            )
+          end
+
+          Type::Combinator.tuple_of(
+            Type::Combinator.constant_of(values.first),
+            Type::Combinator.constant_of(values.last)
+          )
+        end
+
         def try_fold_binary_set(receiver_values, method_name, arg_values)
           string_lift = try_fold_string_array_binary(receiver_values, method_name, arg_values)
           return string_lift if string_lift
@@ -377,6 +423,30 @@ module Rigor
                          :STRING_ARRAY_BINARY_METHODS,
                          :STRING_ARRAY_LIFT_LIMIT
 
+        # `Constant<Regexp>#names` returns an Array of capture-group name
+        # strings. Lifted to a Tuple so downstream narrowing can project
+        # per-element types. The catalog classifies the C body as `:leaf`
+        # so it is safe to evaluate at fold time; no `$~` side effect.
+        REGEXP_ARRAY_UNARY_METHODS = Set[:names].freeze
+        private_constant :REGEXP_ARRAY_UNARY_METHODS
+
+        # `Constant<Set>#to_a` returns an Array of the set's elements.
+        # Ruby 3.2+ Set is C-implemented with a Hash as its backing store,
+        # so element ordering is deterministic (insertion order).
+        # The catalog marks `to_a` as `:dispatch` (it calls through to the
+        # internal hash), so this dedicated handler bypasses the catalog gate.
+        SET_ARRAY_UNARY_METHODS = Set[:to_a, :entries].freeze
+        private_constant :SET_ARRAY_UNARY_METHODS
+
+        # `Constant<Integer>#digits` returns the base-10 (or base-n with
+        # an argument — only the no-arg form is folded here) place
+        # values as a little-endian Array of Integers. Lifted to a
+        # Tuple so downstream rules see the precise per-position type.
+        # `digits` raises `Math::DomainError` on a negative receiver,
+        # so the negative case bails to the RBS tier.
+        INTEGER_ARRAY_UNARY_METHODS = Set[:digits].freeze
+        private_constant :INTEGER_ARRAY_UNARY_METHODS
+
         # v0.0.7 — `Constant<Pathname>` delegates to a curated set
         # of pure path-manipulation methods. Pathname is immutable
         # in Ruby (per its docstring) and the catalog classifies
@@ -446,6 +516,83 @@ module Rigor
           nil
         end
 
+        # `Constant<Regexp>#names` — lift the Array[String] of named-capture
+        # group names to a Tuple[Constant[String]…]. Safe to evaluate at fold
+        # time: the C body reads only the regexp's internal names table,
+        # writes no global state, and always returns an Array of frozen Strings.
+        def try_fold_regexp_array_unary(receiver_values, method_name)
+          return nil unless REGEXP_ARRAY_UNARY_METHODS.include?(method_name)
+          return nil unless receiver_values.size == 1
+
+          receiver = receiver_values.first
+          return nil unless receiver.is_a?(Regexp)
+
+          lift_array_result(receiver.public_send(method_name))
+        rescue StandardError
+          nil
+        end
+
+        # `Constant<Set>#to_a` / `#entries` — lift the Array of set elements
+        # to a Tuple[Constant[…]…] when every element is a foldable scalar.
+        # Ruby 3.2+ Set is C-implemented; element order is deterministic
+        # (insertion order), so the result is stable across invocations.
+        def try_fold_set_array_unary(receiver_values, method_name)
+          return nil unless SET_ARRAY_UNARY_METHODS.include?(method_name)
+          return nil unless receiver_values.size == 1
+
+          receiver = receiver_values.first
+          return nil unless receiver.is_a?(::Set)
+
+          lift_array_result(receiver.to_a)
+        rescue StandardError
+          nil
+        end
+
+        # `Constant<Integer>#digits` — lift the Array of base-10 place
+        # values to a Tuple[Constant[Integer]…]. Safe to evaluate at
+        # fold time: the C body is pure arithmetic. Negative receivers
+        # raise `Math::DomainError`; the fold declines so the RBS tier
+        # answers with `Array[Integer]`.
+        def try_fold_integer_array_unary(receiver_values, method_name)
+          return nil unless INTEGER_ARRAY_UNARY_METHODS.include?(method_name)
+          return nil unless receiver_values.size == 1
+
+          receiver = receiver_values.first
+          return nil unless receiver.is_a?(Integer)
+          return nil if receiver.negative?
+
+          lift_array_result(receiver.digits)
+        rescue StandardError
+          nil
+        end
+
+        # `Constant<Complex>#rect` / `#rectangular` — lifts `[real, imaginary]`
+        # to `Tuple[Constant[re], Constant[im]]`. Both components are always
+        # numeric (Integer or Float for literal complexes), so they satisfy
+        # `foldable_constant_value?`.
+        #
+        # `Constant<Complex>#polar` — lifts `[abs, arg]` to
+        # `Tuple[Constant[Float], Constant[Float]]`. Evaluated at fold time
+        # via `Complex#polar` (which calls `Math.hypot` and `Math.atan2`).
+        # Deterministic: reads only the receiver's real and imaginary parts.
+        #
+        # Rational receivers also support `rect` / `rectangular` / `polar`:
+        # `Rational(r,1).rect` → `[r, 0]`, `Rational(r,1).polar` → `[abs, arg]`.
+        NUMERIC_ARRAY_UNARY_METHODS = Set[:rect, :rectangular, :polar].freeze
+        private_constant :NUMERIC_ARRAY_UNARY_METHODS
+
+        def try_fold_numeric_array_unary(receiver_values, method_name)
+          return nil unless NUMERIC_ARRAY_UNARY_METHODS.include?(method_name)
+          return nil unless receiver_values.size == 1
+
+          receiver = receiver_values.first
+          return nil unless receiver.is_a?(Complex) || receiver.is_a?(Rational)
+
+          lift_array_result(receiver.public_send(method_name))
+        rescue StandardError
+          nil
+        end
+
         # `Constant<String>#split(arg)` / `#scan(arg)` — lift the
         # Array result to a Tuple when both sides are statically
         # known and the cardinality fits.
@@ -841,6 +988,11 @@ module Rigor
           magnitude: :range_unary_abs,
           "-@": :range_unary_negate,
           "+@": :range_unary_identity,
+          # `Integer#to_i` / `Integer#to_int` are identity operations —
+          # they return `self` — so the IntegerRange carrier is preserved.
+          # `positive-int.to_i → positive-int`, etc.
+          to_i: :range_unary_identity,
+          to_int: :range_unary_identity,
           bit_length: :range_unary_bit_length
         }.freeze
         private_constant :UNARY_RANGE_DIRECT
@@ -1101,6 +1253,8 @@ module Rigor
           when Symbol         then SYMBOL_UNARY
           when true, false    then BOOL_UNARY
           when nil            then NIL_UNARY
+          when Rational       then RATIONAL_UNARY
+          when Complex        then COMPLEX_UNARY
           else                     Set.new
           end
         end
@@ -1126,11 +1280,15 @@ module Rigor
         # have their own shape carriers; this method picks
         # the conservative envelope of "values that already
         # round-trip through `Type::Combinator.constant_of`".
+        FOLDABLE_CONSTANT_CLASSES = [
+          Integer, Float, Rational, Complex, String, Symbol,
+          Regexp, Pathname, ::Set, Date, Time,
+          TrueClass, FalseClass, NilClass
+        ].freeze
+        private_constant :FOLDABLE_CONSTANT_CLASSES
+
         def foldable_constant_value?(value)
-          case value
-          when Integer, Float, Rational, Complex, String, Symbol, Regexp, Pathname, true, false, nil then true
-          else false
-          end
+          FOLDABLE_CONSTANT_CLASSES.any? { |klass| value.is_a?(klass) }
         end
 
         def safe?(receiver_value, method_name, arg_value)
@@ -1150,6 +1308,7 @@ module Rigor
           when Symbol         then SYMBOL_BINARY
           when true, false    then BOOL_BINARY
           when nil            then NIL_BINARY
+          when Rational       then RATIONAL_BINARY
           else                     Set.new
           end
         end
@@ -1169,10 +1328,19 @@ module Rigor
           case method_name
           when :+ then string_concat_blow_up?(receiver_value, arg_value)
           when :* then string_repeat_blow_up?(receiver_value, arg_value)
+          when :center, :ljust, :rjust then string_pad_blow_up?(arg_value)
           else false
           end
         end
 
+        # `"x".center(width)` / `#ljust` / `#rjust` produce a string
+        # of `max(width, len)` characters. A literal `width` far
+        # larger than the receiver would materialise a huge Constant;
+        # cap it at the same byte limit the concat / repeat paths use.
+        def string_pad_blow_up?(arg_value)
+          arg_value.is_a?(Integer) && arg_value > STRING_FOLD_BYTE_LIMIT
+        end
+
         def string_concat_blow_up?(receiver_value, arg_value)
           arg_value.is_a?(String) &&
             receiver_value.bytesize + arg_value.bytesize > STRING_FOLD_BYTE_LIMIT

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

@@ -57,11 +57,63 @@ module Rigor
           return nil if receiver.nil?
           return try_array(args) if method_name == :Array
           return try_numeric_constructor(method_name, args) if NUMERIC_CONSTRUCTORS.key?(method_name)
-          return try_integer_from_refinement(args) if method_name == :Integer
+          return try_integer(args) if method_name == :Integer
+          return try_float(args) if method_name == :Float
 
           nil
         end
 
+        # `Kernel#Integer(arg)` / `Integer(arg, base)`. Two folding
+        # paths, tried in order:
+        #
+        # 1. A `Refined[String, predicate]` argument whose predicate
+        #    is a digit-only carrier narrows to `non-negative-int`
+        #    (see {try_integer_from_refinement}).
+        # 2. A `Constant` String or Numeric argument — optionally
+        #    with a `Constant[Integer]` base — runs the actual
+        #    `Integer()` conversion and lifts the result to
+        #    `Constant[Integer]`.
+        def try_integer(args)
+          refined = try_integer_from_refinement(args)
+          return refined if refined
+
+          try_integer_constant(args)
+        end
+
+        # Constant-folding path for `Integer()`. A non-parseable
+        # string raises `ArgumentError` (or `TypeError` for a base
+        # against a non-string) at fold time; the handler declines
+        # so the RBS tier answers with the widened `Integer`.
+        def try_integer_constant(args)
+          return nil unless [1, 2].include?(args.size)
+          return nil unless args.all?(Type::Constant)
+
+          values = args.map(&:value)
+          return nil unless values[0].is_a?(String) || values[0].is_a?(Numeric)
+          return nil if values.size == 2 && !values[1].is_a?(Integer)
+
+          Type::Combinator.constant_of(Integer(*values))
+        rescue ArgumentError, TypeError
+          nil
+        end
+
+        # `Kernel#Float(arg)` — folds a `Constant` String or Numeric
+        # argument to `Constant[Float]`. A non-parseable string
+        # raises `ArgumentError` at fold time; the handler declines.
+        def try_float(args)
+          return nil unless args.size == 1
+
+          arg = args.first
+          return nil unless arg.is_a?(Type::Constant)
+
+          value = arg.value
+          return nil unless value.is_a?(String) || value.is_a?(Numeric)
+
+          Type::Combinator.constant_of(Float(value))
+        rescue ArgumentError, TypeError
+          nil
+        end
+
         # `Kernel#Integer(s)` over a `Refined[String, predicate]`
         # whose predicate is in {INTEGER_REFINEMENT_PREDICATES}.
         # Mirrors the `String#to_i` projection in `ShapeDispatch`

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

@@ -65,6 +65,11 @@ module Rigor
         # == ""`); the carrier collapses from `non-empty-literal-string`
         # down to plain `literal-string`.
         LITERAL_PRESERVING_METHODS = %i[strip lstrip rstrip chomp chop scrub].freeze
+        # Methods that preserve literal-bearing AND non-empty-string-ness.
+        # Unlike `LITERAL_PRESERVING_METHODS` (strip/chomp/etc.) these do
+        # not reduce the string — they transform characters without
+        # removing any, so a non-empty receiver stays non-empty.
+        NON_EMPTY_LITERAL_PRESERVING_METHODS = %i[upcase downcase capitalize swapcase reverse].freeze
         # v0.1.1 Track 1 slice 5c — width-padding methods. `center`
         # / `ljust` / `rjust` take a `width` Integer plus an
         # optional literal padding `String`. When the receiver
@@ -72,28 +77,32 @@ module Rigor
         # literal-bearing, the result is literal-bearing too.
         WIDTH_PADDING_METHODS = %i[center ljust rjust].freeze
         private_constant :CONCAT_METHODS, :FORMAT_METHODS,
-                         :LITERAL_PRESERVING_METHODS, :WIDTH_PADDING_METHODS
+                         :LITERAL_PRESERVING_METHODS, :NON_EMPTY_LITERAL_PRESERVING_METHODS,
+                         :WIDTH_PADDING_METHODS
 
         def try_dispatch(receiver:, method_name:, args:, **)
           return fold_array_join(receiver, args) if method_name == :join
           return fold_format(args) if FORMAT_METHODS.include?(method_name)
-
           return nil unless Type::Combinator.literal_string_compatible?(receiver)
-
           return fold_string_percent(args) if method_name == :%
-          if args.empty?
-            return LITERAL_PRESERVING_METHODS.include?(method_name) ? Type::Combinator.literal_string : nil
-          end
+          return fold_no_arg(receiver, method_name) if args.empty?
           return fold_width_pad(args) if WIDTH_PADDING_METHODS.include?(method_name)
           return nil unless args.size == 1
 
           if CONCAT_METHODS.include?(method_name)
-            fold_concat(args.first)
+            fold_concat(receiver, args.first)
           elsif method_name == :*
-            fold_repeat(args.first)
+            fold_repeat(receiver, args.first)
           end
         end
 
+        def fold_no_arg(receiver, method_name)
+          return Type::Combinator.literal_string if LITERAL_PRESERVING_METHODS.include?(method_name)
+          return non_empty_literal_result(receiver) if NON_EMPTY_LITERAL_PRESERVING_METHODS.include?(method_name)
+
+          nil
+        end
+
         # `String#center` / `#ljust` / `#rjust` — first argument is
         # the target width (Integer-typed), optional second
         # argument is the padding string (must be literal-bearing
@@ -111,19 +120,39 @@ module Rigor
           Type::Combinator.literal_string
         end
 
-        def fold_concat(arg_type)
-          return nil unless Type::Combinator.literal_string_compatible?(arg_type)
+        def fold_concat(receiver, arg)
+          return nil unless Type::Combinator.literal_string_compatible?(arg)
+
+          if Type::Combinator.non_empty_string_compatible?(receiver) ||
+             Type::Combinator.non_empty_string_compatible?(arg)
+            return Type::Combinator.non_empty_literal_string
+          end
 
           Type::Combinator.literal_string
         end
 
-        def fold_repeat(arg_type)
-          return nil unless integer_typed?(arg_type)
-          return nil if known_negative_integer?(arg_type)
+        def fold_repeat(receiver, arg)
+          return nil unless integer_typed?(arg)
+          return nil if known_negative_integer?(arg)
+          return Type::Combinator.constant_of("") if known_zero_integer?(arg)
+
+          if Type::Combinator.non_empty_string_compatible?(receiver) && known_positive_integer?(arg)
+            return Type::Combinator.non_empty_literal_string
+          end
 
           Type::Combinator.literal_string
         end
 
+        # Returns `non_empty_literal_string` when the receiver is provably
+        # non-empty; otherwise collapses to plain `literal_string`.
+        def non_empty_literal_result(receiver)
+          if Type::Combinator.non_empty_string_compatible?(receiver)
+            Type::Combinator.non_empty_literal_string
+          else
+            Type::Combinator.literal_string
+          end
+        end
+
         # `[lit, lit].join(sep)` — receiver must be a Tuple
         # whose every element is literal-bearing; separator
         # (when given) must be literal-bearing too. Multi-arg
@@ -205,9 +234,27 @@ module Rigor
           type.is_a?(Type::Constant) && type.value.is_a?(Integer) && type.value.negative?
         end
 
-        private_class_method :fold_concat, :fold_repeat, :fold_array_join,
+        def known_zero_integer?(type)
+          case type
+          when Type::Constant then type.value.is_a?(Integer) && type.value.zero?
+          when Type::IntegerRange then type.lower.zero? && type.upper.zero?
+          else false
+          end
+        end
+
+        def known_positive_integer?(type)
+          case type
+          when Type::Constant then type.value.is_a?(Integer) && type.value.positive?
+          when Type::IntegerRange then type.lower >= 1
+          else false
+          end
+        end
+
+        private_class_method :fold_no_arg, :fold_concat, :fold_repeat, :fold_array_join,
                              :fold_format, :fold_string_percent, :fold_width_pad,
-                             :literal_or_constant?, :integer_typed?
+                             :non_empty_literal_result, :literal_or_constant?,
+                             :integer_typed?, :known_negative_integer?,
+                             :known_zero_integer?, :known_positive_integer?
       end
     end
   end

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

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # Folds `Math` module-function calls on statically known numeric
+      # constants.
+      #
+      # `Math` is a pure, side-effect-free module whose functions are
+      # deterministic over their inputs — the same number always
+      # produces the same result. When every relevant argument is a
+      # `Constant` carrying a `Numeric` value, the analyzer evaluates
+      # the call at inference time and returns the concrete result.
+      #
+      # === Supported methods
+      #
+      # * Single-argument transcendental functions (`sqrt`, `cbrt`,
+      #   `exp`, `log2`, `log10`, `log1p`, `expm1`, `sin`, `cos`,
+      #   `tan`, `asin`, `acos`, `atan`, `sinh`, `cosh`, `tanh`,
+      #   `asinh`, `acosh`, `atanh`, `erf`, `erfc`, `gamma`) — return
+      #   `Constant[Float]`.
+      #
+      # * Two-argument functions (`atan2`, `hypot`, `ldexp`) — return
+      #   `Constant[Float]`.
+      #
+      # * `log(x)` / `log(x, base)` — variadic; folds the 1- and
+      #   2-argument forms to `Constant[Float]`.
+      #
+      # * `frexp(x)` / `lgamma(x)` — return a two-element array, lifted
+      #   to `Tuple[Constant[Float], Constant[Integer]]`.
+      #
+      # === Non-constant / unsupported cases
+      #
+      # Any call where the receiver is not `Singleton[Math]`, an
+      # argument is not a numeric `Constant`, the method is not in the
+      # supported set, or the Ruby call raises `Math::DomainError` /
+      # `RangeError` (domain-error inputs like `Math.sqrt(-1)`) returns
+      # `nil`, deferring to the next dispatcher tier.
+      #
+      # An infinite or NaN result (`Math.log(0.0)` → `-Infinity`) is
+      # still folded — `Constant[Float]` carries those values, matching
+      # `ConstantFolding`'s treatment of `Float / 0`.
+      module MathFolding
+        MATH_UNARY = Set[
+          :sqrt, :cbrt, :exp, :log2, :log10, :log1p, :expm1,
+          :sin, :cos, :tan, :asin, :acos, :atan,
+          :sinh, :cosh, :tanh, :asinh, :acosh, :atanh,
+          :erf, :erfc, :gamma
+        ].freeze
+        MATH_BINARY = Set[:atan2, :hypot, :ldexp].freeze
+        MATH_TUPLE_UNARY = Set[:frexp, :lgamma].freeze
+
+        private_constant :MATH_UNARY, :MATH_BINARY, :MATH_TUPLE_UNARY
+
+        module_function
+
+        # @return [Rigor::Type, nil] folded result, or nil to defer.
+        def try_dispatch(receiver:, method_name:, args:)
+          return nil unless dispatch_target?(receiver)
+
+          # `log` is variadic (1 or 2 args), so it cannot live in the
+          # fixed-arity sets above.
+          return fold_log(args) if method_name == :log
+          return fold_unary(method_name, args) if MATH_UNARY.include?(method_name)
+          return fold_binary(method_name, args) if MATH_BINARY.include?(method_name)
+          return fold_tuple_unary(method_name, args) if MATH_TUPLE_UNARY.include?(method_name)
+
+          nil
+        end
+
+        def dispatch_target?(receiver)
+          receiver.is_a?(Type::Singleton) && receiver.class_name == "Math"
+        end
+
+        # Unwraps a numeric `Constant` argument to its Ruby value.
+        # Returns nil for any non-`Constant` or non-`Numeric` carrier.
+        def numeric_constant(arg)
+          return nil unless arg.is_a?(Type::Constant)
+
+          value = arg.value
+          value.is_a?(Numeric) ? value : nil
+        end
+
+        def fold_unary(method_name, args)
+          return nil unless args.size == 1
+
+          x = numeric_constant(args.first)
+          return nil if x.nil?
+
+          fold_float_result(Math.public_send(method_name, x))
+        rescue Math::DomainError, RangeError
+          nil
+        end
+
+        def fold_binary(method_name, args)
+          return nil unless args.size == 2
+
+          a = numeric_constant(args[0])
+          b = numeric_constant(args[1])
+          return nil if a.nil? || b.nil?
+
+          fold_float_result(Math.public_send(method_name, a, b))
+        rescue Math::DomainError, RangeError
+          nil
+        end
+
+        # `Math.log(x)` and `Math.log(x, base)` — the only variadic
+        # `Math` function.
+        def fold_log(args)
+          return nil unless [1, 2].include?(args.size)
+
+          values = args.map { |a| numeric_constant(a) }
+          return nil if values.any?(&:nil?)
+
+          fold_float_result(Math.log(*values))
+        rescue Math::DomainError, RangeError
+          nil
+        end
+
+        # `Math.frexp` / `Math.lgamma` return a two-element array;
+        # lift it to `Tuple[Constant[Float], Constant[Integer]]`.
+        def fold_tuple_unary(method_name, args)
+          return nil unless args.size == 1
+
+          x = numeric_constant(args.first)
+          return nil if x.nil?
+
+          result = Math.public_send(method_name, x)
+          return nil unless result.is_a?(Array) && result.size == 2
+
+          Type::Combinator.tuple_of(
+            Type::Combinator.constant_of(result[0]),
+            Type::Combinator.constant_of(result[1])
+          )
+        rescue Math::DomainError, RangeError
+          nil
+        end
+
+        def fold_float_result(result)
+          return nil unless result.is_a?(Float)
+
+          Type::Combinator.constant_of(result)
+        end
+      end
+    end
+  end
+end