schemurai 3.0.0 → 3.0.2

data/ext/schemurai_native/src/memo.rs

@@ -123,14 +123,16 @@ pub(super) struct Memo {
 impl Memo {
     pub(super) fn key(
         &self,
-        engine: &Engine,
+        engine: &Execution<'_>,
         node: usize,
         value: Value,
         depth: usize,
         context: scope::Context<'_>,
         budget: &budget::Budget,
     ) -> Option<Key> {
-        if !engine.memoizable[node] {
+        // Dynamic Ruby predicates may be stateful. Replayed observations already
+        // preserve reached calls; result memoization must not skip later calls.
+        if engine.caches.dynamic_calls() || !engine.memoizable[node] {
             return None;
         }
         let mut object = false;
@@ -968,29 +970,9 @@ impl Engine {
         // Cyclic candidates can reuse results only under an exact guard/scope
         // context. Propagate unsupported instructions and nested iteration
         // through reverse edges without a per-candidate graph walk.
-        let mut parents = vec![vec![]; edges.len()];
-        for (parent, children) in edges.iter().enumerate() {
-            for &child in children {
-                parents[child].push(parent);
-            }
-        }
-        fn propagate(flags: &mut [bool], parents: &[Vec<usize>]) {
-            let mut queue: std::collections::VecDeque<_> = flags
-                .iter()
-                .enumerate()
-                .filter_map(|(node, &set)| set.then_some(node))
-                .collect();
-            while let Some(node) = queue.pop_front() {
-                for &parent in &parents[node] {
-                    if !flags[parent] {
-                        flags[parent] = true;
-                        queue.push_back(parent);
-                    }
-                }
-            }
-        }
-        propagate(&mut unsupported, &parents);
-        propagate(&mut repeated_subtree, &parents);
+        let parents = graph::parents(&edges);
+        graph::propagate(&mut unsupported, &parents);
+        graph::propagate(&mut repeated_subtree, &parents);
         // Iterative Kosaraju analysis identifies the only active sources
         // whose guards can affect descendants: sources lying on a schema cycle.
         fn cycle_nodes(edges: &[Vec<usize>], parents: &[Vec<usize>]) -> Vec<bool> {
@@ -1072,19 +1054,10 @@ impl Engine {
                 }
             }
         }
-        fn reverse(edges: &[Vec<usize>]) -> Vec<Vec<usize>> {
-            let mut parents = vec![vec![]; edges.len()];
-            for (parent, children) in edges.iter().enumerate() {
-                for &child in children {
-                    parents[child].push(parent);
-                }
-            }
-            parents
-        }
-        let scalar_parents = reverse(&same_edges);
+        let scalar_parents = graph::parents(&same_edges);
         self.memo_guard_scalar_sources =
             cycle_nodes(&same_edges, &scalar_parents)[..count].to_vec();
-        propagate(&mut scalar_refs, &scalar_parents);
+        graph::propagate(&mut scalar_refs, &scalar_parents);
         let mut scalar_amplification = vec![false; edges.len()];
         for (node, ops) in self.nodes.iter().enumerate() {
             for op in ops {
@@ -1106,7 +1079,7 @@ impl Engine {
                 scalar_amplification[node] |= references > 1;
             }
         }
-        propagate(&mut scalar_amplification, &scalar_parents);
+        graph::propagate(&mut scalar_amplification, &scalar_parents);
         self.memo_guard_scalar_amplification = scalar_amplification[..count].to_vec();
         // Object dependencies keep the same value; all other container child
         // edges change positions. Scalar/array inputs cannot take dependencies.
@@ -1119,7 +1092,7 @@ impl Engine {
             }
         }
         self.memo_guard_same_sources =
-            cycle_nodes(&same_edges, &reverse(&same_edges))[..count].to_vec();
+            cycle_nodes(&same_edges, &graph::parents(&same_edges))[..count].to_vec();
         self.memo_guard_sources = cyclic[..count].to_vec();
         self.memo_guarded = vec![false; count];
         for node in 0..count {

data/ext/schemurai_native/src/number/arbitrary.rs

@@ -0,0 +1,154 @@
+//! Cold arithmetic for magnitudes outside the fixed-width scalar paths.
+//! Only ordinary numeric scalar operands are read; no Ruby allocation or
+//! method dispatch can invalidate the evaluator's borrowed instance storage.
+use super::*;
+use num_bigint::{BigInt, Sign};
+use std::borrow::Cow;
+
+fn integer(value: Value) -> BigInt {
+    if unsafe { sn_fixnum(value) } != 0 {
+        return BigInt::from(unsafe { sn_integer(value) });
+    }
+    let (words, sign) = unbounded_integer_words(value);
+    let digits = words
+        .into_iter()
+        .flat_map(|word| [word as u32, (word >> 32) as u32])
+        .collect();
+    BigInt::new(if sign < 0 { Sign::Minus } else { Sign::Plus }, digits)
+}
+
+pub(super) fn fraction(numerator: Value, denominator: Option<Value>) -> BigRational {
+    BigRational::new(
+        integer(numerator),
+        denominator.map_or_else(|| BigInt::from(1), integer),
+    )
+}
+
+fn decimal(value: f64) -> Option<BigRational> {
+    let Decimal { coefficient, power } = decimal_parts(value)?;
+    let scale = BigInt::from(10).pow(power.unsigned_abs());
+    Some(if power >= 0 {
+        BigRational::from_integer(BigInt::from(coefficient) * scale)
+    } else {
+        BigRational::new(BigInt::from(coefficient), scale)
+    })
+}
+
+impl Limit {
+    fn fraction(&self) -> Cow<'_, BigRational> {
+        if let Some(fraction) = &self.arbitrary {
+            Cow::Borrowed(fraction)
+        } else {
+            let fraction = self.exact.expect("compiled numeric fraction");
+            Cow::Owned(BigRational::new_raw(
+                BigInt::from(fraction.numerator),
+                BigInt::from(fraction.denominator),
+            ))
+        }
+    }
+
+    pub(super) fn arbitrary_memory_usage(&self) -> usize {
+        self.arbitrary.as_ref().map_or(0, |fraction| {
+            // num-bigint exposes used digits rather than allocation capacity.
+            std::mem::size_of::<BigRational>()
+                + (fraction.numer().bits().div_ceil(64) + fraction.denom().bits().div_ceil(64))
+                    as usize
+                    * 8
+        })
+    }
+}
+
+impl Rules {
+    pub(super) fn arbitrary_check(
+        &self,
+        caches: &runtime::Caches,
+        value: Value,
+        budget: &budget::Budget,
+        mut failure: impl FnMut(i32) -> bool,
+    ) -> Result<i32, Verdict> {
+        let float = unsafe { sn_is_float(value) } != 0;
+        let n = if float {
+            unsafe { sn_float(value) }
+        } else {
+            0.0
+        };
+        let actual = if float {
+            if self.multiple.is_some() {
+                if !n.is_finite() {
+                    budget.failure.set(if n.is_nan() {
+                        STATUS_DECIMAL_NAN
+                    } else if n.is_sign_negative() {
+                        STATUS_DECIMAL_NEGATIVE_INFINITY
+                    } else {
+                        STATUS_DECIMAL_POSITIVE_INFINITY
+                    });
+                    return Err(Unsupported);
+                }
+                Some(decimal(n).ok_or(Unsupported)?)
+            } else {
+                None
+            }
+        } else {
+            if unsafe { sn_kind(value) } & TYPE_INTEGER == 0 {
+                return Err(Unsupported);
+            }
+            Some(BigRational::from_integer(integer(value)))
+        };
+        // Without multipleOf, Ruby compares a Float to Integer bounds exactly
+        // in binary, but rounds Rational bounds to Float. With multipleOf,
+        // Ruby first converts the instance's decimal spelling to a Rational.
+        let binary = if actual.is_none() && self.limits.iter().any(|(_, limit)| limit.integer) {
+            BigRational::from_float(n)
+        } else {
+            None
+        };
+        let mut bits = 0;
+        for (bit, limit) in &self.limits {
+            if !budget.checkpoint() {
+                return Err(Unsupported);
+            }
+            let violates = limit.violation(caches, value, *bit, self.multiple.is_some(), || {
+                let order = if let Some(actual) = &actual {
+                    Some(actual.cmp(limit.fraction().as_ref()))
+                } else if !limit.integer {
+                    n.partial_cmp(&limit.rounded)
+                } else if let Some(binary) = &binary {
+                    Some(binary.cmp(limit.fraction().as_ref()))
+                } else if n.is_nan() {
+                    None
+                } else {
+                    Some(if n.is_sign_negative() {
+                        Ordering::Less
+                    } else {
+                        Ordering::Greater
+                    })
+                };
+                violates(*bit, order)
+            })?;
+            if violates {
+                bits |= bit;
+                if failure(*bit) {
+                    return Ok(bits);
+                }
+            }
+        }
+        if let Some(limit) = &self.multiple {
+            if !budget.checkpoint() {
+                return Err(Unsupported);
+            }
+            let violates = limit.violation(caches, value, MULTIPLE_OF, true, || {
+                let divisor = limit.fraction();
+                let actual = actual.as_ref().expect("multipleOf decimal operand");
+                let valid = divisor.numer().sign() == Sign::Plus
+                    && (actual.numer() % divisor.numer()).sign() == Sign::NoSign
+                    && (divisor.denom() % actual.denom()).sign() == Sign::NoSign;
+                !valid
+            })?;
+            if violates {
+                bits |= MULTIPLE_OF;
+                failure(MULTIPLE_OF);
+            }
+        }
+        Ok(bits)
+    }
+}