schemurai 3.0.0 → 3.0.2

data/ext/schemurai_native/src/runtime/reports.rs

@@ -0,0 +1,266 @@
+//! Owned diagnostic seeds and results. No native frame is retained across Ruby.
+use super::*;
+use crate::diagnostics::Report;
+use std::cell::RefCell;
+
+#[derive(Default)]
+pub(super) struct Reports {
+    initial: RefCell<Option<Report>>,
+    callback: RefCell<Option<Report>>,
+    pending: RefCell<Option<(Value, Report)>>,
+    completed: RefCell<HashMap<Value, Report>>,
+    live: RefCell<Option<Report>>,
+    boundary: RefCell<Option<Report>>,
+    runtime_key: std::cell::Cell<Option<scopes::Key>>,
+    effects: RefCell<HashMap<scopes::Key, Report>>,
+    replay: RefCell<Vec<Report>>,
+}
+impl Reports {
+    pub(super) fn clear(&self) {
+        self.boundary.borrow_mut().take();
+        self.live.borrow_mut().take();
+        self.runtime_key.set(None);
+        self.effects.borrow_mut().clear();
+        self.replay.borrow_mut().clear();
+        self.initial.borrow_mut().take();
+        self.callback.borrow_mut().take();
+        self.pending.borrow_mut().take();
+        *self.completed.borrow_mut() = HashMap::new();
+    }
+    pub(super) fn capture(&self, report: &Report) {
+        *self.boundary.borrow_mut() = Some(report.clone());
+        if self.live.borrow().is_none() {
+            *self.live.borrow_mut() = Some(report.clone());
+        }
+    }
+    pub(super) fn request_runtime(&self, key: scopes::Key) {
+        self.runtime_key.set(Some(key));
+    }
+    pub(super) fn apply_runtime(&self, key: scopes::Key) {
+        if let Some(effect) = self.effects.borrow().get(&key) {
+            self.replay.borrow_mut().push(effect.clone());
+        }
+    }
+    pub(super) fn apply(&self, report: &mut Report) {
+        for effect in self.replay.borrow_mut().drain(..) {
+            report.apply_effect(effect);
+        }
+    }
+    pub(super) fn reset(&self) {
+        *self.callback.borrow_mut() = self.initial.borrow().clone();
+        self.boundary.borrow_mut().take();
+        self.live.borrow_mut().take();
+        self.runtime_key.set(None);
+        self.replay.borrow_mut().clear();
+        self.pending.borrow_mut().take();
+    }
+    pub(super) fn initial(&self) -> Option<Report> {
+        self.initial.borrow().clone()
+    }
+    pub(super) fn request(&self, key: Value, report: Report) {
+        *self.pending.borrow_mut() = Some((key, report));
+    }
+    pub(super) fn result(&self, key: Value) -> Option<Report> {
+        self.completed.borrow().get(&key).cloned()
+    }
+    pub(super) fn memory_usage(&self) -> usize {
+        [&self.live, &self.boundary, &self.initial, &self.callback]
+            .iter()
+            .map(|cell| {
+                cell.try_borrow()
+                    .map_or(0, |r| r.as_ref().map_or(0, Report::memory_usage))
+            })
+            .sum::<usize>()
+            + self.effects.try_borrow().map_or(0, |effects| {
+                effects.values().map(Report::memory_usage).sum::<usize>()
+            })
+            + self.replay.try_borrow().map_or(0, |effects| {
+                effects.iter().map(Report::memory_usage).sum::<usize>()
+            })
+            + self
+                .pending
+                .try_borrow()
+                .map_or(0, |r| r.as_ref().map_or(0, |(_, r)| r.memory_usage()))
+            + self.completed.try_borrow().map_or(0, |r| {
+                r.capacity() * std::mem::size_of::<(Value, Report)>()
+                    + r.values().map(Report::memory_usage).sum::<usize>()
+            })
+    }
+    pub(super) fn mark(&self) {
+        // C additionally roots every completed report and inherited seed.
+        // Pending snapshots use input/schema handles and runtime observations
+        // already owned by the runner while a stopped pass borrows this state.
+        if let Ok(boundary) = self.boundary.try_borrow()
+            && let Some(report) = &*boundary
+        {
+            report.mark();
+        }
+        if let Ok(callback) = self.callback.try_borrow()
+            && let Some(report) = &*callback
+        {
+            report.mark();
+        }
+        if let Ok(live) = self.live.try_borrow()
+            && let Some(report) = &*live
+        {
+            report.mark();
+        }
+        if let Ok(effects) = self.effects.try_borrow() {
+            for report in effects.values() {
+                report.mark();
+            }
+        }
+        if let Ok(replay) = self.replay.try_borrow() {
+            for report in replay.iter() {
+                report.mark();
+            }
+        }
+        if let Ok(initial) = self.initial.try_borrow()
+            && let Some(report) = &*initial
+        {
+            report.mark();
+        }
+        if let Ok(pending) = self.pending.try_borrow()
+            && let Some((_, report)) = &*pending
+        {
+            report.mark();
+        }
+        if let Ok(completed) = self.completed.try_borrow() {
+            for report in completed.values() {
+                report.mark();
+            }
+        }
+    }
+}
+/// # Safety
+/// Caches must be idle and own a pending native report request. The returned
+/// report is owned by C TypedData and freed exactly once with sn_report_free.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_report_seed(caches: *const Caches) -> *mut Report {
+    Box::into_raw(Box::new(
+        unsafe { &*caches }
+            .reports
+            .pending
+            .borrow()
+            .as_ref()
+            .expect("pending native report")
+            .1
+            .clone(),
+    ))
+}
+/// # Safety
+/// Caches must be idle and report live and C-rooted through the invocation.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_report_inherit(caches: *const Caches, report: *const Report) {
+    let reports = &unsafe { &*caches }.reports;
+    *reports.initial.borrow_mut() = Some(unsafe { &*report }.clone());
+    *reports.callback.borrow_mut() = Some(unsafe { &*report }.clone());
+}
+/// # Safety
+/// Caches must be idle with a pending report request; report must be live,
+/// complete, and retained by the runner's completed-report roots before calling.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_report_accept(caches: *const Caches, report: *const Report) {
+    let reports = &unsafe { &*caches }.reports;
+    let key = reports
+        .pending
+        .borrow()
+        .as_ref()
+        .expect("pending native report")
+        .0;
+    reports
+        .completed
+        .borrow_mut()
+        .insert(key, unsafe { &*report }.clone());
+}
+
+/// # Safety
+/// Caches must be idle. A non-null result is an owned report rooted/freed by C.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_report_live(caches: *const Caches) -> *mut Report {
+    unsafe { &*caches }
+        .reports
+        .live
+        .borrow()
+        .as_ref()
+        .map_or(std::ptr::null_mut(), |report| {
+            Box::into_raw(Box::new(report.clone()))
+        })
+}
+/// # Safety
+/// Caches and completed report must be idle, live and C-rooted.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_report_effect(caches: *const Caches, completed: *const Report) {
+    let reports = &unsafe { &*caches }.reports;
+    if let Some(key) = reports.runtime_key.get()
+        && let Some(before) = &*reports.live.borrow()
+        && let Some(effect) = unsafe { &*completed }.effect_since(before)
+    {
+        reports.effects.borrow_mut().insert(key, effect);
+    }
+}
+
+impl Caches {
+    pub(crate) fn callback_tracked(&self, node: usize, value: Value) -> Option<Verdict> {
+        let mut report = self.reports.callback.borrow().clone()?;
+        self.reports.apply(&mut report);
+        let result = self
+            .report_child(node, value, &mut report, true)
+            .map_or_else(|verdict| verdict, |evaluation| evaluation.status);
+        self.reports.apply(&mut report);
+        if result == Unsupported {
+            self.reports.capture(&report);
+        }
+        *self.reports.callback.borrow_mut() = Some(report);
+        Some(result)
+    }
+    pub(crate) fn finish_callback_report(&self, verdict: Verdict) {
+        if let Some(report) = &mut *self.reports.callback.borrow_mut() {
+            self.reports.apply(report);
+            if verdict == Unsupported {
+                self.reports.capture(report);
+            }
+        }
+    }
+}
+/// # Safety
+/// Caches must be idle after a successful seeded validity call. C owns the result.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_callback_report_result(
+    caches: *const Caches,
+    valid: i32,
+) -> *mut Report {
+    let mut report = unsafe { &*caches }
+        .reports
+        .callback
+        .borrow()
+        .clone()
+        .expect("callback report");
+    report.complete_callback(valid != 0);
+    Box::into_raw(Box::new(report))
+}
+
+/// # Safety
+/// Caches are idle while C unwinds an interrupted runner. C owns a non-null result.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_report_interrupted(caches: *const Caches) -> *mut Report {
+    let reports = &unsafe { &*caches }.reports;
+    let mut report = reports
+        .boundary
+        .borrow()
+        .clone()
+        .or_else(|| reports.callback.borrow().clone());
+    if let Some(report) = &mut report {
+        if let Some(key) = reports.runtime_key.get()
+            && let Some(live) = &*reports.live.borrow()
+            && report.same_collection_policy(live)
+            && let Some(effect) = reports.effects.borrow().get(&key)
+        {
+            report.apply_effect(effect.clone());
+        }
+        report.complete_callback(false);
+    }
+    report.map_or(std::ptr::null_mut(), |report| {
+        Box::into_raw(Box::new(report))
+    })
+}

