Auto merge of #272 - eddyb:back-to-roots, r=Manishearth

Replace return_address usage in Rooted with a stack guard and a rooted! macro.

Part of a potential solution for rust-lang/rust#34227.

<!-- Reviewable:start -->
---
This change is [<img src="https://reviewable.io/review_button.svg" height="35" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/rust-mozjs/272)
<!-- Reviewable:end -->

src/conversions.rs

@@ -33,7 +33,7 @@ use jsapi::JSPROP_ENUMERATE;
 use jsapi::{JSContext, JSObject, JSString, HandleValue, MutableHandleValue};
 use jsapi::{JS_NewUCStringCopyN, JS_StringHasLatin1Chars, JS_WrapValue};
 use jsapi::{JS_GetLatin1StringCharsAndLength, JS_GetTwoByteStringCharsAndLength};
-use jsapi::{JS_NewArrayObject1, JS_DefineElement, RootedValue, RootedObject};
+use jsapi::{JS_NewArrayObject1, JS_DefineElement, RootedObject};
 use jsapi::{ForOfIterator, ForOfIterator_NonIterableBehavior};
 use jsval::{BooleanValue, Int32Value, NullValue, UInt32Value, UndefinedValue};
 use jsval::{JSVal, ObjectValue, ObjectOrNullValue, StringValue};
