schemurai 2.3.0 → 3.0.0

data/ext/schemurai_native/src/enumeration.rs

@@ -0,0 +1,154 @@
+//! Large enums retain a compiled fingerprint index over pinned schema values.
+//! Hashes only select candidates; JSON equality still decides every match.
+use super::*;
+
+const LINEAR_LIMIT: usize = 16;
+const MAX_INDEX_BYTES: usize = 64 * 1024 * 1024;
+
+#[derive(Debug)]
+pub(super) struct Enumeration {
+    values: Vec<Value>,
+    index: Option<Index>,
+    kinds: i32,
+}
+
+impl Enumeration {
+    pub(super) fn compile(values: Vec<Value>, fixnum_flag: Value) -> Self {
+        let mut fingerprints = structural::Cache::batch(0);
+        let budget = budget::Budget::default();
+        let index = (values.len() > LINEAR_LIMIT)
+            .then(|| {
+                Index::compile(&values, |value| {
+                    fingerprint_cached(value, 0, fixnum_flag, false, &mut fingerprints, &budget)
+                })
+            })
+            .flatten();
+        let kinds = if index.is_some() {
+            values
+                .iter()
+                .fold(0, |mask, &value| mask | unsafe { sn_shallow_kind(value) })
+        } else {
+            0
+        };
+        Self {
+            values,
+            index,
+            kinds,
+        }
+    }
+
+    pub(super) fn eval(
+        &self,
+        value: Value,
+        kind: i32,
+        depth: usize,
+        fixnum_flag: Value,
+        budget: &budget::Budget,
+    ) -> Verdict {
+        if let Some(index) = &self.index {
+            // All indexed schema values are supported. A disjoint root type
+            // cannot match, even if the input contains unsupported descendants.
+            // Avoid fingerprinting large containers for scalar-only enums.
+            if kind & self.kinds == 0 {
+                return Invalid;
+            }
+            // Keep the best-case linear lookup cheap. This also avoids hashing
+            // a whole input container when the first candidate already matches.
+            let first = equal_budgeted(self.values[0], value, depth, budget);
+            if first != Invalid {
+                return first;
+            }
+            if let Some(hash) = fingerprint_budgeted(value, depth, fixnum_flag, false, budget) {
+                return self.compare(
+                    index.candidates(hash).filter(|&index| index != 0),
+                    value,
+                    depth,
+                    budget,
+                );
+            }
+            return self.compare(1..self.values.len(), value, depth, budget);
+        }
+        // An unavailable fingerprint is not an unsupported comparison. Linear
+        // equality can reject a different shape before reaching that value.
+        self.compare(0..self.values.len(), value, depth, budget)
+    }
+
+    fn compare(
+        &self,
+        candidates: impl Iterator<Item = usize>,
+        value: Value,
+        depth: usize,
+        budget: &budget::Budget,
+    ) -> Verdict {
+        for index in candidates {
+            let result = equal_budgeted(self.values[index], value, depth, budget);
+            if result != Invalid {
+                return result;
+            }
+        }
+        Invalid
+    }
+
+    pub(super) fn memory_usage(&self) -> usize {
+        std::mem::size_of::<Self>()
+            + self.values.capacity() * std::mem::size_of::<Value>()
+            + self.index.as_ref().map_or(0, |index| {
+                index.entries.capacity() * std::mem::size_of::<(u64, usize)>()
+            })
+    }
+}
+
+#[derive(Debug)]
+struct Index {
+    entries: Vec<(u64, usize)>,
+}
+
+impl Index {
+    fn compile(values: &[Value], mut hash: impl FnMut(Value) -> Option<u64>) -> Option<Self> {
+        if values
+            .len()
+            .checked_mul(std::mem::size_of::<(u64, usize)>())?
+            > MAX_INDEX_BYTES
+        {
+            return None;
+        }
+        let mut entries = Vec::new();
+        entries.try_reserve_exact(values.len()).ok()?;
+        for (index, &value) in values.iter().enumerate() {
+            entries.push((hash(value)?, index));
+        }
+        // A sorted flat index bounds memory and compilation to O(E log E),
+        // even for colliding fingerprints. Equal hashes retain schema order.
+        entries.sort_unstable();
+        Some(Self { entries })
+    }
+
+    fn candidates(&self, hash: u64) -> impl Iterator<Item = usize> + '_ {
+        let start = self
+            .entries
+            .partition_point(|&(candidate, _)| candidate < hash);
+        self.entries[start..]
+            .iter()
+            .take_while(move |&&(candidate, _)| candidate == hash)
+            .map(|&(_, index)| index)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn selects_all_collisions_in_schema_order() {
+        let index = Index::compile(&[3, 1, 3, 2, 3], |value| Some(value as u64)).unwrap();
+        assert_eq!(index.candidates(3).collect::<Vec<_>>(), [0, 2, 4]);
+        assert_eq!(index.candidates(1).collect::<Vec<_>>(), [1]);
+        assert_eq!(index.candidates(0).count(), 0);
+        assert_eq!(index.candidates(4).count(), 0);
+    }
+
+    #[test]
+    fn unavailable_fingerprint_discards_the_index() {
+        assert!(Index::compile(&[1, 2, 3], |value| (value != 2).then_some(value as u64)).is_none());
+    }
+}

