schemurai 3.0.1 → 3.0.2

data/ext/schemurai_native/src/enumeration.rs

@@ -7,13 +7,14 @@ const MAX_INDEX_BYTES: usize = 64 * 1024 * 1024;
 
 #[derive(Debug)]
 pub(super) struct Enumeration {
+    source: Value,
     values: Vec<Value>,
     index: Option<Index>,
     kinds: i32,
 }
 
 impl Enumeration {
-    pub(super) fn compile(values: Vec<Value>, fixnum_flag: Value) -> Self {
+    pub(super) fn compile(source: Value, 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)
@@ -31,12 +32,16 @@ impl Enumeration {
             0
         };
         Self {
+            source,
             values,
             index,
             kinds,
         }
     }
 
+    pub(super) fn runtime(&self, caches: &runtime::Caches, value: Value) -> Verdict {
+        caches.equality(self.source, value, RUNTIME_ENUM)
+    }
     pub(super) fn eval(
         &self,
         value: Value,

data/ext/schemurai_native/src/evaluation.rs

@@ -42,7 +42,6 @@ impl BranchPolicy {
 pub(super) trait BranchResult {
     fn valid() -> Self;
     fn status(&self) -> Verdict;
-    fn merge(&mut self, branch: Self);
 }
 impl BranchResult for Verdict {
     fn valid() -> Self {
@@ -51,7 +50,6 @@ impl BranchResult for Verdict {
     fn status(&self) -> Verdict {
         *self
     }
-    fn merge(&mut self, _: Self) {}
 }
 impl BranchResult for Tracked {
     fn valid() -> Self {
@@ -60,9 +58,6 @@ impl BranchResult for Tracked {
     fn status(&self) -> Verdict {
         self.status
     }
-    fn merge(&mut self, branch: Self) {
-        self.merge(branch);
-    }
 }
 
 pub(super) struct BranchMatches<R> {
@@ -72,33 +67,44 @@ pub(super) struct BranchMatches<R> {
 pub(super) fn scan_branches<R: BranchResult>(
     nodes: &[(usize, usize)],
     policy: BranchPolicy,
+    separate_calls: bool,
     mut evaluate: impl FnMut(usize) -> R,
+    mut merge: impl FnMut(&mut R, R) -> Result<(), Verdict>,
 ) -> 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);
+    'groups: for &(node, multiplicity) in nodes {
+        for _ in 0..if separate_calls { multiplicity } else { 1 } {
+            let branch = evaluate(node);
+            match branch.status() {
+                Unsupported => return Err(Unsupported),
+                Invalid => {}
+                Valid => {
+                    result.matches += if separate_calls { 1 } else { multiplicity };
+                    merge(&mut result.coverage, branch)?;
+                }
+            }
+            if policy.finished(result.matches) {
+                break 'groups;
             }
-        }
-        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.
+#[derive(Clone, Copy)]
+pub(super) enum ContainsPolicy {
+    FirstMatch,
+    AllMatches,
+}
+
+// Older dialects use any? for untracked validity; counted validity,
+// diagnostic counts and annotations need every match.
 pub(super) fn scan_contains(
     len: usize,
+    policy: ContainsPolicy,
     mut evaluate: impl FnMut(usize) -> Verdict,
     mut record: impl FnMut(usize),
 ) -> Result<usize, Verdict> {
@@ -110,6 +116,9 @@ pub(super) fn scan_contains(
             Valid => {
                 matches += 1;
                 record(index);
+                if matches!(policy, ContainsPolicy::FirstMatch) {
+                    break;
+                }
             }
         }
     }
@@ -184,7 +193,14 @@ mod tests {
         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();
+            let result = scan_branches(
+                &nodes,
+                BranchPolicy::Validity(kind),
+                false,
+                evaluate,
+                |_, _| Ok(()),
+            )
+            .unwrap();
             assert_eq!(result.matches, 2);
             assert_eq!(
                 kind.accepts(result.matches),
@@ -192,7 +208,9 @@ mod tests {
             );
         }
         assert!(matches!(
-            scan_branches(&nodes, BranchPolicy::Complete, evaluate),
+            scan_branches(&nodes, BranchPolicy::Complete, false, evaluate, |_, _| Ok(
+                ()
+            )),
             Err(Unsupported)
         ));
     }
@@ -202,6 +220,7 @@ mod tests {
         let mut recorded = vec![];
         let result = scan_contains(
             4,
+            ContainsPolicy::AllMatches,
             |index| verdict(index % 2 == 0),
             |index| recorded.push(index),
         );
@@ -210,6 +229,16 @@ mod tests {
         assert_eq!(
             scan_contains(
                 2,
+                ContainsPolicy::FirstMatch,
+                |index| if index == 0 { Valid } else { Unsupported },
+                |_| {}
+            ),
+            Ok(1)
+        );
+        assert_eq!(
+            scan_contains(
+                2,
+                ContainsPolicy::AllMatches,
                 |index| if index == 0 { Valid } else { Unsupported },
                 |_| {}
             ),

data/ext/schemurai_native/src/format.rs

@@ -51,9 +51,6 @@ impl Format {
             Self::Unsupported => return Unsupported,
         })
     }
-    pub(super) fn eval_items(&self, required: i32, values: &[Value]) -> Verdict {
-        self.visit_invalid_items(required, values, |_, _| Invalid)
-    }
     pub(super) fn visit_invalid_items(
         &self,
         required: i32,
@@ -91,9 +88,14 @@ fn scan_items(
         let mut data = std::ptr::null();
         let mut len = 0;
         let kind = unsafe { sn_format_item_view(value, &mut data, &mut len) };
-        let result = if kind == -TYPE_UNSUPPORTED {
-            Unsupported
-        } else if kind < 0 {
+        if kind == -TYPE_UNSUPPORTED {
+            let status = invalid(index, value);
+            if status != Valid {
+                return status;
+            }
+            continue;
+        }
+        let result = if kind < 0 {
             verdict(required == 0)
         } else {
             matches(unsafe { byte_view(data, len) })

data/ext/schemurai_native/src/graph.rs

@@ -26,6 +26,34 @@ pub(super) fn postorder(edges: &[Vec<usize>], seen: &mut [bool]) -> Vec<usize> {
     order
 }
 
+pub(super) fn parents(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
+}
+
+// Reachability flags flow from children to parents, including through cycles.
+// Each newly marked node enters the queue once.
+pub(super) 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);
+            }
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -39,6 +67,15 @@ mod tests {
         assert!(postorder(&[], &mut []).is_empty());
     }
 
+    #[test]
+    fn flags_propagate_through_cycles_without_marking_disconnected_nodes() {
+        let parents = vec![vec![2], vec![0], vec![1, 3], vec![], vec![4]];
+        let mut flags = vec![false, true, false, false, false];
+        propagate(&mut flags, &parents);
+        assert_eq!(flags, [true, true, true, true, false]);
+        propagate(&mut [], &[]);
+    }
+
     #[test]
     fn deep_chains_use_an_explicit_stack() {
         let count = 100_000;

data/ext/schemurai_native/src/instance_graph.rs

@@ -82,3 +82,93 @@ unsafe extern "C" fn entry(context: *mut c_void, _key: Value, value: Value) -> i
     }))
     .unwrap_or(VERDICT_INVALID)
 }
+
+enum Work {
+    Visit(Value),
+    Finish(Value),
+}
+
+pub(super) enum Safety {
+    Ordinary,
+    Cyclic,
+    Unsupported,
+}
+
+// A failed fingerprint may indicate either an optimization bound or Ruby
+// behavior that native equality must not skip. Classify every reachable value
+// before substituting direct comparisons or a stack error for hashing. Continue
+// after detecting a cycle: any special value still requires Ruby's behavior.
+// Unlike the memoization hint above, this rare path needs no depth/visit cap.
+pub(super) fn ordinary_graph(value: Value, budget: &budget::Budget) -> Safety {
+    let mut work = vec![Work::Visit(value)];
+    let mut states = HashMap::new();
+    let mut cyclic = false;
+    while let Some(task) = work.pop() {
+        if !budget.checkpoint() {
+            return Safety::Unsupported;
+        }
+        match task {
+            Work::Finish(value) => {
+                states.insert(value, true);
+            }
+            Work::Visit(value) => {
+                if let Some(&done) = states.get(&value) {
+                    if !done {
+                        cyclic = true;
+                    }
+                    continue;
+                }
+                match unsafe { sn_kind(value) } {
+                    TYPE_UNSUPPORTED => return Safety::Unsupported,
+                    TYPE_ARRAY => {
+                        states.insert(value, false);
+                        work.push(Work::Finish(value));
+                        for i in (0..unsafe { sn_len(value) }).rev() {
+                            work.push(Work::Visit(unsafe { sn_entry(value, i) }));
+                        }
+                    }
+                    TYPE_OBJECT => {
+                        states.insert(value, false);
+                        work.push(Work::Finish(value));
+                        let mut context = OrdinaryWalk {
+                            work: &mut work,
+                            budget,
+                        };
+                        if unsafe {
+                            sn_hash_each(
+                                value,
+                                (&mut context as *mut OrdinaryWalk<'_>).cast(),
+                                ordinary_entry,
+                            )
+                        } != VERDICT_VALID
+                        {
+                            return Safety::Unsupported;
+                        }
+                    }
+                    _ => {}
+                }
+            }
+        }
+    }
+    if cyclic {
+        Safety::Cyclic
+    } else {
+        Safety::Ordinary
+    }
+}
+
+struct OrdinaryWalk<'a> {
+    work: &'a mut Vec<Work>,
+    budget: &'a budget::Budget,
+}
+unsafe extern "C" fn ordinary_entry(context: *mut c_void, _: Value, value: Value) -> i32 {
+    catch_unwind(AssertUnwindSafe(|| {
+        let context = unsafe { &mut *context.cast::<OrdinaryWalk<'_>>() };
+        if !context.budget.checkpoint() {
+            return VERDICT_UNSUPPORTED;
+        }
+        context.work.push(Work::Visit(value));
+        VERDICT_VALID
+    }))
+    .unwrap_or(VERDICT_UNSUPPORTED)
+}