@@ -473,10 +473,10 @@ impl<T: FromJSValConvertible> FromJSValConvertible for Option<T> {
 // https://heycam.github.io/webidl/#es-sequence
 impl<T: ToJSValConvertible> ToJSValConvertible for Vec<T> {
     unsafe fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue) {
-        let js_array = RootedObject::new(cx, JS_NewArrayObject1(cx, self.len() as libc::size_t));
+        rooted!(in(cx) let js_array = JS_NewArrayObject1(cx, self.len() as libc::size_t));
         assert!(!js_array.handle().is_null());
 
-        let mut val = RootedValue::new(cx, UndefinedValue());
+        rooted!(in(cx) let mut val = UndefinedValue());
         for (index, obj) in self.iter().enumerate() {
             obj.to_jsval(cx, val.handle_mut());
 
@@ -488,6 +488,33 @@ impl<T: ToJSValConvertible> ToJSValConvertible for Vec<T> {
     }
 }
 
+/// Rooting guard for the iterator field of ForOfIterator.
+/// Behaves like RootedGuard (roots on creation, unroots on drop),
+/// but borrows and allows access to the whole ForOfIterator, so
+/// that methods on ForOfIterator can still be used through it.
+struct ForOfIteratorGuard<'a> {
+    root: &'a mut ForOfIterator
+}
+
+impl<'a> ForOfIteratorGuard<'a> {
+    fn new(cx: *mut JSContext, root: &'a mut ForOfIterator) -> Self {
+        unsafe {
+            root.iterator.add_to_root_stack(cx);
+        }
+        ForOfIteratorGuard {
+            root: root
+        }
+    }
+}
+
+impl<'a> Drop for ForOfIteratorGuard<'a> {
+    fn drop(&mut self) {
+        unsafe {
+            self.root.iterator.remove_from_root_stack();
+        }
+    }
+}
+
 impl<C: Clone, T: FromJSValConvertible<Config=C>> FromJSValConvertible for Vec<T> {
     type Config = C;
 
@@ -497,9 +524,11 @@ impl<C: Clone, T: FromJSValConvertible<Config=C>> FromJSValConvertible for Vec<T
                          -> Result<Vec<T>, ()> {
         let mut iterator = ForOfIterator {
             cx_: cx,
-            iterator: RootedObject::new(cx, ptr::null_mut()),
+            iterator: RootedObject::new_unrooted(ptr::null_mut()),
             index: ::std::u32::MAX, // NOT_ARRAY
         };
+        let mut iterator = ForOfIteratorGuard::new(cx, &mut iterator);
+        let iterator = &mut *iterator.root;
 
         if !iterator.init(value, ForOfIterator_NonIterableBehavior::ThrowOnNonIterable) {
             return Err(())
@@ -509,7 +538,7 @@ impl<C: Clone, T: FromJSValConvertible<Config=C>> FromJSValConvertible for Vec<T
 
         loop {
             let mut done = false;
-            let mut val = RootedValue::new(cx, UndefinedValue());
+            rooted!(in(cx) let mut val = UndefinedValue());
             if !iterator.next(val.handle_mut(), &mut done) {
                 return Err(())
             }

src/lib.rs

@@ -5,7 +5,6 @@
 #![crate_name = "js"]
 #![crate_type = "rlib"]
 
-#![feature(core_intrinsics)]
 #![feature(filling_drop)]
 #![feature(link_args)]
 #![feature(unsafe_no_drop_flag)]
@@ -77,12 +76,15 @@ pub mod jsapi {
     include!("jsapi_linux_32_debug.rs");
 }
 
+#[macro_use]
+pub mod rust;
+
 mod consts;
 pub mod conversions;
 pub mod error;
 pub mod glue;
 pub mod jsval;
-pub mod rust;
+
 
 pub use consts::*;
 

src/rust.rs

@@ -4,7 +4,7 @@
 
 //! Rust wrappers around the raw JS apis
 
-use libc::{size_t, c_uint, c_char, ptrdiff_t};
+use libc::{size_t, c_uint, c_char};
 use heapsize::HeapSizeOf;
 use std::char;
 use std::ffi;
@@ -13,7 +13,6 @@ use std::slice;
 use std::mem;
 use std::u32;
 use std::default::Default;
-use std::intrinsics::return_address;
 use std::ops::{Deref, DerefMut};
 use std::cell::UnsafeCell;
 use std::marker::PhantomData;
@@ -26,7 +25,6 @@ use jsapi::{JS_SetErrorReporter, Evaluate2, JSErrorReport};
 use jsapi::{JS_SetGCParameter, JSGCParamKey};
 use jsapi::{Heap, HeapObjectPostBarrier, HeapValuePostBarrier};
 use jsapi::{ContextFriendFields};
-use jsapi::{CustomAutoRooter, AutoGCRooter, _vftable_CustomAutoRooter, AutoGCRooter_jspubtd_h_unnamed_1};
 use jsapi::{Rooted, Handle, MutableHandle, MutableHandleBase, RootedBase};
 use jsapi::{MutableHandleValue, HandleValue, HandleObject, HandleBase};
 use jsapi::AutoObjectVector;
@@ -270,41 +268,103 @@ impl RootKind for Value {
     fn rootKind() -> jsapi::RootKind { jsapi::RootKind::Value }
 }
 
-impl<T: RootKind + Copy> Rooted<T> {
-    pub fn new_with_addr(cx: *mut JSContext, initial: T, addr: *const u8) -> Rooted<T> {
-        let ctxfriend: &mut ContextFriendFields = unsafe {
-            mem::transmute(cx)
-        };
-
-        let kind = T::rootKind() as usize;
-        let root = Rooted::<T> {
+impl<T> Rooted<T> {
+    pub fn new_unrooted(initial: T) -> Rooted<T> {
+        Rooted {
             _base: RootedBase { _phantom0: PhantomData },
-            stack: &mut ctxfriend.roots.stackRoots_[kind] as *mut _ as *mut _,
-            prev: ctxfriend.roots.stackRoots_[kind] as *mut _,
+            stack: ptr::null_mut(),
+            prev: ptr::null_mut(),
             ptr: initial,
-        };
+        }
+    }
+
+    pub unsafe fn add_to_root_stack(&mut self, cx: *mut JSContext) where T: RootKind {
+        let ctxfriend: &mut ContextFriendFields = mem::transmute(cx);
+
+        let kind = T::rootKind() as usize;
+        self.stack = &mut ctxfriend.roots.stackRoots_[kind] as *mut _ as *mut _;
+        self.prev = ctxfriend.roots.stackRoots_[kind] as *mut _;
 
-        ctxfriend.roots.stackRoots_[kind] = unsafe { mem::transmute(addr) };
-        root
+        ctxfriend.roots.stackRoots_[kind] = self as *mut _ as usize as _;
     }
 
-    pub fn new(cx: *mut JSContext, initial: T) -> Rooted<T> {
-        Rooted::new_with_addr(cx, initial, unsafe { return_address() })
+    pub unsafe fn remove_from_root_stack(&mut self) {
+        assert!(*self.stack == mem::transmute(&*self));
+        *self.stack = self.prev;
     }
+}
 
-    pub fn handle(&self) -> Handle<T> {
+/// Rust API for keeping a Rooted value in the context's root stack.
+/// Example usage: `rooted!(in(cx) let x = UndefinedValue());`.
+/// `RootedGuard::new` also works, but the macro is preferred.
+pub struct RootedGuard<'a, T: 'a> {
+    root: &'a mut Rooted<T>
+}
+
+impl<'a, T> RootedGuard<'a, T> {
+    pub fn new(cx: *mut JSContext, root: &'a mut Rooted<T>) -> Self where T: RootKind {
         unsafe {
-            Handle::from_marked_location(&self.ptr)
+            root.add_to_root_stack(cx);
         }
+        RootedGuard {
+            root: root
+        }
+    }
+
+    pub fn handle(&self) -> Handle<T> where T: Copy {
+        unsafe {
+            Handle::from_marked_location(&self.root.ptr)
+        }
+    }
+
+    pub fn handle_mut(&mut self) -> MutableHandle<T> where T: Copy {
+        unsafe {
+            MutableHandle::from_marked_location(&mut self.root.ptr)
+        }
+    }
+
+    pub fn get(&self) -> T where T: Copy {
+        self.root.ptr
+    }
+
+    pub fn set(&mut self, v: T) {
+        self.root.ptr = v;
+    }
+}
+
+impl<'a, T> Deref for RootedGuard<'a, T> {
+    type Target = T;
+    fn deref(&self) -> &T {
+        &self.root.ptr
+    }
+}
+
+impl<'a, T> DerefMut for RootedGuard<'a, T> {
+    fn deref_mut(&mut self) -> &mut T {
+        &mut self.root.ptr
     }
+}
 
-    pub fn handle_mut(&mut self) -> MutableHandle<T> {
+impl<'a, T> Drop for RootedGuard<'a, T> {
+    fn drop(&mut self) {
         unsafe {
-            MutableHandle::from_marked_location(&mut self.ptr)
+            self.root.remove_from_root_stack();
         }
     }
 }
 
+#[macro_export]
+macro_rules! rooted {
+    (in($cx:expr) let $name:ident = $init:expr) => {
+        let mut __root = $crate::jsapi::Rooted::new_unrooted($init);
+        let $name = $crate::rust::RootedGuard::new($cx, &mut __root);
+    };
+    (in($cx:expr) let mut $name:ident = $init:expr) => {
+        let mut __root = $crate::jsapi::Rooted::new_unrooted($init);
+        let mut $name = $crate::rust::RootedGuard::new($cx, &mut __root);
+    }
+}
+
 impl<T: Copy> Handle<T> {
     pub fn get(&self) -> T {
         unsafe { *self.ptr }
@@ -391,57 +451,6 @@ impl<T: Copy> MutableHandle<T> {
     }
 }
 
-impl<T> Drop for Rooted<T> {
-    fn drop(&mut self) {
-        unsafe {
-            if self.stack as usize == mem::POST_DROP_USIZE {
-                return;
-            }
-            assert!(*self.stack == mem::transmute(&*self));
-            *self.stack = self.prev;
-        }
-    }
-}
-
-impl CustomAutoRooter {
-    pub fn new(cx: *mut JSContext, vftable: &'static _vftable_CustomAutoRooter)
-        -> CustomAutoRooter {
-        CustomAutoRooter::new_with_addr(cx, vftable, unsafe { return_address() })
-    }
-
-    pub fn new_with_addr(cx: *mut JSContext, vftable: &'static _vftable_CustomAutoRooter, addr: *const u8) -> CustomAutoRooter {
-        let ctxfriend: &mut ContextFriendFields = unsafe {
-            &mut *(cx as *mut ContextFriendFields)
-        };
-
-        let rooter = CustomAutoRooter {
-            _vftable: vftable as *const _,
-            _base: AutoGCRooter {
-                down: ctxfriend.roots.autoGCRooters_,
-                tag_: AutoGCRooter_jspubtd_h_unnamed_1::CUSTOM as ptrdiff_t,
-                stackTop: &mut ctxfriend.roots.autoGCRooters_ as *mut _,
-            }
-        };
-
-        ctxfriend.roots.autoGCRooters_ = unsafe {
-            (addr as *const *const u8).offset(1) as *const AutoGCRooter as *mut _
-        };
-        rooter
-    }
-}
-
-impl Drop for CustomAutoRooter {
-    fn drop(&mut self) {
-        if self._base.stackTop as usize == mem::POST_DROP_USIZE {
-            return;
-        }
-        unsafe {
-            assert!(*self._base.stackTop == mem::transmute(&self._base));
-            *self._base.stackTop = self._base.down;
-        }
-    }
-}
-
 impl Default for jsid {
     fn default() -> jsid { JSID_VOID }
 }