data/ext/schemurai_native/src/evaluation.rs

@@ -0,0 +1,219 @@
+//! Shared branch and contains scans with separate result and termination policies.
+use super::*;
+use tracking::Tracked;
+
+#[derive(Clone, Copy)]
+pub(super) enum BranchKind {
+    Any,
+    One,
+}
+impl BranchKind {
+    pub(super) fn accepts(self, matches: usize) -> bool {
+        match self {
+            Self::Any => matches > 0,
+            Self::One => matches == 1,
+        }
+    }
+    pub(super) fn keyword(self) -> &'static str {
+        match self {
+            Self::Any => "anyOf",
+            Self::One => "oneOf",
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+pub(super) enum BranchPolicy {
+    Validity(BranchKind),
+    // Annotations, exact diagnostic counts and compatibility exceptions can
+    // require later branches even after validity alone is conclusive.
+    Complete,
+}
+impl BranchPolicy {
+    fn finished(self, matches: usize) -> bool {
+        match self {
+            Self::Validity(BranchKind::Any) => matches > 0,
+            Self::Validity(BranchKind::One) => matches > 1,
+            Self::Complete => false,
+        }
+    }
+}
+
+pub(super) trait BranchResult {
+    fn valid() -> Self;
+    fn status(&self) -> Verdict;
+    fn merge(&mut self, branch: Self);
+}
+impl BranchResult for Verdict {
+    fn valid() -> Self {
+        Valid
+    }
+    fn status(&self) -> Verdict {
+        *self
+    }
+    fn merge(&mut self, _: Self) {}
+}
+impl BranchResult for Tracked {
+    fn valid() -> Self {
+        Self::new(Valid)
+    }
+    fn status(&self) -> Verdict {
+        self.status
+    }
+    fn merge(&mut self, branch: Self) {
+        self.merge(branch);
+    }
+}
+
+pub(super) struct BranchMatches<R> {
+    pub matches: usize,
+    pub coverage: R,
+}
+pub(super) fn scan_branches<R: BranchResult>(
+    nodes: &[(usize, usize)],
+    policy: BranchPolicy,
+    mut evaluate: impl FnMut(usize) -> R,
+) -> Result<BranchMatches<R>, Verdict> {
+    let mut result = BranchMatches {
+        matches: 0,
+        coverage: R::valid(),
+    };
+    for &(node, multiplicity) in nodes {
+        let branch = evaluate(node);
+        match branch.status() {
+            Unsupported => return Err(Unsupported),
+            Invalid => {}
+            Valid => {
+                result.matches += multiplicity;
+                result.coverage.merge(branch);
+            }
+        }
+        if policy.finished(result.matches) {
+            break;
+        }
+    }
+    Ok(result)
+}
+
+// Diagnostic counts and annotations need every match. Keep the same complete
+// traversal for ordinary validity so unsupported later items retain fallback.
+pub(super) fn scan_contains(
+    len: usize,
+    mut evaluate: impl FnMut(usize) -> Verdict,
+    mut record: impl FnMut(usize),
+) -> Result<usize, Verdict> {
+    let mut matches = 0;
+    for index in 0..len {
+        match evaluate(index) {
+            Unsupported => return Err(Unsupported),
+            Invalid => {}
+            Valid => {
+                matches += 1;
+                record(index);
+            }
+        }
+    }
+    Ok(matches)
+}
+
+// Use only after proving every remaining predicate evaluation is supported.
+// Annotation and diagnostic policies continue using the complete scan above.
+pub(super) fn contains_validity(
+    len: usize,
+    min: usize,
+    max: Option<usize>,
+    mut evaluate: impl FnMut(usize) -> bool,
+) -> Verdict {
+    if len < min || max.is_some_and(|max| max < min) {
+        return Invalid;
+    }
+    // Infinity and any bound at least as large as the array cannot constrain
+    // its match count. The VM represents an absent maxContains as +Infinity.
+    let max = max.filter(|&max| max < len);
+    if min == 0 && max.is_none() {
+        return Valid;
+    }
+    let mut matches = 0;
+    for index in 0..len {
+        matches += usize::from(evaluate(index));
+        if max.is_some_and(|max| matches > max) {
+            return Invalid;
+        }
+        if max.is_none() && matches >= min {
+            return Valid;
+        }
+        if matches + (len - index - 1) < min {
+            return Invalid;
+        }
+    }
+    bounds(matches, Some(min), max)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn contains_termination_matches_complete_counts() {
+        for len in 0..8 {
+            for mask in 0..(1 << len) {
+                let count = (mask as u32).count_ones() as usize;
+                for min in 0..9 {
+                    for max in [None, Some(0), Some(1), Some(4), Some(8)] {
+                        assert_eq!(
+                            contains_validity(len, min, max, |i| mask & (1 << i) != 0),
+                            bounds(count, Some(min), max)
+                        );
+                    }
+                }
+            }
+        }
+        let mut calls = 0;
+        assert_eq!(
+            contains_validity(1000, 1, None, |_| {
+                calls += 1;
+                true
+            }),
+            Valid
+        );
+        assert_eq!(calls, 1);
+    }
+
+    #[test]
+    fn termination_preserves_multiplicity_and_complete_scan_errors() {
+        let nodes = [(0, 2), (1, 1)];
+        let evaluate = |node| if node == 0 { Valid } else { Unsupported };
+        for kind in [BranchKind::Any, BranchKind::One] {
+            let result = scan_branches(&nodes, BranchPolicy::Validity(kind), evaluate).unwrap();
+            assert_eq!(result.matches, 2);
+            assert_eq!(
+                kind.accepts(result.matches),
+                matches!(kind, BranchKind::Any)
+            );
+        }
+        assert!(matches!(
+            scan_branches(&nodes, BranchPolicy::Complete, evaluate),
+            Err(Unsupported)
+        ));
+    }
+
+    #[test]
+    fn contains_records_only_matches_and_retains_later_unsupported_results() {
+        let mut recorded = vec![];
+        let result = scan_contains(
+            4,
+            |index| verdict(index % 2 == 0),
+            |index| recorded.push(index),
+        );
+        assert_eq!(result, Ok(2));
+        assert_eq!(recorded, [0, 2]);
+        assert_eq!(
+            scan_contains(
+                2,
+                |index| if index == 0 { Valid } else { Unsupported },
+                |_| {}
+            ),
+            Err(Unsupported)
+        );
+    }
+}

data/ext/schemurai_native/src/graph.rs

@@ -0,0 +1,50 @@
+//! Iterative schema graph traversal used by compilation analyses.
+
+// Callers own the visited buffer so cycle analysis can reuse it in the
+// reverse pass. Keep discovery and child order identical for both analyses.
+pub(super) fn postorder(edges: &[Vec<usize>], seen: &mut [bool]) -> Vec<usize> {
+    let mut order = vec![];
+    for root in 0..edges.len() {
+        if seen[root] {
+            continue;
+        }
+        seen[root] = true;
+        let mut stack = vec![(root, 0)];
+        while let Some((node, next)) = stack.last_mut() {
+            if let Some(&child) = edges[*node].get(*next) {
+                *next += 1;
+                if !seen[child] {
+                    seen[child] = true;
+                    stack.push((child, 0));
+                }
+            } else {
+                order.push(*node);
+                stack.pop();
+            }
+        }
+    }
+    order
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn orders_disconnected_cycles_and_shared_children() {
+        let edges = vec![vec![1, 2], vec![2], vec![0], vec![3], vec![]];
+        let mut seen = vec![false; edges.len()];
+        assert_eq!(postorder(&edges, &mut seen), [2, 1, 0, 3, 4]);
+        assert!(seen.iter().all(|&visited| visited));
+        assert!(postorder(&[], &mut []).is_empty());
+    }
+
+    #[test]
+    fn deep_chains_use_an_explicit_stack() {
+        let count = 100_000;
+        let mut edges: Vec<_> = (1..count).map(|child| vec![child]).collect();
+        edges.push(vec![]);
+        let order = postorder(&edges, &mut vec![false; count]);
+        assert!(order.into_iter().eq((0..count).rev()));
+    }
+}

data/ext/schemurai_native/src/instance_graph.rs

@@ -0,0 +1,84 @@
+//! Bounded, invocation-local proof that container values cannot revisit an
+//! ancestor instance. Read under the GVL, without Ruby allocations/callbacks.
+use super::*;
+
+const MAX_VISITS: usize = 4096;
+
+pub(super) struct Graph {
+    proven: structural::Cache<Value, bool>,
+}
+impl Default for Graph {
+    fn default() -> Self {
+        Self {
+            proven: structural::Cache::new(0),
+        }
+    }
+}
+impl Graph {
+    pub(super) fn acyclic(&mut self, value: Value, budget: &budget::Budget) -> bool {
+        self.visit(value, 0, &mut HashMap::new(), budget)
+    }
+    fn visit(
+        &mut self,
+        value: Value,
+        depth: usize,
+        states: &mut HashMap<Value, bool>,
+        budget: &budget::Budget,
+    ) -> bool {
+        if !budget.checkpoint() {
+            return false;
+        }
+        let kind = unsafe { sn_shallow_kind(value) };
+        if kind != TYPE_ARRAY && kind != TYPE_OBJECT {
+            return kind != TYPE_UNSUPPORTED;
+        }
+        if self.proven.get(value) == Some(true) {
+            return true;
+        }
+        if let Some(&done) = states.get(&value) {
+            return done;
+        }
+        if depth > MAX_EVALUATION_DEPTH || states.len() == MAX_VISITS {
+            return false;
+        }
+        states.insert(value, false);
+        let complete = if kind == TYPE_ARRAY {
+            let len = unsafe { sn_len(value) };
+            if !budget.checkpoint() {
+                return false;
+            }
+            (0..len).all(|i| self.visit(unsafe { sn_entry(value, i) }, depth + 1, states, budget))
+        } else {
+            let mut context = Walk {
+                graph: self,
+                states,
+                depth: depth + 1,
+                budget,
+            };
+            (unsafe { sn_hash_each(value, (&mut context as *mut Walk<'_>).cast(), entry) })
+                == VERDICT_VALID
+        };
+        if complete {
+            states.insert(value, true);
+            self.proven.record(value, true);
+        }
+        complete
+    }
+}
+struct Walk<'a> {
+    graph: &'a mut Graph,
+    states: &'a mut HashMap<Value, bool>,
+    depth: usize,
+    budget: &'a budget::Budget,
+}
+unsafe extern "C" fn entry(context: *mut c_void, _key: Value, value: Value) -> i32 {
+    catch_unwind(AssertUnwindSafe(|| {
+        let context = unsafe { &mut *context.cast::<Walk<'_>>() };
+        verdict(
+            context
+                .graph
+                .visit(value, context.depth, context.states, context.budget),
+        ) as i32
+    }))
+    .unwrap_or(VERDICT_INVALID)
+}