Moved GC traits from mozjs crate to mozjs_sys

Author: Alan Jeffrey

Cargo.toml

@@ -30,3 +30,6 @@ libz-sys = "1.0"
 [build-dependencies]
 bindgen = "0.36"
 cc = "1.0"
+
+[patch.crates-io]
+bindgen = { git = "https://github.com/emilio/rust-bindgen", branch = "per-module-lines" }

build.rs

@@ -158,6 +158,10 @@ fn build_jsapi_bindings() {
         builder = builder.blacklist_type(ty);
     }
 
+    for &(module, raw_line) in MODULE_RAW_LINES {
+        builder = builder.module_raw_line(module, raw_line);
+    }
+
     let bindings = builder.generate()
         .expect("Should generate JSAPI bindings OK");
 
@@ -421,3 +425,8 @@ const BLACKLIST_TYPES: &'static [&'static str] = &[
     // the definition of the struct to make our Drop implementation correct.
     "JS::Heap",
 ];
+
+/// Definitions for types that were blacklisted
+const MODULE_RAW_LINES: &'static [(&'static str, &'static str)] = &[
+    ("root::JS", "pub type Heap<T> = ::jsgc::Heap<T>;")
+];

src/jsgc.rs

@@ -0,0 +1,229 @@
+/* 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/. */
+
+use jsapi::JS;
+use jsapi::jsid;
+use jsapi::JSFlatString;
+use jsapi::JSFunction;
+use jsapi::JSID_VOID;
+use jsapi::JSObject;
+use jsapi::JSScript;
+use jsapi::JSString;
+
+use std::cell::UnsafeCell;
+use std::mem;
+use std::ptr;
+
+// Trait for rooting
+
+pub trait RootKind {
+    #[allow(non_snake_case)]
+    #[inline(always)]
+    fn rootKind() -> JS::RootKind;
+}
+
+impl RootKind for *mut JSObject {
+    #[inline(always)]
+    fn rootKind() -> JS::RootKind { JS::RootKind::Object }
+}
+
+impl RootKind for *mut JSFlatString {
+    #[inline(always)]
+    fn rootKind() -> JS::RootKind { JS::RootKind::String }
+}
+
+impl RootKind for *mut JSFunction {
+    #[inline(always)]
+    fn rootKind() -> JS::RootKind { JS::RootKind::Object }
+}
+
+impl RootKind for *mut JSString {
+    #[inline(always)]
+    fn rootKind() -> JS::RootKind { JS::RootKind::String }
+}
+
+impl RootKind for *mut JS::Symbol {
+    #[inline(always)]
+    fn rootKind() -> JS::RootKind { JS::RootKind::Symbol }
+}
+
+impl RootKind for *mut JSScript {
+    #[inline(always)]
+    fn rootKind() -> JS::RootKind { JS::RootKind::Script }
+}
+
+impl RootKind for jsid {
+    #[inline(always)]
+    fn rootKind() -> JS::RootKind { JS::RootKind::Id }
+}
+
+impl RootKind for JS::Value {
+    #[inline(always)]
+    fn rootKind() -> JS::RootKind { JS::RootKind::Value }
+}
+
+impl RootKind for JS::PropertyDescriptor {
+    #[inline(always)]
+    fn rootKind() -> JS::RootKind { JS::RootKind::Traceable }
+}
+
+// Trait for GC
+
+pub trait GCMethods {
+    unsafe fn initial() -> Self;
+    unsafe fn post_barrier(v: *mut Self, prev: Self, next: Self);
+}
+
+impl GCMethods for jsid {
+    unsafe fn initial() -> jsid { JSID_VOID }
+    unsafe fn post_barrier(_: *mut jsid, _: jsid, _: jsid) {}
+}
+
+impl GCMethods for *mut JSObject {
+    unsafe fn initial() -> *mut JSObject { ptr::null_mut() }
+    unsafe fn post_barrier(v: *mut *mut JSObject,
+                           prev: *mut JSObject, next: *mut JSObject) {
+        JS::HeapObjectPostBarrier(v, prev, next);
+    }
+}
+
+impl GCMethods for *mut JSString {
+    unsafe fn initial() -> *mut JSString { ptr::null_mut() }
+    unsafe fn post_barrier(_: *mut *mut JSString, _: *mut JSString, _: *mut JSString) {}
+}
+
+impl GCMethods for *mut JSScript {
+    unsafe fn initial() -> *mut JSScript { ptr::null_mut() }
+    unsafe fn post_barrier(_: *mut *mut JSScript, _: *mut JSScript, _: *mut JSScript) { }
+}
+
+impl GCMethods for *mut JSFunction {
+    unsafe fn initial() -> *mut JSFunction { ptr::null_mut() }
+    unsafe fn post_barrier(v: *mut *mut JSFunction,
+                           prev: *mut JSFunction, next: *mut JSFunction) {
+        JS::HeapObjectPostBarrier(mem::transmute(v),
+                                  mem::transmute(prev), mem::transmute(next));
+    }
+}
+
+impl GCMethods for JS::Value {
+    unsafe fn initial() -> JS::Value { JS::Value::default() }
+    unsafe fn post_barrier(v: *mut JS::Value, prev: JS::Value, next: JS::Value) {
+        JS::HeapValuePostBarrier(v, &prev, &next);
+    }
+}
+
+impl GCMethods for JS::PropertyDescriptor {
+    unsafe fn initial() -> JS::PropertyDescriptor { JS::PropertyDescriptor::default() }
+    unsafe fn post_barrier(_ : *mut JS::PropertyDescriptor, _ : JS::PropertyDescriptor, _ : JS::PropertyDescriptor) {}
+}
+
+/// Heap values encapsulate GC concerns of an on-heap reference to a JS
+/// object. This means that every reference to a JS object on heap must
+/// be realized through this structure.
+///
+/// # Safety
+/// For garbage collection to work correctly in SpiderMonkey, modifying the
+/// wrapped value triggers a GC barrier, pointing to the underlying object.
+///
+/// This means that after calling the `set()` function with a non-null or
+/// non-undefined value, the `Heap` wrapper *must not* be moved, since doing
+/// so will invalidate the local reference to wrapped value, still held by
+/// SpiderMonkey.
+///
+/// For safe `Heap` construction with value see `Heap::boxed` function.
+#[repr(C)]
+#[derive(Debug)]
+pub struct Heap<T: GCMethods + Copy> {
+    pub ptr: UnsafeCell<T>,
+}
+
+impl<T: GCMethods + Copy> Heap<T> {
+    /// This creates a `Box`-wrapped Heap value. Setting a value inside Heap
+    /// object triggers a barrier, referring to the Heap object location,
+    /// hence why it is not safe to construct a temporary Heap value, assign
+    /// a non-null value and move it (e.g. typical object construction).
+    ///
+    /// Using boxed Heap value guarantees that the underlying Heap value will
+    /// not be moved when constructed.
+    pub fn boxed(v: T) -> Box<Heap<T>>
+        where Heap<T>: Default
+    {
+        let boxed = Box::new(Heap::default());
+        boxed.set(v);
+        boxed
+    }
+
+    pub fn set(&self, v: T) {
+        unsafe {
+            let ptr = self.ptr.get();
+            let prev = *ptr;
+            *ptr = v;
+            T::post_barrier(ptr, prev, v);
+        }
+    }
+
+    pub fn get(&self) -> T {
+        unsafe { *self.ptr.get() }
+    }
+
+    pub fn get_unsafe(&self) -> *mut T {
+        self.ptr.get()
+    }
+
+    pub fn handle_mut(&self) -> JS::MutableHandle<T> {
+        unsafe {
+            JS::MutableHandle::from_marked_location(self.ptr.get())
+        }
+    }
+    /// Retrieves a Handle to the underlying value.
+    ///
+    /// # Safety
+    ///
+    /// This is only safe to do on a rooted object (which Heap is not, it needs
+    /// to be additionally rooted), like RootedGuard, so use this only if you
+    /// know what you're doing.
+    ///
+    /// # Notes
+    ///
+    /// Since Heap values need to be informed when a change to underlying
+    /// value is made (e.g. via `get()`), this does not allow to create
+    /// MutableHandle objects, which can bypass this and lead to crashes.
+    pub unsafe fn handle(&self) -> JS::Handle<T> {
+        JS::Handle::from_marked_location(self.ptr.get() as *const _)
+    }
+}
+
+impl<T> Default for Heap<*mut T>
+    where *mut T: GCMethods + Copy
+{
+    fn default() -> Heap<*mut T> {
+        Heap {
+            ptr: UnsafeCell::new(ptr::null_mut())
+        }
+    }
+}
+
+impl Default for Heap<JS::Value> {
+    fn default() -> Heap<JS::Value> {
+        Heap {
+            ptr: UnsafeCell::new(JS::Value::default())
+        }
+    }
+}
+
+impl<T: GCMethods + Copy> Drop for Heap<T> {
+    fn drop(&mut self) {
+        unsafe {
+            let ptr = self.ptr.get();
+            T::post_barrier(ptr, *ptr, T::initial());
+        }
+    }
+}
+
+impl<T: GCMethods + Copy + PartialEq> PartialEq for Heap<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.get() == other.get()
+    }
+}

