Add more fields to API

Author: schungx

src/eval/eval_context.rs

@@ -152,6 +152,24 @@ impl<'a, 's, 'ps, 'g, 'c, 't> EvalContext<'a, 's, 'ps, 'g, 'c, 't> {
     pub const fn call_level(&self) -> usize {
         self.global.level
     }
+    /// _(internals, debugging)_ Debugging interface.
+    /// Exported under the `debugging` and `internals` features only.
+    #[cfg(feature = "debugging")]
+    #[cfg(feature = "internals")]
+    #[inline(always)]
+    #[must_use]
+    pub fn debugger(&self) -> Option<&crate::debugger::Debugger> {
+        self.global.debugger.as_deref()
+    }
+    /// _(internals, debugging)_ Mutable reference to the debugging interface.
+    /// Exported under the `debugging` and `internals` features only.
+    #[cfg(feature = "debugging")]
+    #[cfg(feature = "internals")]
+    #[inline(always)]
+    #[must_use]
+    pub fn debugger_mut(&mut self) -> Option<&mut crate::debugger::Debugger> {
+        self.global.debugger.as_deref_mut()
+    }
 
     /// Evaluate an [expression tree][crate::Expression] within this [evaluation context][`EvalContext`].
     ///
@@ -383,12 +401,16 @@ impl<'a, 's, 'ps, 'g, 'c, 't> EvalContext<'a, 's, 'ps, 'g, 'c, 't> {
     /// # Examples
     ///
     /// ```rust,ignore
-    /// // The following disables caching of function resolution results for this frame
-    /// // by pushing a new, empty, caching layer. This is useful if the resolution will be volatile.
+    /// // The following pushes a new, empty, caching layer to make sure that new function resolutions
+    /// // do not persist. This is useful if the resolution will be volatile.
     /// let result: i64 = context.new_frame()
     ///                          .with_new_caching_layer()
     ///                          .call_fn("foo", (0_i64,))?;
     ///
+    /// // In the above example, the resolution to function 'foo' will not be cached outside the frame.
+    /// // The next call to 'foo' will be resolved again instead of using the cached resolution,
+    /// // even if 'foo' is redefined.
+    ///
     /// // The following modifies the [`EvalContext`] before using, restoring its state afterwards.
     /// {
     ///     // Modify the context before using...
@@ -415,7 +437,6 @@ impl<'a, 's, 'ps, 'g, 'c, 't> EvalContext<'a, 's, 'ps, 'g, 'c, 't> {
     /// * 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`].
     /// * the current [nesting level][GlobalRuntimeState::level] of function calls will be restored if modified via [`EvalContextFrameGuard::up_call_level`].
-    /// * the current [scope level][GlobalRuntimeState::scope_level] will be restored if modified via [`EvalContextFrameGuard::up_scope_level`].
     /// * the current [`tag`][GlobalRuntimeState::tag] will be restored if modified via [`EvalContextFrameGuard::with_tag`] or [`EvalContextFrameGuard::clear_tag`].
     pub fn new_frame<'f>(&'f mut self) -> EvalContextFrameGuard<'f, 'a, 's, 'ps, 'g, 'c, 't> {
         EvalContextFrameGuard {
@@ -430,8 +451,6 @@ impl<'a, 's, 'ps, 'g, 'c, 't> EvalContext<'a, 's, 'ps, 'g, 'c, 't> {
             source: None,
             #[cfg(feature = "internals")]
             level: None,
-            #[cfg(feature = "internals")]
-            scope_level: None,
             tag: None,
 
             context: self,
@@ -520,8 +539,6 @@ pub struct EvalContextFrameGuard<'f, 'a, 's, 'ps, 'g, 'c, 't> {
     source: Option<Option<ImmutableString>>,
     #[cfg(feature = "internals")]
     level: Option<usize>,
-    #[cfg(feature = "internals")]
-    scope_level: Option<usize>,
     tag: Option<Dynamic>,
 }
 
@@ -551,10 +568,6 @@ impl Drop for EvalContextFrameGuard<'_, '_, '_, '_, '_, '_, '_> {
         if let Some(level) = self.level {
             self.context.global.level = level;
         }
-        #[cfg(feature = "internals")]
-        if let Some(scope_level) = self.scope_level {
-            self.context.global.scope_level = scope_level;
-        }
         if let Some(tag) = self.tag.take() {
             *self.context.tag_mut() = tag;
         }
@@ -659,13 +672,4 @@ impl<'t> EvalContextFrameGuard<'_, '_, '_, '_, '_, '_, 't> {
         self.context.global.level += 1;
         self
     }
-    /// _(internals)_ Increment the current scope level.
-    /// Exported under the `internals` feature only.
-    #[cfg(feature = "internals")]
-    #[inline(always)]
-    pub fn up_scope_level(mut self) -> Self {
-        self.scope_level = Some(self.context.global.scope_level);
-        self.context.global.scope_level += 1;
-        self
-    }
 }

src/func/native.rs

@@ -265,16 +265,6 @@ impl<'a> NativeCallContext<'a> {
     pub fn iter_imports(&self) -> impl Iterator<Item = (&str, &crate::Module)> {
         self.global.iter_imports()
     }
-    /// _(internals)_ The current [`GlobalRuntimeState`], if any.
-    /// Exported under the `internals` feature only.
-    ///
-    /// Not available under `no_module`.
-    #[expose_under_internals]
-    #[inline(always)]
-    #[must_use]
-    const fn global_runtime_state(&self) -> &GlobalRuntimeState {
-        self.global
-    }
     /// 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).
     ///
@@ -295,6 +285,25 @@ impl<'a> NativeCallContext<'a> {
     pub fn namespaces(&self) -> &[crate::SharedModule] {
         &self.global.lib
     }
+    /// _(internals)_ The current [`GlobalRuntimeState`], if any.
+    /// Exported under the `internals` feature only.
+    ///
+    /// Not available under `no_module`.
+    #[expose_under_internals]
+    #[inline(always)]
+    #[must_use]
+    const fn global_runtime_state(&self) -> &GlobalRuntimeState {
+        self.global
+    }
+    /// _(internals, debugging)_ Debugging interface.
+    /// Exported under the `debugging` and `internals` features only.
+    #[cfg(feature = "debugging")]
+    #[cfg(feature = "internals")]
+    #[inline(always)]
+    #[must_use]
+    pub fn debugger(&self) -> Option<&crate::debugger::Debugger> {
+        self.global.debugger.as_deref()
+    }
 
     /// Call a function inside the call context with the provided arguments.
     #[inline]

tests/functions.rs

@@ -626,9 +626,8 @@ fn test_missing_function_receives_args() {
 #[cfg(not(feature = "no_object"))]
 fn test_missing_function_not_called_for_existing() {
     use std::sync::atomic::{AtomicBool, Ordering};
-    use std::sync::Arc;
 
-    let called = Arc::new(AtomicBool::new(false));
+    let called = Shared::new(AtomicBool::new(false));
     let called_clone = called.clone();
 
     let mut engine = Engine::new();
@@ -708,9 +707,8 @@ fn test_missing_function_multiple_arities() {
 #[cfg(not(feature = "no_object"))]
 fn test_missing_function_is_method_call_flag() {
     use std::sync::atomic::{AtomicBool, Ordering};
-    use std::sync::Arc;
 
-    let saw_method = Arc::new(AtomicBool::new(false));
+    let saw_method = Shared::new(AtomicBool::new(false));
     let saw_method_clone = saw_method.clone();
 
     let mut engine = Engine::new();