f

Signed-off-by: sagudev <[email protected]>

Author: sagudev

mozjs/benches/latin1_string_conversion.rs

@@ -61,7 +61,7 @@ fn bench_str_repetition(
 fn external_string(c: &mut Criterion) {
     let engine = JSEngine::init().unwrap();
     let mut runtime = Runtime::new(engine.handle());
-    let context = *runtime.cx();
+    let context = **runtime.cx();
     let h_option = OnNewGlobalHookOption::FireOnNewGlobalHook;
     let c_option = RealmOptions::default();
     rooted!(in(context) let global = unsafe { JS_NewGlobalObject(

mozjs/examples/eval.rs

@@ -23,8 +23,8 @@ use mozjs::rust::{JSEngine, RealmOptions, Runtime};
 
 fn run(mut rt: Runtime) {
     let options = RealmOptions::default();
-    rooted!(in(*rt.cx()) let global = unsafe {
-        JS_NewGlobalObject(*rt.cx(), &SIMPLE_GLOBAL_CLASS, ptr::null_mut(),
+    rooted!(in(**rt.cx()) let global = unsafe {
+        JS_NewGlobalObject(**rt.cx(), &SIMPLE_GLOBAL_CLASS, ptr::null_mut(),
                            OnNewGlobalHookOption::FireOnNewGlobalHook,
                            &*options)
     });
@@ -37,7 +37,7 @@ fn run(mut rt: Runtime) {
      * The return value comes back here. If it could be a GC thing, you must add it to the
      * GC's "root set" with the rooted! macro.
      */
-    rooted!(in(*rt.cx()) let mut rval = UndefinedValue());
+    rooted!(in(**rt.cx()) let mut rval = UndefinedValue());
 
     /*
      * Some example source in a string. This is equivalent to JS_EvaluateScript in C++.

mozjs/examples/minimal.rs

@@ -34,7 +34,7 @@ fn main() {
 }
 
 fn run(mut rt: Runtime) {
-    let cx = *rt.cx();
+    let cx = **rt.cx();
     // In addition to what the C++ interface requires, define a global scope for the code.
     //
     // This demonstrates the way Rust uses the C++ garbage collector: using the rooted! macro to

mozjs/examples/wasm.rs

@@ -49,34 +49,34 @@ unsafe extern "C" fn bar(_cx: *mut JSContext, argc: u32, vp: *mut Value) -> bool
 
 fn run(mut rt: Runtime) {
     let options = RealmOptions::default();
-    rooted!(in(*rt.cx()) let global = unsafe {
-        JS_NewGlobalObject(*rt.cx(), &SIMPLE_GLOBAL_CLASS, ptr::null_mut(),
+    rooted!(in(**rt.cx()) let global = unsafe {
+        JS_NewGlobalObject(**rt.cx(), &SIMPLE_GLOBAL_CLASS, ptr::null_mut(),
                            OnNewGlobalHookOption::FireOnNewGlobalHook,
                            &*options)
     });
-    let _ac = JSAutoRealm::new(*rt.cx(), global.get());
+    let _ac = JSAutoRealm::new(**rt.cx(), global.get());
 
     // Get WebAssembly.Module and WebAssembly.Instance constructors.
-    rooted!(in(*rt.cx()) let mut wasm = UndefinedValue());
-    rooted!(in(*rt.cx()) let mut wasm_module = UndefinedValue());
-    rooted!(in(*rt.cx()) let mut wasm_instance = UndefinedValue());
+    rooted!(in(**rt.cx()) let mut wasm = UndefinedValue());
+    rooted!(in(**rt.cx()) let mut wasm_module = UndefinedValue());
+    rooted!(in(**rt.cx()) let mut wasm_instance = UndefinedValue());
 
     unsafe {
         assert!(JS_GetProperty(
-            *rt.cx(),
+            **rt.cx(),
             global.handle(),
             c"WebAssembly".as_ptr(),
             wasm.handle_mut()
         ));
-        rooted!(in(*rt.cx()) let mut wasm_obj = wasm.to_object());
+        rooted!(in(**rt.cx()) let mut wasm_obj = wasm.to_object());
         assert!(JS_GetProperty(
-            *rt.cx(),
+            **rt.cx(),
             wasm_obj.handle(),
             c"Module".as_ptr(),
             wasm_module.handle_mut()
         ));
         assert!(JS_GetProperty(
-            *rt.cx(),
+            **rt.cx(),
             wasm_obj.handle(),
             c"Instance".as_ptr(),
             wasm_instance.handle_mut()
@@ -86,85 +86,85 @@ fn run(mut rt: Runtime) {
         assert!(HI_WASM.0.as_ptr() as usize % 8 == 0);
 
         // Construct Wasm module from bytes.
-        rooted!(in(*rt.cx()) let mut module = null_mut::<JSObject>());
+        rooted!(in(**rt.cx()) let mut module = null_mut::<JSObject>());
         {
             let array_buffer = JS::NewArrayBufferWithUserOwnedContents(
-                *rt.cx(),
+                **rt.cx(),
                 HI_WASM.0.len(),
                 HI_WASM.0.as_ptr() as _,
             );
             assert!(!array_buffer.is_null());
 
-            rooted!(in(*rt.cx()) let val = ObjectValue(array_buffer));
+            rooted!(in(**rt.cx()) let val = ObjectValue(array_buffer));
             let args = HandleValueArray::from(val.handle().into_handle());
 
             assert!(Construct1(
-                *rt.cx(),
+                **rt.cx(),
                 wasm_module.handle(),
                 &args,
                 module.handle_mut()
             ))
         }
 
         // Construct Wasm module instance with required imports.
-        rooted!(in(*rt.cx()) let mut instance = null_mut::<JSObject>());
+        rooted!(in(**rt.cx()) let mut instance = null_mut::<JSObject>());
         {
             // Build "env" imports object.
-            rooted!(in(*rt.cx()) let mut env_import_obj = JS_NewPlainObject(*rt.cx()));
+            rooted!(in(**rt.cx()) let mut env_import_obj = JS_NewPlainObject(**rt.cx()));
             assert!(!env_import_obj.is_null());
             let function = JS_DefineFunction(
-                *rt.cx(),
+                **rt.cx(),
                 env_import_obj.handle().into(),
                 c"bar".as_ptr(),
                 Some(bar),
                 1,
                 0,
             );
             assert!(!function.is_null());
-            rooted!(in(*rt.cx()) let mut env_import = ObjectValue(env_import_obj.get()));
+            rooted!(in(**rt.cx()) let mut env_import = ObjectValue(env_import_obj.get()));
             // Build imports bag.
-            rooted!(in(*rt.cx()) let mut imports = JS_NewPlainObject(*rt.cx()));
+            rooted!(in(**rt.cx()) let mut imports = JS_NewPlainObject(**rt.cx()));
             assert!(!imports.is_null());
             assert!(JS_SetProperty(
-                *rt.cx(),
+                **rt.cx(),
                 imports.handle(),
                 c"env".as_ptr(),
                 env_import.handle()
             ));
 
-            rooted!(in(*rt.cx()) let mut args = ValueArray::new([ObjectValue(module.get()), ObjectValue(imports.get())]));
+            rooted!(in(**rt.cx()) let mut args = ValueArray::new([ObjectValue(module.get()), ObjectValue(imports.get())]));
 
             assert!(Construct1(
-                *rt.cx(),
+                **rt.cx(),
                 wasm_instance.handle(),
                 &HandleValueArray::from(&args),
                 instance.handle_mut()
             ));
         }
 
         // Find `foo` method in exports.
-        rooted!(in(*rt.cx()) let mut exports = UndefinedValue());
+        rooted!(in(**rt.cx()) let mut exports = UndefinedValue());
 
         assert!(JS_GetProperty(
-            *rt.cx(),
+            **rt.cx(),
             instance.handle(),
             c"exports".as_ptr(),
             exports.handle_mut()
         ));
 
-        rooted!(in(*rt.cx()) let mut exports_obj = exports.to_object());
-        rooted!(in(*rt.cx()) let mut foo = UndefinedValue());
+        rooted!(in(**rt.cx()) let mut exports_obj = exports.to_object());
+        rooted!(in(**rt.cx()) let mut foo = UndefinedValue());
         assert!(JS_GetProperty(
-            *rt.cx(),
+            **rt.cx(),
             exports_obj.handle(),
             c"foo".as_ptr(),
             foo.handle_mut()
         ));
 
         // call foo and get its result
-        rooted!(in(*rt.cx()) let mut rval = UndefinedValue());
+        rooted!(in(**rt.cx()) let mut rval = UndefinedValue());
         assert!(Call(
-            *rt.cx(),
+            **rt.cx(),
             JS::UndefinedHandleValue,
             foo.handle().into(),
             &HandleValueArray::empty(),

mozjs/src/context.rs

@@ -85,27 +85,20 @@ pub use crate::jsapi::JSContext as RawJSContext;
 /// ### WIP
 ///
 /// This model is still being incrementally introduced, so there are currently some escape hatches.
-#[derive(Copy, Clone)]
-pub struct JSContext<'rt> {
+pub struct JSContext {
     pub(crate) ptr: NonNull<RawJSContext>,
-    pub(crate) runtime_anchor: PhantomData<&'rt ()>,
 }
 
-impl<'rt> JSContext<'rt> {
+impl JSContext {
     /// Wrap an existing [RawJSContext] pointer.
     ///
     /// SAFETY:
     /// - `cx` must be valid [RawJSContext] object.
-    /// - the resulting lifetime `'rt` must not exceed the actual lifetime of the
-    ///   associated [Runtime].
-    /// - only one [JSContext] can be alive.
+    /// - only one [JSContext] can be alive and it should not outlive [Runtime].
     /// This in turn means that [JSContext] always needs to be passed down as an argument,
     /// but for the SpiderMonkey callbacks which provide [RawJSContext] it's safe to construct **one** from provided [RawJSContext].
-    pub unsafe fn from_ptr(cx: NonNull<RawJSContext>) -> JSContext<'rt> {
-        JSContext {
-            ptr: cx,
-            runtime_anchor: PhantomData,
-        }
+    pub unsafe fn from_ptr(cx: NonNull<RawJSContext>) -> JSContext {
+        JSContext { ptr: cx }
     }
 
     /// Returns [NoGC] token bounded to this [JSContext].
@@ -132,11 +125,33 @@ impl<'rt> JSContext<'rt> {
     /// fn SM_function_that_can_trigger_gc(_cx: *mut RawJSContext) {}
     ///
     /// fn can_trigger_gc(cx: &mut JSContext) {
-    ///     unsafe { SM_function_that_can_trigger_gc(cx.raw()) } // returned pointer is immediately used
+    ///     unsafe { SM_function_that_can_trigger_gc(cx.raw_cx()) } // returned pointer is immediately used
     ///     cx.no_gc(); // this is ok because no outstanding raw pointer is alive
     /// }
     /// ```
-    pub unsafe fn raw(&mut self) -> *mut RawJSContext {
+    pub unsafe fn raw_cx(&mut self) -> *mut RawJSContext {
+        self.ptr.as_ptr()
+    }
+
+    /// Obtain [RawJSContext] mutable pointer, that will not be used for GC.
+    ///
+    /// # Safety
+    ///
+    /// No &mut calls should be done on [JSContext] while returned pointer is available.
+    /// In practices this means that one should use the result
+    /// as direct argument to SpiderMonkey function and not store it in variable.
+    ///
+    /// ```rust
+    /// use mozjs::context::*;
+    /// use mozjs::jsapi::JSContext as RawJSContext;
+    ///
+    /// fn SM_function_that_cannot_trigger_gc(_cx: *mut RawJSContext) {}
+    ///
+    /// fn f(cx: &mut JSContext) {
+    ///     unsafe { SM_function_that_cannot_trigger_gc(cx.raw_cx_no_gc()) } // returned pointer is immediately used
+    /// }
+    /// ```
+    pub unsafe fn raw_cx_no_gc(&self) -> *mut RawJSContext {
         self.ptr.as_ptr()
     }
 }
@@ -149,13 +164,13 @@ impl<'rt> JSContext<'rt> {
 /// For more info and examples see [JSContext].
 pub struct NoGC<'cx>(PhantomData<&'cx ()>);
 
-impl<'rt> Deref for JSContext<'rt> {
+impl Deref for JSContext {
     type Target = *mut RawJSContext;
 
     /// This exists to make migration to [JSContext] easier,
     /// but it will be eventually removed as it is **unsafe**.
     ///
-    /// Use [JSContext::raw] instead.
+    /// Use [JSContext::raw_cx] instead.
     fn deref(&'_ self) -> &'_ Self::Target {
         unsafe { std::mem::transmute::<&NonNull<RawJSContext>, &*mut RawJSContext>(&self.ptr) }
     }

mozjs/src/rust.rs

@@ -283,8 +283,8 @@ unsafe impl Send for ParentRuntime {}
 
 /// A wrapper for the `JSContext` structure in SpiderMonkey.
 pub struct Runtime {
-    /// Raw pointer to the underlying SpiderMonkey context.
-    cx: NonNull<JSContext>,
+    /// Safe SpiderMonkey context.
+    cx: crate::context::JSContext,
     /// The engine that this runtime is associated with.
     engine: JSEngineHandle,
     /// If this Runtime was created with a parent, this member exists to ensure
@@ -389,24 +389,30 @@ impl Runtime {
         Runtime {
             engine,
             _parent_child_count: parent.map(|p| p.children_of_parent),
-            cx: js_context,
+            cx: crate::context::JSContext::from_ptr(js_context),
             outstanding_children: Arc::new(()),
             thread_safe_handle: Arc::new(RwLock::new(Some(js_context))),
         }
     }
 
     /// Returns the `JSRuntime` object.
     pub fn rt(&self) -> *mut JSRuntime {
-        unsafe { JS_GetRuntime(self.cx.as_ptr()) }
+        // SAFETY: JS_GetRuntime does not trigger GC
+        unsafe { JS_GetRuntime(self.cx.raw_cx_no_gc()) }
     }
 
     /// Returns the `JSContext` object.
-    pub fn cx<'rt>(&'rt mut self) -> crate::context::JSContext<'rt> {
-        unsafe { crate::context::JSContext::from_ptr(self.cx) }
+    pub fn cx<'rt>(&'rt mut self) -> &'rt mut crate::context::JSContext {
+        &mut self.cx
+    }
+
+    /// Returns the `JSContext` object.
+    pub fn cx_no_gc<'rt>(&'rt self) -> &'rt crate::context::JSContext {
+        &self.cx
     }
 
     pub fn evaluate_script(
-        &self,
+        &mut self,
         glob: HandleObject,
         script: &str,
         rval: MutableHandleValue,
@@ -418,11 +424,11 @@ impl Runtime {
             script
         );
 
-        let _ac = JSAutoRealm::new(self.cx.as_ptr(), glob.get());
+        let _ac = JSAutoRealm::new(unsafe { self.cx().raw_cx() }, glob.get());
 
         unsafe {
             let mut source = transform_str_to_source_text(&script);
-            if !Evaluate2(self.cx.as_ptr(), options.ptr, &mut source, rval.into()) {
+            if !Evaluate2(self.cx().raw_cx(), options.ptr, &mut source, rval.into()) {
                 debug!("...err!");
                 maybe_resume_unwind();
                 Err(())
@@ -435,9 +441,9 @@ impl Runtime {
         }
     }
 
-    pub fn new_compile_options(&self, filename: &str, line: u32) -> CompileOptionsWrapper {
+    pub fn new_compile_options(&mut self, filename: &str, line: u32) -> CompileOptionsWrapper {
         // SAFETY: `cx` argument points to a non-null, valid JSContext
-        unsafe { CompileOptionsWrapper::new(self.cx.as_ptr(), filename, line) }
+        unsafe { CompileOptionsWrapper::new(self.cx().raw_cx(), filename, line) }
     }
 }
 
@@ -449,7 +455,7 @@ impl Drop for Runtime {
             "This runtime still has live children."
         );
         unsafe {
-            JS_DestroyContext(self.cx.as_ptr());
+            JS_DestroyContext(self.cx.raw_cx());
 
             CONTEXT.with(|context| {
                 assert!(context.take().is_some());

mozjs/tests/callback.rs

@@ -17,7 +17,7 @@ use mozjs::rust::{JSEngine, RealmOptions, Runtime, SIMPLE_GLOBAL_CLASS};
 fn callback() {
     let engine = JSEngine::init().unwrap();
     let mut runtime = Runtime::new(engine.handle());
-    let context = *runtime.cx();
+    let context = **runtime.cx();
     #[cfg(feature = "debugmozjs")]
     unsafe {
         mozjs::jsapi::SetGCZeal(context, 2, 1);

mozjs/tests/capture_stack.rs

@@ -33,7 +33,7 @@ fn capture_stack() {
 
     let engine = JSEngine::init().unwrap();
     let mut runtime = Runtime::new(engine.handle());
-    let context = *runtime.cx();
+    let context = **runtime.cx();
     #[cfg(feature = "debugmozjs")]
     unsafe {
         mozjs::jsapi::SetGCZeal(context, 2, 1);

mozjs/tests/custom_auto_rooter.rs

@@ -32,7 +32,7 @@ unsafe impl CustomTrace for TraceCheck {
 fn virtual_trace_called() {
     let engine = JSEngine::init().unwrap();
     let mut runtime = Runtime::new(engine.handle());
-    let context = *runtime.cx();
+    let context = **runtime.cx();
 
     let mut rooter = CustomAutoRooter::new(TraceCheck::new());
     let guard = rooter.root(context);

mozjs/tests/custom_auto_rooter_macro.rs

@@ -30,7 +30,7 @@ unsafe impl CustomTrace for TraceCheck {
 fn custom_auto_rooter_macro() {
     let engine = JSEngine::init().unwrap();
     let mut runtime = Runtime::new(engine.handle());
-    let context = *runtime.cx();
+    let context = **runtime.cx();
 
     auto_root!(in(context) let vec = vec![TraceCheck::new(), TraceCheck::new()]);