Support using rooted macro with vectors. (#697)

We created our `RootedVec` type back before we supported storing
arbitrary traceable types in SpiderMonkey's `Rooted` class. Now that we
can do that, we can replicate SpiderMonkey's `RootedVec`, which is just
a Rooted wrapper around a vector.

Testing: New unit test added.
Servo PR: servo/servo#41921

---------

Signed-off-by: Josh Matthews <josh@joshmatthews.net>

Author: jdm

mozjs-sys/Cargo.toml

@@ -2,7 +2,7 @@
 name = "mozjs_sys"
 description = "System crate for the Mozilla SpiderMonkey JavaScript engine."
 repository.workspace = true
-version = "0.140.5-8"
+version = "0.140.5-9"
 authors = ["Mozilla", "The Servo Project Developers"]
 links = "mozjs"
 license.workspace = true

mozjs-sys/src/jsgc.rs

@@ -110,6 +110,7 @@ pub trait Rootable: crate::trace::Traceable + Sized {
 }
 
 impl<T: Rootable> Rootable for Option<T> {}
+impl<T: crate::trace::Traceable> Rootable for Vec<T> {}
 
 // The C++ representation of Rooted<T> inherits from StackRootedBase, which
 // contains the actual pointers that get manipulated. The Rust representation

mozjs/Cargo.toml

@@ -2,7 +2,7 @@
 name = "mozjs"
 description = "Rust bindings to the Mozilla SpiderMonkey JavaScript engine."
 repository.workspace = true
-version = "0.14.6"
+version = "0.14.7"
 authors = ["The Servo Project Developers"]
 license.workspace = true
 edition.workspace = true
@@ -26,7 +26,7 @@ crown = ["mozjs_sys/crown"]
 encoding_rs = "0.8.35"
 libc.workspace = true
 log = "0.4"
-mozjs_sys = { version = "=0.140.5-8", path = "../mozjs-sys" }
+mozjs_sys = { version = "=0.140.5-9", path = "../mozjs-sys" }
 num-traits = "0.2"
 
 [target.'cfg(target_arch = "wasm32")'.dev-dependencies]

mozjs/src/gc/collections.rs

@@ -49,6 +49,15 @@ impl From<&RootedVec<'_, JSVal>> for JS::HandleValueArray {
     }
 }
 
+impl From<&super::RootedGuard<'_, Vec<JSVal>>> for JS::HandleValueArray {
+    fn from(vec: &super::RootedGuard<'_, Vec<JSVal>>) -> JS::HandleValueArray {
+        JS::HandleValueArray {
+            length_: vec.len(),
+            elements_: vec.deref().as_ptr(),
+        }
+    }
+}
+
 impl<'a, T: Traceable + 'static> RootedVec<'a, T> {
     pub fn new(root: &'a mut RootableVec<T>) -> RootedVec<'a, T> {
         unsafe {

mozjs/src/gc/root.rs

@@ -1,6 +1,6 @@
 use std::marker::PhantomData;
 use std::mem::MaybeUninit;
-use std::ops::Deref;
+use std::ops::{Deref, IndexMut};
 use std::ptr;
 use std::ptr::NonNull;
 
@@ -135,6 +135,40 @@ where
     }
 }
 
+impl<'a, T> RootedGuard<'a, Vec<T>>
+where
+    Vec<T>: RootKind,
+{
+    pub fn push(&mut self, value: T) {
+        // Safety: No GC occurs during this call
+        unsafe { self.as_mut().push(value) }
+    }
+
+    pub fn extend(&mut self, iterator: impl Iterator<Item = T>) {
+        // Safety: No GC occurs during this call
+        unsafe { self.as_mut().extend(iterator) }
+    }
+
+    pub fn set_index(&mut self, index: usize, value: T) {
+        // Safety: No GC occurs during this call
+        unsafe {
+            *self.as_mut().index_mut(index) = value;
+        }
+    }
+
+    pub fn handle_at(&'_ self, index: usize) -> Handle<'_, T> {
+        assert!(index < self.len());
+        // Safety: Values within this rooted vector are traced.
+        unsafe { Handle::from_marked_location(self.deref().as_ptr().add(index)) }
+    }
+
+    pub fn handle_mut_at(&'_ mut self, index: usize) -> MutableHandle<'_, T> {
+        assert!(index < self.len());
+        // Safety: Values within this rooted vector are traced.
+        unsafe { MutableHandle::from_marked_location(self.as_mut().as_mut_ptr().add(index)) }
+    }
+}
+
 impl<'a, T: 'a + RootKind> Deref for RootedGuard<'a, T> {
     type Target = T;
 

mozjs/tests/rooted_vec.rs

@@ -0,0 +1,58 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#![cfg(feature = "debugmozjs")]
+
+use std::ptr;
+
+use mozjs::jsapi::HandleValueArray;
+use mozjs::jsapi::OnNewGlobalHookOption;
+use mozjs::jsapi::SetGCZeal;
+use mozjs::jsval::{JSVal, ObjectValue};
+use mozjs::realm::AutoRealm;
+use mozjs::rooted;
+use mozjs::rust::wrappers2::{
+    GetArrayLength, JS_GetElement, JS_NewGlobalObject, JS_NewPlainObject, NewArrayObject,
+};
+use mozjs::rust::{JSEngine, RealmOptions, Runtime, SIMPLE_GLOBAL_CLASS};
+
+#[test]
+fn rooted_vec() {
+    let engine = JSEngine::init().unwrap();
+    let mut runtime = Runtime::new(engine.handle());
+    let context = runtime.cx();
+    let h_option = OnNewGlobalHookOption::FireOnNewGlobalHook;
+    let c_option = RealmOptions::default();
+
+    unsafe {
+        SetGCZeal(context.raw_cx(), 2, 1);
+        rooted!(&in(context) let global = JS_NewGlobalObject(
+            context,
+            &SIMPLE_GLOBAL_CLASS,
+            ptr::null_mut(),
+            h_option,
+            &*c_option,
+        ));
+        let mut realm = AutoRealm::new_from_handle(context, global.handle());
+        let mut context = &mut realm;
+        rooted!(&in(context) let mut values = vec![]);
+        for _ in 0..32 {
+            values.push(ObjectValue(JS_NewPlainObject(&mut context)));
+        }
+        rooted!(&in(context) let array = NewArrayObject(&mut context, &HandleValueArray::from(&values)));
+        let mut length = 0;
+        assert!(GetArrayLength(&mut context, array.handle(), &mut length));
+        assert_eq!(values.len(), length as usize);
+        for index in 0..length {
+            rooted!(&in(context) let mut element: JSVal);
+            assert!(JS_GetElement(
+                &mut context,
+                array.handle(),
+                index,
+                element.handle_mut()
+            ));
+            assert_eq!(values[index as usize], element.get());
+        }
+    }
+}