schemurai 3.0.0 → 3.0.2

data/ext/schemurai_native/src/number.rs

@@ -2,7 +2,9 @@
 //! multipleOf semantics. All evaluation helpers operate under the GVL and
 //! allocate no Ruby objects; unsupported magnitudes retain VM compatibility.
 use super::*;
+use num_rational::BigRational;
 use std::cmp::Ordering;
+mod arbitrary;
 
 // Strictly ordered integers are unique without fingerprinting their digits.
 // Each comparison checks both original handles; mixed or unordered inputs
@@ -241,7 +243,12 @@ impl Fraction {
     }
 }
 
-fn decimal_float(value: f64) -> Option<Fraction> {
+struct Decimal {
+    coefficient: i128,
+    power: i32,
+}
+
+fn decimal_parts(value: f64) -> Option<Decimal> {
     if !value.is_finite() {
         return None;
     }
@@ -286,12 +293,21 @@ fn decimal_float(value: f64) -> Option<Fraction> {
             .checked_add(i128::from(byte.checked_sub(b'0')?))?;
     }
     if numerator == 0 {
-        return Some(Fraction {
-            numerator: 0,
-            denominator: 1,
+        return Some(Decimal {
+            coefficient: 0,
+            power: 0,
         });
     }
     let power = exponent + trailing - fractional as i32;
+    Some(Decimal {
+        coefficient: if negative { -numerator } else { numerator },
+        power,
+    })
+}
+
+fn decimal_float(value: f64) -> Option<Fraction> {
+    let Decimal { coefficient, power } = decimal_parts(value)?;
+    let mut numerator = coefficient.abs();
     let mut denominator = 1;
     if power >= 0 {
         numerator = numerator.checked_mul(10_i128.checked_pow(power as u32)?)?;
@@ -303,7 +319,7 @@ fn decimal_float(value: f64) -> Option<Fraction> {
         (a, b) = (b, a % b);
     }
     Some(Fraction {
-        numerator: if negative {
+        numerator: if coefficient < 0 {
             -numerator / a
         } else {
             numerator / a
@@ -311,9 +327,11 @@ fn decimal_float(value: f64) -> Option<Fraction> {
         denominator: denominator / a,
     })
 }
-#[derive(Debug)]
+#[derive(Debug, Default)]
 struct Limit {
+    null: bool,
     exact: Option<Fraction>,
+    arbitrary: Option<Box<BigRational>>,
     wide_integer: Option<Value>,
     wide_rounded_order: Option<Ordering>,
     rounded: f64,
@@ -322,6 +340,24 @@ struct Limit {
 }
 
 impl Limit {
+    fn violation(
+        &self,
+        caches: &runtime::Caches,
+        value: Value,
+        bit: i32,
+        decimal: bool,
+        native: impl FnOnce() -> bool,
+    ) -> Result<bool, Verdict> {
+        if self.null {
+            match caches.null_number(value, bit, decimal) {
+                Valid => Ok(false),
+                Invalid => Ok(true),
+                Unsupported => Err(Unsupported),
+            }
+        } else {
+            Ok(native())
+        }
+    }
     fn float_order(&self, n: f64) -> Result<Option<Ordering>, Verdict> {
         if let Some(exact) = self.exact {
             return Ok(compare_float_integer(n, exact.numerator));
@@ -358,6 +394,7 @@ impl Limit {
 }
 #[derive(Debug)]
 pub(super) struct Rules {
+    source: Value,
     limits: Vec<(i32, Limit)>,
     multiple: Option<Limit>,
     pub(super) fast_limits: Option<Vec<(i32, i64)>>,
@@ -365,6 +402,7 @@ pub(super) struct Rules {
     fixnum_flag: Value,
     bounds_view: bool,
     bounded_signs: Option<[bool; 2]>,
+    runtime_operands: bool,
 }
 
 #[derive(Debug)]
@@ -470,7 +508,11 @@ impl Engine {
                         .any(|(bit, _)| matches!(*bit, MAXIMUM | EXCLUSIVE_MAXIMUM)),
                 ]
             });
+        let runtime_operands = limits.iter().any(|(_, limit)| limit.null)
+            || multiple.as_ref().is_some_and(|limit| limit.null);
         Ok(Some(Rules {
+            source: operand,
+            runtime_operands,
             limits,
             multiple,
             fast_limits,
@@ -482,25 +524,32 @@ impl Engine {
     }
 
     fn numeric_limit(&mut self, value: Value) -> Result<Option<Limit>, Value> {
+        if unsafe { sn_same(value, sn_nil()) } != 0 {
+            return Ok(Some(Limit {
+                null: true,
+                ..Limit::default()
+            }));
+        }
         let integer = unsafe { sn_kind(value) } & TYPE_INTEGER != 0;
         if !integer && unsafe { sn_is_rational(value) } == 0 {
             return Ok(None);
         }
-        let exact = if integer {
-            read_integer(value).map(|numerator| Fraction {
-                numerator,
-                denominator: 1,
-            })
+        let (numerator, denominator) = if integer {
+            (value, None)
         } else {
             let numerator = self.field(value, b"numerator\0")?;
             let denominator = self.field(value, b"denominator\0")?;
-            read_integer(numerator).zip(read_integer(denominator)).map(
-                |(numerator, denominator)| Fraction {
-                    numerator,
-                    denominator,
-                },
-            )
+            (numerator, Some(denominator))
         };
+        let exact = read_integer(numerator)
+            .zip(denominator.map_or(Some(1), read_integer))
+            .map(|(numerator, denominator)| Fraction {
+                numerator,
+                denominator,
+            });
+        let arbitrary = exact
+            .is_none()
+            .then(|| Box::new(arbitrary::fraction(numerator, denominator)));
         let rounded = self.field(value, b"to_f\0")?;
         let rounded = unsafe { sn_float(rounded) };
         let wide_rounded_order = if integer && exact.is_none() {
@@ -512,7 +561,9 @@ impl Engine {
             fraction.numerator > 1 && (1_u128 << 64) % fraction.numerator as u128 == 1
         });
         Ok(Some(Limit {
+            null: false,
             exact,
+            arbitrary,
             wide_integer: (integer && exact.is_none()).then(|| self.retain(value)),
             wide_rounded_order,
             rounded,
@@ -586,12 +637,24 @@ fn wide_integer_multiple(value: Value, divisor: Fraction, sum_words: bool) -> Ve
     }
     let mut words = [0_u64; 16];
     if unsafe { sn_integer1024(value, words.as_mut_ptr()) }.abs() > 1 {
-        return Unsupported;
+        return unbounded_integer_multiple(value, divisor, sum_words);
     }
     wide_multiple_words(&words, divisor, sum_words)
 }
 
-fn wide_multiple_words(words: &[u64; 16], divisor: Fraction, sum_words: bool) -> Verdict {
+fn unbounded_integer_multiple(value: Value, divisor: Fraction, sum_words: bool) -> Verdict {
+    let (words, _) = unbounded_integer_words(value);
+    wide_multiple_words(&words, divisor, sum_words)
+}
+
+fn unbounded_integer_words(value: Value) -> (Vec<u64>, i32) {
+    let count = unsafe { sn_integer_word_count(value) };
+    let mut words = vec![0_u64; count];
+    let sign = unsafe { sn_integer_words(value, words.as_mut_ptr(), count) };
+    (words, sign)
+}
+
+fn wide_multiple_words(words: &[u64], divisor: Fraction, sum_words: bool) -> Verdict {
     let len = words
         .iter()
         .rposition(|&word| word != 0)
@@ -600,8 +663,8 @@ fn wide_multiple_words(words: &[u64; 16], divisor: Fraction, sum_words: bool) ->
     let mut remainder = 0_u128;
     if sum_words {
         // If base 2^64 is 1 modulo the divisor, a magnitude has the same
-        // remainder as the sum of its words. At most 16 u64 words sum below
-        // 2^68, so one u128 remainder replaces per-word division.
+        // remainder as the sum of its words. An addressable slice of u64 words
+        // sums within u128, so one remainder replaces per-word division.
         remainder = words[..len]
             .iter()
             .map(|&word| u128::from(word))
@@ -630,6 +693,15 @@ fn wide_multiple_words(words: &[u64; 16], divisor: Fraction, sum_words: bool) ->
     verdict(remainder == 0)
 }
 
+fn violates(bit: i32, order: Option<Ordering>) -> bool {
+    match bit {
+        MAXIMUM => order == Some(Ordering::Greater),
+        MINIMUM => order == Some(Ordering::Less),
+        EXCLUSIVE_MAXIMUM => matches!(order, Some(Ordering::Greater | Ordering::Equal)),
+        _ => matches!(order, Some(Ordering::Less | Ordering::Equal)),
+    }
+}
+
 fn fixnum_bounds(n: i64, limits: &[(i32, i64)]) -> Verdict {
     verdict(limits.iter().all(|&(bit, limit)| match bit {
         MAXIMUM => n <= limit,
@@ -700,7 +772,62 @@ fn wide_float_tie(value: Value, rounded: f64) -> Option<Ordering> {
 impl Rules {
     // Shared by validity scans and diagnostic prechecks. Numeric traversal
     // borrows only opaque VALUEs and uses the compiled primitive shortcuts.
-    pub(super) fn eval_guarded(&self, required: i32, value: Value) -> Verdict {
+    pub(super) fn runtime_valid(
+        &self,
+        caches: &runtime::Caches,
+        required: i32,
+        value: Value,
+    ) -> Verdict {
+        caches
+            .number(self.source, value, required)
+            .map_or(Unsupported, |frame| frame.step(0))
+    }
+    pub(super) fn runtime_failures(
+        &self,
+        caches: &runtime::Caches,
+        required: i32,
+        value: Value,
+        mut visit: impl FnMut(&'static str) -> Result<(), Verdict>,
+    ) -> Result<(), Verdict> {
+        let frame = caches.number(self.source, value, required)?;
+        if !frame.predicate(1)? {
+            if required != 0 {
+                visit("type")?;
+            }
+            return Ok(());
+        }
+        if required == TYPE_INTEGER && !frame.predicate(2)? {
+            visit("type")?;
+        }
+        if frame.step(3) != Valid {
+            return Err(Unsupported);
+        }
+        for (bit, keyword, step) in [
+            (MAXIMUM, "maximum", 4),
+            (MINIMUM, "minimum", 5),
+            (EXCLUSIVE_MAXIMUM, "exclusiveMaximum", 6),
+            (EXCLUSIVE_MINIMUM, "exclusiveMinimum", 7),
+            (MULTIPLE_OF, "multipleOf", 8),
+        ] {
+            if ((bit == MULTIPLE_OF && self.multiple.is_some())
+                || self.limits.iter().any(|&(candidate, _)| candidate == bit))
+                && !frame.predicate(step)?
+            {
+                visit(keyword)?;
+            }
+        }
+        Ok(())
+    }
+    pub(super) fn runtime_operands(&self) -> bool {
+        self.runtime_operands
+    }
+    pub(super) fn eval_guarded(
+        &self,
+        caches: &runtime::Caches,
+        required: i32,
+        value: Value,
+        budget: &budget::Budget,
+    ) -> Verdict {
         let fixnum = value & self.fixnum_flag != 0;
         if fixnum {
             if required != 0 && required & TYPE_INTEGRAL_NUMBER == 0 {
@@ -728,7 +855,7 @@ impl Rules {
         } else if kind & TYPE_NUMBER == 0 {
             Valid
         } else {
-            self.eval(value)
+            self.eval(caches, value, budget)
         }
     }
 
@@ -783,12 +910,7 @@ impl Rules {
                     Ok(order) => order,
                     Err(status) => return status,
                 };
-                if match bit {
-                    MAXIMUM => order == Some(Ordering::Greater),
-                    MINIMUM => order == Some(Ordering::Less),
-                    EXCLUSIVE_MAXIMUM => matches!(order, Some(Ordering::Greater | Ordering::Equal)),
-                    _ => matches!(order, Some(Ordering::Less | Ordering::Equal)),
-                } {
+                if violates(bit, order) {
                     return Invalid;
                 }
             }
@@ -810,19 +932,24 @@ impl Rules {
             let Some(order) = limit.integer_order(value, integer, sign) else {
                 return Unsupported;
             };
-            if match bit {
-                MAXIMUM => order == Ordering::Greater,
-                MINIMUM => order == Ordering::Less,
-                EXCLUSIVE_MAXIMUM => order != Ordering::Less,
-                _ => order != Ordering::Greater,
-            } {
+            if violates(bit, Some(order)) {
                 return Invalid;
             }
         }
         Valid
     }
 
-    pub(super) fn eval(&self, value: Value) -> Verdict {
+    pub(super) fn eval(
+        &self,
+        caches: &runtime::Caches,
+        value: Value,
+        budget: &budget::Budget,
+    ) -> Verdict {
+        if self.runtime_operands {
+            return self
+                .arbitrary_check(caches, value, budget, |_| true)
+                .map_or(Unsupported, |bits| verdict(bits == 0));
+        }
         if let Some(multiple) = &self.fast_multiple
             && value & self.fixnum_flag != 0
         {
@@ -833,10 +960,21 @@ impl Rules {
         {
             return fixnum_bounds(immediate_integer(value), limits);
         }
-        self.check(value, |_| true)
+        let result = self.check(value, |_| true);
+        if result == Unsupported {
+            self.arbitrary_check(caches, value, budget, |_| true)
+                .map_or(Unsupported, |bits| verdict(bits == 0))
+        } else {
+            result
+        }
     }
 
-    pub(super) fn failures(&self, value: Value) -> Result<i32, Verdict> {
+    fn failures(
+        &self,
+        caches: &runtime::Caches,
+        value: Value,
+        budget: &budget::Budget,
+    ) -> Result<i32, Verdict> {
         if let Some(multiple) = &self.fast_multiple
             && value & self.fixnum_flag != 0
         {
@@ -865,12 +1003,80 @@ impl Rules {
             false
         });
         if status == Unsupported {
-            Err(status)
+            self.arbitrary_check(caches, value, budget, |_| false)
         } else {
             Ok(bits)
         }
     }
 
+    pub(super) fn visit_failures(
+        &self,
+        caches: &runtime::Caches,
+        value: Value,
+        budget: &budget::Budget,
+        mut visit: impl FnMut(&'static str) -> Result<(), Verdict>,
+    ) -> Result<(), Verdict> {
+        const KEYWORDS: [(i32, &str); 5] = [
+            (MAXIMUM, "maximum"),
+            (MINIMUM, "minimum"),
+            (EXCLUSIVE_MAXIMUM, "exclusiveMaximum"),
+            (EXCLUSIVE_MINIMUM, "exclusiveMinimum"),
+            (MULTIPLE_OF, "multipleOf"),
+        ];
+        if self.runtime_operands {
+            let mut failure = None;
+            let result = self.arbitrary_check(caches, value, budget, |bit| {
+                let keyword = KEYWORDS
+                    .iter()
+                    .find(|&&(candidate, _)| candidate == bit)
+                    .expect("compiled numeric assertion")
+                    .1;
+                if let Err(status) = visit(keyword) {
+                    failure = Some(status);
+                    true
+                } else {
+                    false
+                }
+            });
+            if let Some(status) = failure {
+                Err(status)
+            } else {
+                result.map(|_| ())
+            }
+        } else {
+            let bits = self.failures(caches, value, budget)?;
+            for (bit, keyword) in KEYWORDS {
+                if !budget.checkpoint() {
+                    return Err(Unsupported);
+                }
+                if bits & bit != 0 {
+                    visit(keyword)?;
+                }
+            }
+            Ok(())
+        }
+    }
+
+    pub(super) fn memory_usage(&self) -> usize {
+        std::mem::size_of::<Self>()
+            + self.limits.capacity() * std::mem::size_of::<(i32, Limit)>()
+            + self
+                .limits
+                .iter()
+                .map(|(_, limit)| limit.arbitrary_memory_usage())
+                .sum::<usize>()
+            + self
+                .multiple
+                .as_ref()
+                .map_or(0, Limit::arbitrary_memory_usage)
+            + self.fast_limits.as_ref().map_or(0, |limits| {
+                limits.capacity() * std::mem::size_of::<(i32, i64)>()
+            })
+            + self.fast_multiple.as_ref().map_or(0, |multiple| {
+                multiple.limits.capacity() * std::mem::size_of::<(i32, i64)>()
+            })
+    }
+
     fn check_wide_multiple(
         &self,
         value: Value,
@@ -886,12 +1092,7 @@ impl Rules {
             let Some(order) = limit.integer_order(value, integer, sign) else {
                 return Unsupported;
             };
-            if match bit {
-                MAXIMUM => order == Ordering::Greater,
-                MINIMUM => order == Ordering::Less,
-                EXCLUSIVE_MAXIMUM => order != Ordering::Less,
-                _ => order != Ordering::Greater,
-            } {
+            if violates(bit, Some(order)) {
                 invalid = true;
                 if failure(bit) {
                     return Invalid;
@@ -907,7 +1108,7 @@ impl Rules {
                 .multiple_of(divisor),
             )
         } else if sign.abs() > 1 {
-            Unsupported
+            unbounded_integer_multiple(value, divisor, sum_words)
         } else {
             wide_multiple_words(&words, divisor, sum_words)
         };
@@ -944,7 +1145,7 @@ impl Rules {
         if !float && integer.is_none() {
             // An ordinary Integer outside i128 is beyond every representable
             // exact limit (whose denominator is positive). Bounds alone need
-            // only its sign. Multiples can use a bounded magnitude below.
+            // only its sign. Multiples read the full magnitude below.
             if large_sign == 0 {
                 return Unsupported;
             }
@@ -952,12 +1153,7 @@ impl Rules {
                 let Some(order) = limit.integer_order(value, None, large_sign) else {
                     return Unsupported;
                 };
-                let violates = match *bit {
-                    MAXIMUM => order == Ordering::Greater,
-                    MINIMUM => order == Ordering::Less,
-                    EXCLUSIVE_MAXIMUM => order != Ordering::Less,
-                    _ => order != Ordering::Greater,
-                };
+                let violates = violates(*bit, Some(order));
                 if violates {
                     invalid = true;
                     if failure(*bit) {
@@ -1027,12 +1223,7 @@ impl Rules {
                     n.partial_cmp(&limit.rounded)
                 }
             };
-            let violates = match *bit {
-                MAXIMUM => order == Some(Ordering::Greater),
-                MINIMUM => order == Some(Ordering::Less),
-                EXCLUSIVE_MAXIMUM => matches!(order, Some(Ordering::Greater | Ordering::Equal)),
-                _ => matches!(order, Some(Ordering::Less | Ordering::Equal)),
-            };
+            let violates = violates(*bit, order);
             if violates {
                 invalid = true;
                 if failure(*bit) {