src/jsglue.rs

@@ -15,25 +15,30 @@ use jsapi::JS_LeaveCompartment;
 use jsapi::glue::JS_NewCompartmentOptions;
 use jsapi::JSID_VOID;
 use jsapi::jsid;
-use rooting;
+use jsgc::RootKind;
+use jsval::UndefinedValue;
 
-impl<T> ::std::ops::Deref for JS::Handle<T> {
+use std::ops::Deref;
+use std::ops::DerefMut;
+use std::ptr;
+
+impl<T> Deref for JS::Handle<T> {
     type Target = T;
 
     fn deref<'a>(&'a self) -> &'a T {
         unsafe { &*self.ptr }
     }
 }
 
-impl<T> ::std::ops::Deref for JS::MutableHandle<T> {
+impl<T> Deref for JS::MutableHandle<T> {
     type Target = T;
 
     fn deref<'a>(&'a self) -> &'a T {
         unsafe { &*self.ptr }
     }
 }
 
-impl<T> ::std::ops::DerefMut for JS::MutableHandle<T> {
+impl<T> DerefMut for JS::MutableHandle<T> {
     fn deref_mut<'a>(&'a mut self) -> &'a mut T {
         unsafe { &mut *self.ptr }
     }
@@ -49,6 +54,18 @@ impl Default for JS::CompartmentOptions {
     }
 }
 