data/ext/schemurai_native/src/runtime/scopes.rs

@@ -0,0 +1,430 @@
+//! Invocation scope snapshots and scope effects of completed Ruby requests.
+use super::*;
+use std::cell::{Cell, RefCell};
+
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+pub(super) enum Key {
+    Value(Value, Value, i32),
+    Message(Message),
+    Pointer(usize),
+    Rescue(StringError),
+}
+#[derive(Default)]
+pub(super) struct Scopes {
+    enabled: Cell<bool>,
+    initial_references: RefCell<Vec<(Value, Value)>>,
+    vm_references: RefCell<Vec<(Value, Value)>>,
+    pending_references: RefCell<Vec<(Value, Value)>>,
+    reference: Cell<*const Reference>,
+    initial: RefCell<Vec<Value>>,
+    stack: RefCell<Vec<Value>>,
+    pending: RefCell<Vec<Value>>,
+    key: Cell<Option<Key>>,
+    effects: RefCell<HashMap<Key, Vec<Value>>>,
+    entered: Cell<usize>,
+    unwind: Cell<usize>,
+}
+pub(crate) struct Guard<'a> {
+    scopes: &'a Scopes,
+    entered: bool,
+}
+// Stack records are read only while their guards are live. No pointer survives
+// native unwinding: requests copy the pairs before returning to C/Ruby.
+pub(crate) struct Reference {
+    pair: (Value, Value),
+    parent: *const Reference,
+}
+pub(crate) struct ReferenceGuard<'a> {
+    scopes: &'a Scopes,
+    frame: &'a Reference,
+}
+impl Drop for ReferenceGuard<'_> {
+    fn drop(&mut self) {
+        self.scopes.reference.set(self.frame.parent);
+    }
+}
+impl Drop for Guard<'_> {
+    fn drop(&mut self) {
+        if self.entered {
+            self.scopes.stack.borrow_mut().pop();
+            self.scopes.entered.set(self.scopes.entered.get() - 1);
+        }
+    }
+}
+impl Scopes {
+    pub(super) fn enabled(&self) -> bool {
+        self.enabled.get()
+    }
+    pub(super) fn clear(&self) {
+        self.enabled.set(false);
+        self.initial_references.borrow_mut().clear();
+        self.vm_references.borrow_mut().clear();
+        self.pending_references.borrow_mut().clear();
+        self.reference.set(std::ptr::null());
+        self.initial.borrow_mut().clear();
+        self.stack.borrow_mut().clear();
+        self.pending.borrow_mut().clear();
+        *self.effects.borrow_mut() = HashMap::new();
+        self.key.set(None);
+        self.entered.set(0);
+        self.unwind.set(0);
+    }
+    pub(super) fn inherit(&self, values: Vec<Value>, enabled: bool) {
+        self.enabled.set(enabled);
+        *self.initial.borrow_mut() = values;
+        self.reset();
+    }
+    pub(super) fn reset(&self) {
+        if self.enabled() {
+            self.stack.borrow_mut().clone_from(&self.initial.borrow());
+        }
+        self.reference.set(std::ptr::null());
+        self.pending_references.borrow_mut().clear();
+        self.key.set(None);
+        self.unwind.set(0);
+        self.entered.set(0);
+    }
+    pub(super) fn enter(&self, resource: Value, enters: bool) -> Guard<'_> {
+        let entered = self.enabled() && enters && self.stack.borrow().last() != Some(&resource);
+        if entered {
+            self.stack.borrow_mut().push(resource);
+            self.entered.set(self.entered.get() + 1);
+        }
+        Guard {
+            scopes: self,
+            entered,
+        }
+    }
+    pub(super) fn at(&self, index: usize) -> Option<Value> {
+        self.stack.borrow().get(index).copied()
+    }
+    pub(super) fn reference_frame(&self, program: Value, instance: Value) -> Reference {
+        Reference {
+            pair: (program, instance),
+            parent: self.reference.get(),
+        }
+    }
+    pub(super) fn reference_guard<'a>(&'a self, frame: &'a Reference) -> ReferenceGuard<'a> {
+        if self.enabled() {
+            self.reference.set(frame);
+        }
+        ReferenceGuard {
+            scopes: self,
+            frame,
+        }
+    }
+    pub(super) fn reference_active(&self, program: Value, instance: Value) -> bool {
+        self.enabled()
+            && (self
+                .initial_references
+                .borrow()
+                .contains(&(program, instance))
+                || self.vm_references.borrow().contains(&(program, instance)))
+    }
+    fn references(&self, initial: bool) -> std::cell::Ref<'_, Vec<(Value, Value)>> {
+        if !initial && self.key.get().is_some() {
+            self.pending_references.borrow()
+        } else {
+            self.initial_references.borrow()
+        }
+    }
+    pub(super) fn request(&self, key: Key) {
+        if self.enabled() {
+            self.pending.borrow_mut().clone_from(&self.stack.borrow());
+            let mut pairs = self.pending_references.borrow_mut();
+            pairs.clone_from(&self.initial_references.borrow());
+            let mut reference = self.reference.get();
+            while !reference.is_null() {
+                // Each pointer belongs to a stack record borrowed by a live guard.
+                let frame = unsafe { &*reference };
+                pairs.push(frame.pair);
+                reference = frame.parent;
+            }
+            self.key.set(Some(key));
+            self.unwind.set(self.entered.get());
+        }
+    }
+    pub(super) fn apply(&self, key: Key) {
+        if self.enabled()
+            && let Some(values) = self.effects.borrow().get(&key)
+        {
+            self.stack.borrow_mut().clone_from(values);
+        }
+    }
+    pub(super) fn accept(&self, values: Vec<Value>) {
+        if let Some(key) = self.key.get() {
+            if *self.pending.borrow() == values {
+                self.effects.borrow_mut().remove(&key);
+            } else {
+                self.effects.borrow_mut().insert(key, values);
+            }
+        }
+    }
+    pub(super) fn rescue(&self, error: StringError) {
+        if let Some(key) = self.key.get() {
+            let values = self.effects.borrow().get(&key).cloned();
+            if let Some(values) = values {
+                self.effects.borrow_mut().insert(Key::Rescue(error), values);
+            }
+        }
+    }
+    pub(super) fn len(&self) -> usize {
+        if self.key.get().is_some() {
+            self.pending.borrow().len()
+        } else {
+            self.stack.borrow().len()
+        }
+    }
+    pub(super) fn value(&self, index: usize) -> Value {
+        if self.key.get().is_some() {
+            self.pending.borrow()[index]
+        } else {
+            self.stack.borrow()[index]
+        }
+    }
+    pub(super) fn unwind(&self) -> usize {
+        self.unwind.replace(0)
+    }
+    pub(super) fn size(&self) -> usize {
+        let vectors = [&self.initial, &self.stack, &self.pending]
+            .iter()
+            .map(|v| {
+                v.try_borrow()
+                    .map_or(0, |v| v.capacity() * std::mem::size_of::<Value>())
+            })
+            .sum::<usize>();
+        let references = [
+            &self.initial_references,
+            &self.vm_references,
+            &self.pending_references,
+        ]
+        .iter()
+        .map(|v| {
+            v.try_borrow()
+                .map_or(0, |v| v.capacity() * std::mem::size_of::<(Value, Value)>())
+        })
+        .sum::<usize>();
+        vectors
+            + references
+            + self.effects.try_borrow().map_or(0, |effects| {
+                effects.capacity() * std::mem::size_of::<(Key, Vec<Value>)>()
+                    + effects
+                        .values()
+                        .map(|v| v.capacity() * std::mem::size_of::<Value>())
+                        .sum::<usize>()
+            })
+    }
+    pub(super) fn mark(&self) {
+        // A stopped native pass may hold a scope-vector borrow. Resources also
+        // belong to the compiled registry; C roots completed request keys.
+        for values in [&self.initial, &self.stack, &self.pending] {
+            if let Ok(values) = values.try_borrow() {
+                for &value in values.iter() {
+                    unsafe { sn_pin(value) };
+                }
+            }
+        }
+        for pairs in [
+            &self.initial_references,
+            &self.vm_references,
+            &self.pending_references,
+        ] {
+            if let Ok(pairs) = pairs.try_borrow() {
+                for &(program, instance) in pairs.iter() {
+                    unsafe {
+                        sn_pin(program);
+                        sn_pin(instance);
+                    }
+                }
+            }
+        }
+        if let Ok(effects) = self.effects.try_borrow() {
+            for (key, values) in effects.iter() {
+                match *key {
+                    Key::Value(source, value, _) => unsafe {
+                        sn_pin(source);
+                        sn_pin(value);
+                    },
+                    Key::Message(m) => unsafe {
+                        sn_pin(m.operand);
+                        sn_pin(m.instance);
+                        sn_pin(m.frame);
+                    },
+                    Key::Rescue((frame, _, _)) => unsafe {
+                        sn_pin(frame);
+                    },
+                    Key::Pointer(_) => {}
+                }
+                for &value in values {
+                    unsafe { sn_pin(value) };
+                }
+            }
+        }
+    }
+}
+fn values(array: Value) -> Vec<Value> {
+    (0..unsafe { sn_len(array) })
+        .map(|i| unsafe { sn_entry(array, i) })
+        .collect()
+}
+/// # Safety
+/// Caches must be idle. Arrays must be live and runner-rooted; active must be
+/// nil or the library-owned program/instance identity Hashes.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_scopes_inherit(
+    caches: *const Caches,
+    array: Value,
+    references: Value,
+    active: Value,
+    enabled: i32,
+) {
+    unsafe { &*caches }.scopes.inherit(
+        if enabled != 0 { values(array) } else { vec![] },
+        enabled != 0,
+    );
+    if enabled != 0 {
+        let scopes = &unsafe { &*caches }.scopes;
+        *scopes.initial_references.borrow_mut() = (0..unsafe { sn_len(references) } / 2)
+            .map(|i| unsafe { (sn_entry(references, i * 2), sn_entry(references, i * 2 + 1)) })
+            .collect();
+        let mut pairs = scopes.vm_references.borrow_mut();
+        unsafe {
+            sn_references_read(active, (&mut *pairs as *mut Vec<(Value, Value)>).cast());
+        }
+    }
+}
+unsafe extern "C" {
+    fn sn_references_read(active: Value, pairs: *mut c_void);
+}
+/// # Safety
+/// Pairs must be an exclusively borrowed reference vector; called by C's
+/// allocation-free walk of library-owned identity Hashes.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_reference_pair(pairs: *mut c_void, program: Value, instance: Value) {
+    unsafe { &mut *pairs.cast::<Vec<(Value, Value)>>() }.push((program, instance));
+}
+/// # Safety
+/// Caches must be idle and live.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_references_len(caches: *const Caches, initial: i32) -> usize {
+    unsafe { &*caches }.scopes.references(initial != 0).len() * 2
+}
+/// # Safety
+/// Caches must be idle and index in range of sn_references_len.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_references_at(
+    caches: *const Caches,
+    index: usize,
+    initial: i32,
+) -> Value {
+    let pairs = unsafe { &*caches }.scopes.references(initial != 0);
+    let pair = pairs[index / 2];
+    if index.is_multiple_of(2) {
+        pair.0
+    } else {
+        pair.1
+    }
+}
+/// # Safety
+/// Caches must be idle and live.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_scopes_enabled(caches: *const Caches) -> i32 {
+    i32::from(unsafe { &*caches }.scopes.enabled())
+}
+/// # Safety
+/// Caches must be idle and live.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_scopes_len(caches: *const Caches) -> usize {
+    unsafe { &*caches }.scopes.len()
+}
+/// # Safety
+/// Caches must be idle and index in range of sn_scopes_len.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_scopes_at(caches: *const Caches, index: usize) -> Value {
+    unsafe { &*caches }.scopes.value(index)
+}
+/// # Safety
+/// Caches must be idle and array must retain the current Ruby scope contents.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_scopes_accept(caches: *const Caches, array: Value) {
+    if unsafe { &*caches }.scopes.enabled() {
+        unsafe { &*caches }.scopes.accept(values(array));
+    }
+}
+/// # Safety
+/// Caches must be idle and live. Consume only during the runner ensure.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_scopes_unwind(caches: *const Caches) -> usize {
+    unsafe { &*caches }.scopes.unwind()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn pending_scopes_survive_native_unwind_and_replay_ruby_clears() {
+        let scopes = Scopes::default();
+        let key = Key::Value(2, 3, RUNTIME_TYPE);
+        scopes.inherit(vec![10], true);
+        {
+            let _outer = scopes.enter(20, true);
+            let _same = scopes.enter(20, true);
+            scopes.request(key);
+            assert_eq!(scopes.unwind(), 1);
+            assert_eq!(scopes.len(), 2);
+        }
+        assert_eq!(scopes.at(0), Some(10));
+        assert_eq!(scopes.value(1), 20);
+        scopes.accept(vec![]);
+        scopes.reset();
+        {
+            let _outer = scopes.enter(20, true);
+            scopes.apply(key);
+            assert_eq!(scopes.at(0), None);
+        }
+        assert_eq!(scopes.at(0), None);
+    }
+
+    #[test]
+    fn reference_requests_copy_live_guards_and_keep_vm_ancestors_separate() {
+        let scopes = Scopes::default();
+        scopes.inherit(vec![], true);
+        scopes.initial_references.borrow_mut().push((10, 11));
+        scopes.vm_references.borrow_mut().push((20, 21));
+        assert!(scopes.reference_active(10, 11));
+        assert!(scopes.reference_active(20, 21));
+        assert!(!scopes.reference_active(10, 21));
+        {
+            let outer = scopes.reference_frame(30, 31);
+            let _outer = scopes.reference_guard(&outer);
+            {
+                let inner = scopes.reference_frame(40, 41);
+                let _inner = scopes.reference_guard(&inner);
+                scopes.request(Key::Value(2, 3, RUNTIME_TYPE));
+            }
+            assert_eq!(
+                *scopes.references(false),
+                vec![(10, 11), (40, 41), (30, 31)]
+            );
+        }
+        assert!(scopes.reference.get().is_null());
+        assert_eq!(*scopes.references(true), vec![(10, 11)]);
+        scopes.reset();
+        assert_eq!(*scopes.references(false), vec![(10, 11)]);
+        scopes.clear();
+        assert!(!scopes.reference_active(20, 21));
+    }
+
+    #[test]
+    fn unchanged_requests_do_not_restore_a_later_mutated_scope() {
+        let scopes = Scopes::default();
+        let key = Key::Value(2, 3, RUNTIME_TYPE);
+        scopes.inherit(vec![10], true);
+        scopes.request(key);
+        scopes.accept(vec![10]);
+        let _inner = scopes.enter(20, true);
+        scopes.apply(key);
+        assert_eq!(scopes.at(1), Some(20));
+    }
+}