schemurai 2.3.0 → 3.0.1

data/ext/schemurai_native/src/scope.rs

@@ -10,6 +10,85 @@ pub(super) struct Metadata {
     pub dynamic_anchor: Option<Value>,
     pub primary_binding: Option<usize>,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn requires_guard_histories_for_cycles_reached_through_dynamic_overrides() {
+        let reference = |target, kind| Op::Ref(Reference { target, kind });
+        let mut engine = Engine {
+            nodes: vec![
+                vec![Op::Boolean(true)],
+                vec![reference(0, ReferenceKind::Dynamic(0))],
+                vec![reference(1, ReferenceKind::Static)],
+                vec![reference(1, ReferenceKind::Static)],
+                vec![reference(1, ReferenceKind::Static)],
+            ],
+            anchor_tables: vec![vec![(100, 0), (101, 1)]],
+            ..Engine::default()
+        };
+        engine.compile_memoization();
+        assert!(engine.memoizable[1]);
+        assert!(engine.memo_guarded[1]);
+        engine.nodes.pop();
+        engine.compile_memoization();
+        assert!(!engine.memoizable[1]);
+        assert!(engine.memo_guard_sources[1]);
+        engine.nodes.push(vec![reference(1, ReferenceKind::Static)]);
+        engine.nodes[0] = vec![Op::Unsupported];
+        engine.compile_memoization();
+        assert!(!engine.memoizable[1]);
+    }
+
+    #[test]
+    fn removes_scope_keys_only_for_proven_invariant_dynamic_targets() {
+        let reference = |target, kind| Op::Ref(Reference { target, kind });
+        let mut engine = Engine {
+            nodes: vec![
+                vec![Op::Boolean(true)],
+                vec![reference(0, ReferenceKind::Dynamic(0))],
+                vec![reference(0, ReferenceKind::Dynamic(0))],
+                vec![Op::All(vec![1, 2])],
+                vec![reference(3, ReferenceKind::Static)],
+                vec![reference(3, ReferenceKind::Static)],
+                vec![reference(0, ReferenceKind::Dynamic(1))],
+                vec![reference(0, ReferenceKind::Dynamic(2))],
+                vec![reference(0, ReferenceKind::Dynamic(3))],
+                vec![reference(0, ReferenceKind::Recursive)],
+            ],
+            anchor_tables: vec![
+                vec![(100, 0), (101, 0)],
+                vec![(100, 0), (101, 3)],
+                vec![(100, 3)],
+                vec![],
+            ],
+            ..Engine::default()
+        };
+        engine.compile_memoization();
+        assert!(engine.memoizable[3]);
+        assert!(engine.memo_contextual[3]);
+        engine.simplify_dynamic_references();
+        engine.compile_memoization();
+        assert!(engine.memoizable[3]);
+        assert!(!engine.memo_contextual[3]);
+        for node in [1, 2] {
+            let Op::Ref(reference) = engine.nodes[node][0] else {
+                panic!()
+            };
+            assert_eq!(reference.static_target(), Some(0));
+        }
+        // Changing bindings, fallback mismatches, absent bindings and
+        // recursive references retain context-sensitive resolution.
+        for node in [6, 7, 8, 9] {
+            let Op::Ref(reference) = engine.nodes[node][0] else {
+                panic!()
+            };
+            assert_eq!(reference.static_target(), None);
+        }
+    }
+}
 #[derive(Clone, Copy, Debug)]
 enum ReferenceKind {
     Static,
@@ -31,7 +110,50 @@ pub(super) struct ScopeFrame<'a> {
     pub parent: Option<&'a ScopeFrame<'a>>,
     pub primary_binding: Option<usize>,
 }