+impl Default for JS::PropertyDescriptor {
+    fn default() -> Self {
+        JS::PropertyDescriptor {
+            obj: ptr::null_mut(),
+            attrs: 0,
+            getter: None,
+            setter: None,
+            value: UndefinedValue()
+        }
+    }
+}
+
 impl Drop for JSAutoCompartment {
     fn drop(&mut self) {
         unsafe { JS_LeaveCompartment(self.cx_, self.oldCompartment_); }
@@ -258,7 +275,7 @@ impl<T> JS::Rooted<T> {
         }
     }
 
-    pub unsafe fn add_to_root_stack(&mut self, cx: *mut JSContext) where T: rooting::RootKind {
+    pub unsafe fn add_to_root_stack(&mut self, cx: *mut JSContext) where T: RootKind {
         let ctxfriend = cx as *mut js::ContextFriendFields;
         let zone = (*ctxfriend).zone_;
         let roots: *mut _ = if !zone.is_null() {

src/lib.rs

@@ -8,7 +8,7 @@ mod generated { include!(concat!(env!("OUT_DIR"), "/jsapi.rs")); }
 mod jsglue;
 
 // Modules with public definitions
-pub mod rooting;
+pub mod jsgc;
 pub mod jsval;
 
 // Reexport the bindings in the jsapi module