Refine new_frame API and add CI test.

Author: schungx

src/eval/eval_context.rs

@@ -134,6 +134,17 @@ impl<'a, 's, 'ps, 'g, 'c, 't> EvalContext<'a, 's, 'ps, 'g, 'c, 't> {
     pub fn namespaces(&self) -> &[crate::SharedModule] {
         &self.global.lib
     }
+    /// _(internals)_ Mutable reference to the current set of namespaces containing definitions of all script-defined functions.
+    /// Exported under the `internals` feature only.
+    ///
+    /// Not available under `no_function`.
+    #[cfg(not(feature = "no_function"))]
+    #[cfg(feature = "internals")]
+    #[inline(always)]
+    #[must_use]
+    pub fn namespaces_mut(&mut self) -> &mut [crate::SharedModule] {
+        self.global.lib.as_mut()
+    }
     /// The current bound `this` pointer, if any.
     #[inline(always)]
     #[must_use]
@@ -417,7 +428,7 @@ impl<'a, 's, 'ps, 'g, 'c, 't> EvalContext<'a, 's, 'ps, 'g, 'c, 't> {
     ///     let context = context.new_frame()
     ///                          .rewind_scope(true)            // rewinds the scope...
     ///                          .with_source("new source")     // new source...
-    ///                          .with_module(new_module)       // add new module...
+    ///                          .with_namespace(new_module)    // add new namespace module...
     ///                          .up_call_level();
     ///
     ///     // Call a function with the modified context...
@@ -431,8 +442,8 @@ impl<'a, 's, 'ps, 'g, 'c, 't> EvalContext<'a, 's, 'ps, 'g, 'c, 't> {
     ///
     /// Upon `Drop`, the following fields will be automatically restored to the previous values:
     ///
-    /// * the stack of imported [modules][crate::Module] will be rewound to the original depth if more [modules][crate::Module] have been added via [`EvalContextFrameGuard::with_import`].
-    /// * the stack of global [modules][crate::Module] will be rewound to the original depth if more [modules][crate::Module] have been added via [`EvalContextFrameGuard::with_module`].
+    /// * the stack of imported [modules][crate::Module] will be rewound to the original depth if more have been added via [`EvalContextFrameGuard::with_import`].
+    /// * the stack of scripted function [modules][crate::Module] will be rewound to the original depth if more have been added via [`EvalContextFrameGuard::with_namespace`].
     /// * the original functions resolution cache will be restored if a new caching layer was created via [`EvalContextFrameGuard::with_new_caching_layer`].
     /// * the original [scope][EvalContext::scope] will be rewound if [`EvalContextFrameGuard::rewind_scope`] was set to `true`.
     /// * the [source][GlobalRuntimeState::source] will be restored if a new source was set via [`EvalContextFrameGuard::with_source`] or cleared via [`EvalContextFrameGuard::clear_source`].
@@ -658,7 +669,7 @@ impl<'t> EvalContextFrameGuard<'_, '_, '_, '_, '_, '_, 't> {
     #[cfg(not(feature = "no_function"))]
     #[inline(always)]
     #[must_use]
-    pub fn with_module(mut self, module: impl Into<crate::SharedModule>) -> Self {
+    pub fn with_namespace(mut self, module: impl Into<crate::SharedModule>) -> Self {
         self.lib_len = Some(self.context.global.lib.len());
         self.context.global.lib.push(module.into());
         self

src/eval/global_state.rs

@@ -152,7 +152,6 @@ impl GlobalRuntimeState {
         module: impl Into<crate::SharedModule>,
     ) {
         self.imports.push(name.into());
-
         self.modules.push(module.into());
     }
     /// Truncate the stack of globally-imported [modules][crate::Module] to a particular length.
@@ -164,7 +163,8 @@ impl GlobalRuntimeState {
         self.imports.truncate(size);
         self.modules.truncate(size);
     }
-    /// Get an iterator to the stack of globally-imported [modules][crate::Module] in reverse order.
+    /// Get an iterator to the stack of globally-imported [modules][crate::Module] in reverse order
+    /// (i.e. modules imported last come first).
     ///
     /// Not available under `no_module`.
     #[cfg(not(feature = "no_module"))]
@@ -176,7 +176,8 @@ impl GlobalRuntimeState {
             .zip(self.modules.iter().rev())
             .map(|(name, module)| (name.as_str(), &**module))
     }
-    /// Get an iterator to the stack of globally-imported [modules][crate::Module] in reverse order.
+    /// Get an iterator to the stack of globally-imported [modules][crate::Module] in reverse order
+    /// (i.e. modules imported last come first).
     ///
     /// Not available under `no_module`.
     #[cfg(not(feature = "no_module"))]

src/func/native.rs

@@ -256,17 +256,16 @@ impl<'a> NativeCallContext<'a> {
     pub const fn tag(&self) -> Option<&Dynamic> {
         Some(&self.global.tag)
     }
-    /// Get an iterator over the current set of modules imported via `import` statements
-    /// in reverse order.
+    /// Get an iterator over the current set of modules imported via `import` statements in reverse order
+    /// (i.e. modules imported last come first).
     ///
     /// Not available under `no_module`.
     #[cfg(not(feature = "no_module"))]
     #[inline]
     pub fn iter_imports(&self) -> impl Iterator<Item = (&str, &crate::Module)> {
         self.global.iter_imports()
     }
-    /// Get an iterator over the namespaces containing definitions of all script-defined functions
-    /// in reverse order (i.e. parent namespaces are iterated after child namespaces).
+    /// Get an iterator over the namespaces containing definitions of all script-defined functions.
     ///
     /// Not available under `no_function`.
     #[cfg(not(feature = "no_function"))]

src/func/script.rs

@@ -227,22 +227,22 @@ impl Engine {
         }
 
         // First check script-defined functions
-        let res = global.lib.iter().any(|m| m.contains_fn(hash_script))
+        let result = global.lib.iter().any(|m| m.contains_fn(hash_script))
             // Then check the global namespace and packages
             || self.global_modules.iter().any(|m| m.contains_fn(hash_script));
 
         #[cfg(not(feature = "no_module"))]
-        let res = res ||
+        let result = result ||
             // Then check imported modules
             global.contains_qualified_fn(hash_script)
             // Then check sub-modules
             || self.global_sub_modules.values().any(|m| m.contains_qualified_fn(hash_script));
 
-        if !res && !cache.bloom_filter.is_absent_and_set(hash_script) {
+        if !result && !cache.bloom_filter.is_absent_and_set(hash_script) {
             // Do not cache "one-hit wonders"
             cache.dict.insert(hash_script, None);
         }
 
-        res
+        result
     }
 }

tests/functions.rs

@@ -726,3 +726,72 @@ fn test_missing_function_is_method_call_flag() {
     let _: String = engine.eval(r#"let x = 42; x.greet()"#).unwrap();
     assert!(saw_method.load(Ordering::SeqCst), "method-style call should set is_method_call=true");
 }
+
+#[test]
+#[cfg(feature = "internals")]
+#[cfg(not(feature = "no_index"))]
+#[cfg(not(feature = "no_object"))]
+fn on_missing_function_isolates_nested_cache_frame() {
+    use std::sync::atomic::{AtomicUsize, Ordering};
+
+    // Two modules, each registering `step(target, n) -> INT` under the same
+    // name and argument types. Same `(name, arg_types)` produces the same
+    // fn-resolution cache hash.
+    let mut module_a = Module::new();
+    module_a.set_native_fn("step", |_target: &mut INT, n: INT| Ok(n * 2));
+    let module_a = Shared::new(module_a);
+
+    let mut module_b = Module::new();
+    module_b.set_native_fn("step", |_target: &mut INT, n: INT| Ok(n * 10));
+    let module_b = Shared::new(module_b);
+
+    // Counter picks module_a for invocations 0-1, module_b for invocation 2+.
+    // Three invocations are needed to exercise the cache lifecycle: call 1
+    // sets the bloom filter bit (no dict entry yet), call 2 populates the
+    // dict against module_a, call 3 (with module_b pushed) must hit a FRESH
+    // resolution in its isolated frame — if isolation is missing it would
+    // hit the stale dict entry from call 2 and return module_a's result.
+    let call_idx = Shared::new(AtomicUsize::new(0));
+
+    let a = module_a.clone();
+    let b = module_b.clone();
+    let call_idx_clone = call_idx.clone();
+
+    let mut engine = Engine::new();
+
+    #[allow(deprecated)]
+    engine.on_missing_function(move |name, args, _is_method_call, mut ctx| {
+        if name != "step" {
+            return Ok(None);
+        }
+
+        let idx = call_idx_clone.fetch_add(1, Ordering::SeqCst);
+        let module = if idx < 2 { a.clone() } else { b.clone() };
+
+        // Isolate the nested dispatch in a fresh cache frame. Without this,
+        // invocation 2 would cache the resolution against module_a, and
+        // invocation 3 would hit that stale cache entry after module_b had
+        // been pushed.
+        ctx.new_frame().with_new_caching_layer().with_namespace(module).call_fn_raw(name, true, false, args).map(Some)
+    });
+
+    // Three method-style calls with identical name and argument types so
+    // they all hash to the same fn-resolution cache key.
+    let script = r#"
+        let x = 0;
+        [x.step(3), x.step(3), x.step(3)]
+    "#;
+
+    let results: rhai::Array = engine.eval(script).expect("eval must succeed");
+    let results: Vec<INT> = results.into_iter().map(|v| v.as_int().expect("array element must be INT")).collect();
+
+    assert_eq!(
+        results,
+        vec![6, 6, 30],
+        "third invocation must dispatch to module_b (3*10=30), not a stale \
+         cached entry from module_a (3*2=6); without push/rewind_fn_resolution_cache \
+         the third element would be 6."
+    );
+
+    assert_eq!(call_idx.load(Ordering::SeqCst), 3, "on_missing_function must fire exactly three times");
+}