+impl Reference {
+    pub(super) fn dynamic_target(self) -> Option<(usize, usize)> {
+        match self.kind {
+            ReferenceKind::Dynamic(name) => Some((name, self.target)),
+            _ => None,
+        }
+    }
+    pub(super) fn recursive_target(self) -> Option<usize> {
+        matches!(self.kind, ReferenceKind::Recursive).then_some(self.target)
+    }
+    pub(super) fn static_target(self) -> Option<usize> {
+        matches!(self.kind, ReferenceKind::Static).then_some(self.target)
+    }
+}
 impl Engine {
+    pub(super) fn simplify_dynamic_references(&mut self) {
+        // Anchor binding has reached its fixed point, including resources
+        // compiled while discovering overrides. A name whose every binding
+        // equals the fallback target cannot change under any native scope.
+        // Preserve the source opcode for diagnostic paths, while allowing
+        // ordinary acyclic static-target memoization for the shared graph.
+        let invariant: Vec<_> = self
+            .anchor_tables
+            .iter()
+            .map(|bindings| {
+                let &(_, target) = bindings.first()?;
+                bindings
+                    .iter()
+                    .all(|&(_, candidate)| candidate == target)
+                    .then_some(target)
+            })
+            .collect();
+        for ops in &mut self.nodes {
+            for op in ops {
+                if let Op::Ref(reference) = op
+                    && let ReferenceKind::Dynamic(name) = reference.kind
+                    && invariant[name] == Some(reference.target)
+                {
+                    reference.kind = ReferenceKind::Static;
+                }
+            }
+        }
+    }
+
     pub(super) fn compile_scope(
         &mut self,
         program: Value,
@@ -86,15 +208,14 @@ impl Engine {
                         && unsafe { sn_string_equal(fragment, anchor) } != 0 =>
                 {
                     let name = JsonKey::new(fragment);
-                    let index = self
-                        .anchor_names
-                        .iter()
-                        .position(|&candidate| candidate == name)
-                        .unwrap_or_else(|| {
-                            let index = self.anchor_names.len();
-                            self.anchor_names.push(name);
-                            index
-                        });
+                    let index = if let Some(&index) = self.anchor_ids.get(&name) {
+                        index
+                    } else {
+                        let index = self.anchor_names.len();
+                        self.anchor_names.push(name);
+                        self.anchor_ids.insert(name, index);
+                        index
+                    };
                     ReferenceKind::Dynamic(index)
                 }
                 _ => ReferenceKind::Static,
@@ -105,35 +226,127 @@ impl Engine {
         Ok(Op::Ref(Reference { target, kind }))
     }
     pub(super) fn bind_dynamic_anchors(&mut self) -> Result<(), Value> {
+        // Names append during compilation. A resolved prefix per resource
+        // records negative lookups without retaining their Cartesian product.
+        // Snapshot only pending rows; compiling a binding can add resources
+        // and names, which the next pass must resolve too.
+        let mut resolved = HashMap::new();
         loop {
+            let names = self.anchor_names.len();
+            if names > 1 {
+                return self.bind_indexed_dynamic_anchors();
+            }
             let pending: Vec<_> = self
                 .resources
                 .keys()
-                .flat_map(|&resource| {
-                    (0..self.anchor_names.len()).map(move |name| (resource, name))
+                .filter_map(|&resource| {
+                    let first = resolved.get(&resource).copied().unwrap_or(0);
+                    (first < names).then_some((resource, first..names))
                 })
-                .filter(|key| !self.dynamic_bindings.contains_key(key))
                 .collect();
             if pending.is_empty() {
-                self.anchor_tables = vec![vec![]; self.anchor_names.len()];
-                for (&(resource, name), &target) in &self.dynamic_bindings {
-                    if let Some(target) = target {
-                        self.anchor_tables[name].push((resource, target));
+                self.finish_dynamic_bindings();
+                return Ok(());
+            }
+            for (resource, names) in pending {
+                let end = names.end;
+                for name in names {
+                    let mut target = 0;
+                    if unsafe {
+                        sn_anchor_program(
+                            self.compiler,
+                            resource,
+                            self.anchor_names[name].0,
+                            &mut target,
+                        )
+                    } != 0
+                    {
+                        return Err(target);
+                    }
+                    if unsafe { sn_same(target, sn_nil()) } == 0 {
+                        self.retain(target);
+                        let target = self.compile(target)?;
+                        self.dynamic_bindings.insert((resource, name), target);
                     }
                 }
-                if self.anchor_tables.len() == 1 {
-                    for metadata in &mut self.metadata {
-                        metadata.primary_binding =
-                            self.anchor_tables[0]
-                                .iter()
-                                .find_map(|&(resource, target)| {
-                                    (resource == metadata.resource).then_some(target)
-                                });
+                resolved.insert(resource, end);
+            }
+        }
+    }
+    fn finish_dynamic_bindings(&mut self) {
+        self.anchor_tables = vec![vec![]; self.anchor_names.len()];
+        for (&(resource, name), &target) in &self.dynamic_bindings {
+            self.anchor_tables[name].push((resource, target));
+        }
+        if self.anchor_names.len() == 1 {
+            for metadata in &mut self.metadata {
+                // Use the existing resource/name index instead of an
+                // O(binding count) scan for every compiled node.
+                metadata.primary_binding =
+                    self.dynamic_bindings.get(&(metadata.resource, 0)).copied();
+            }
+        }
+        // Compiler-only name indexes cannot be reused at runtime. Drop
+        // their allocations and temporary GC roots after the fixed point.
+        drop(std::mem::take(&mut self.anchor_ids));
+        drop(std::mem::take(
+            &mut unsafe { &mut *self.roots }.binding_names,
+        ));
+    }
+
+    fn bind_indexed_dynamic_anchors(&mut self) -> Result<(), Value> {
+        // Join registered names with resources that actually bind them. Resource
+        // tables append names, including when external indexing augments an
+        // existing resource. An indexed prefix admits only newly added names.
+        let mut available: HashMap<JsonKey, Vec<Value>, BuildHasherDefault<BucketHasher>> =
+            HashMap::default();
+        let mut resolved_names = 0;
+        let mut indexed = HashMap::new();
+        loop {
+            let mut pending = vec![];
+            for &resource in self.resources.keys() {
+                let first = indexed.get(&resource).copied().unwrap_or(0);
+                if unsafe { sn_anchor_count(resource) } == first {
+                    continue;
+                }
+                let mut names = 0;
+                if unsafe { sn_anchor_names(self.compiler, resource, &mut names) } != 0 {
+                    return Err(names);
+                }
+                // Copy handles before any Ruby callback. The snapshot Array
+                // is never borrowed across allocation, and temporary roots
+                // pin its names while the reverse index remains live.
+                let count = unsafe { sn_len(names) };
+                for i in first..count {
+                    let name = unsafe { sn_entry(names, i) };
+                    unsafe { &mut *self.roots }.binding_names.push(name);
+                    let name = JsonKey::new(name);
+                    available.entry(name).or_default().push(resource);
+                    if let Some(&id) = self.anchor_ids.get(&name)
+                        && id < resolved_names
+                    {
+                        pending.push((resource, id));
                     }
                 }
+                indexed.insert(resource, count);
+            }
+            let names = self.anchor_names.len();
+            for id in resolved_names..names {
+                if let Some(resources) = available.get(&self.anchor_names[id]) {
+                    pending.extend(resources.iter().map(|&resource| (resource, id)));
+                }
+            }
+            resolved_names = names;
+            if pending.is_empty() {
+                self.finish_dynamic_bindings();
                 return Ok(());
             }
             for (resource, name) in pending {
+                // Switching from single-name discovery can revisit a positive
+                // pair already compiled. It must not invoke compilation twice.
+                if self.dynamic_bindings.contains_key(&(resource, name)) {
+                    continue;
+                }
                 let mut target = 0;
                 if unsafe {
                     sn_anchor_program(
@@ -146,13 +359,11 @@ impl Engine {
                 {
                     return Err(target);
                 }
-                self.retain(target);
-                let target = if unsafe { sn_same(target, sn_nil()) } != 0 {
-                    None
-                } else {
-                    Some(self.compile(target)?)
-                };
-                self.dynamic_bindings.insert((resource, name), target);
+                if unsafe { sn_same(target, sn_nil()) } == 0 {
+                    self.retain(target);
+                    let target = self.compile(target)?;
+                    self.dynamic_bindings.insert((resource, name), target);
+                }
             }
         }
     }
@@ -197,8 +408,7 @@ impl Engine {
                     }
                 }
                 ReferenceKind::Dynamic(name) => {
-                    if let Some(Some(binding)) = self.dynamic_bindings.get(&(frame.resource, name))
-                    {
+                    if let Some(binding) = self.dynamic_bindings.get(&(frame.resource, name)) {
                         target = *binding;
                     }
                 }

data/ext/schemurai_native/src/structural.rs

@@ -0,0 +1,86 @@
+//! One comparison/hash owns its cache. Ruby values cannot mutate or move
+//! during these GVL-held traversals, which never call back into Ruby.
+use std::collections::{HashMap, VecDeque};
+use std::hash::Hash;
+
+const MAX_ENTRIES: usize = 4096;
+
+pub(super) struct Cache<K, T> {
+    start_depth: usize,
+    shallow_width: usize,
+    results: HashMap<K, T>,
+    order: VecDeque<K>,
+}
+impl<K, T> Cache<K, T> {
+    // A batch can share wide containers below distinct element roots. Keep
+    // small shallow trees cheap; four expanded levels are still a constant
+    // bound before depth-based reuse handles thin shared graphs.
+    pub(super) fn batch(depth: usize) -> Self {
+        let mut cache = Self::new(depth);
+        cache.shallow_width = 16;
+        cache
+    }
+    pub(super) fn new(depth: usize) -> Self {
+        Self {
+            start_depth: depth.saturating_add(4),
+            shallow_width: usize::MAX,
+            results: HashMap::new(),
+            order: VecDeque::new(),
+        }
+    }
+    // Shallow ordinary records/trees avoid table bookkeeping. At most four
+    // levels are expanded before reuse begins, independently of graph depth.
+    pub(super) fn eligible(&self, depth: usize) -> bool {
+        depth >= self.start_depth
+    }
+    pub(super) fn eligible_container(&self, depth: usize, width: usize) -> bool {
+        self.eligible(depth) || width >= self.shallow_width
+    }
+}
+impl<K: Copy + Eq + Hash, T: Copy> Cache<K, T> {
+    pub(super) fn get(&self, key: K) -> Option<T> {
+        self.results.get(&key).copied()
+    }
+    pub(super) fn record(&mut self, key: K, result: T) {
+        if self.results.contains_key(&key) {
+            return;
+        }
+        if self.results.len() == MAX_ENTRIES {
+            self.results.remove(&self.order.pop_front().unwrap());
+        }
+        self.results.insert(key, result);
+        self.order.push_back(key);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn batches_admit_wide_containers_without_charging_small_shallow_trees() {
+        let cache = Cache::<usize, usize>::batch(7);
+        assert!(!cache.eligible_container(7, 2));
+        assert!(!cache.eligible_container(10, 15));
+        assert!(cache.eligible_container(8, 16));
+        assert!(cache.eligible_container(11, 0));
+        assert!(!Cache::<usize, usize>::new(7).eligible_container(8, 1024));
+    }
+
+    #[test]
+    fn separates_depth_and_admits_later_shared_values() {
+        let mut cache = Cache::new(0);
+        for value in 0..MAX_ENTRIES * 3 {
+            cache.record((value, 0), Some(value));
+            cache.record((value, 0), None);
+        }
+        assert_eq!(cache.results.len(), MAX_ENTRIES);
+        assert_eq!(cache.order.len(), MAX_ENTRIES);
+        assert_eq!(cache.get((0, 0)), None);
+        assert_eq!(
+            cache.get((MAX_ENTRIES * 3 - 1, 0)),
+            Some(Some(MAX_ENTRIES * 3 - 1))
+        );
+        assert_eq!(cache.get((MAX_ENTRIES * 3 - 1, 1)), None);
+    }
+}