Auto merge of #6150 - servo:smupgrade3, r=mbrubeck

Upgrade to Spidermonkey 39

> Here it is.
> 
> ~~There's two major things that are unfinished here:~~
> - ~~Dealing with the unroot_must_root lint. I'm not sure about the value of this lint with the new rooting API.~~ Done.
> - ~~Updating the Cargo.locks to point to the new SM and SM binding.~~ Done.
> 
> I also included my fixes for the rust update, but these will disappear in a rebase. A rust update is necessary to support calling `Drop` on `Heap<T>` correctly when `Heap<T>` is inside a `Rc<T>`. Otherwise `&self` points to the wrong location.
> 
> Incremental GC is disabled here. I'm not sure how to deal with the incremental barriers so that's left for later.
> 
> Generational GC works. SM doesn't work without it.
> 
> The biggest change here is to the rooting API. `Root` was made movable, and `Temporary` and `JSRef` was removed. Movable `Root`s means there's no need for `Temporary`, and `JSRef`s aren't needed generally since it can be assumed that being able to obtain a reference to a dom object means it's already rooted. References have their lifetime bound to the Roots that provided them. DOM objects that haven't passed through `reflect_dom_object` don't need to be rooted, and DOM objects that have passed through `reflect_dom_object` can't be obtained without being rooted through `native_from_reflector_jsmanaged` or `JS::<T>::root()`.
> 
> Support for `Heap<T>` ended up messier than I expected. It's split into two commits, but only because it's a bit difficult to fold them together. Supporting `Heap<T>` properly requires that that `Heap::<T>::set()` be called on something that won't move. I removed the Copy and Clone trait from `Heap<T>` so `Cell` can't hold `Heap<T>` - only `UnsafeCell` can hold it.
> 
> `CallbackObject` is a bit tricky - I moved all callbacks into `Rc<T>` in order to make sure that the pointer inside to a `*mut JSObject` doesn't move. This is necessary for supporting `Heap<T>`.
> 
> `RootedCollectionSet` is very general purpose now. Anything with `JSTraceable` can be rooted by `RootedCollectionSet`/`RootedTraceable`. Right now, `RootedTraceable` is only used to hold down dom objects before they're fully attached to their reflector. I had to make a custom mechanism to dispatch the trace call - couldn't figure out how to get trait objects working for this case.
> 
> This has been tested with the following zeal settings:
> 
> GC after every allocation
> JS_GC_ZEAL=2,1
> 
> GC after every 100 allocations (important for catching use-after-free bugs)
> JS_GC_ZEAL=2,100
> 
> Verify pre barriers
> JS_GC_ZEAL=4,1
> 
> Verify post barriers
> JS_GC_ZEAL=11,1

<!-- Reviewable:start -->
[<img src="https://reviewable.io/review_button.png" height=40 alt="Review on Reviewable"/>](https://reviewable.io/reviews/servo/servo/6150)
<!-- Reviewable:end -->

1 files changed, 8 insertions, 22 deletions

diff --git a/components/script/dom/mod.rs b/components/script/dom/mod.rs
index 51ef5ca3c05..8aef70f6368 100644
--- a/components/script/dom/mod.rs
+++ b/components/script/dom/mod.rs
@@ -29,14 +29,12 @@
 //!
 //! For more information, see:
 //!
-//! * rooting pointers on the stack: the [`Root`](bindings/js/struct.Root.html)
-//!   and [`JSRef`](bindings/js/struct.JSRef.html) smart pointers;
+//! * rooting pointers on the stack:
+//!   the [`Root`](bindings/js/struct.Root.html) smart pointer;
 //! * tracing pointers in member fields: the [`JS`](bindings/js/struct.JS.html),
 //!   [`MutNullableJS`](bindings/js/struct.MutNullableJS.html) and
 //!   [`MutHeap`](bindings/js/struct.MutHeap.html) smart pointers and
 //!   [the tracing implementation](bindings/trace/index.html);
-//! * returning pointers from functions: the
-//!   [`Temporary`](bindings/js/struct.Temporary.html) smart pointer;
 //! * rooting pointers from across task boundaries or in channels: the
 //!   [`Trusted`](bindings/refcounted/struct.Trusted.html) smart pointer;
 //! * extracting pointers to DOM objects from their reflectors: the
@@ -62,7 +60,7 @@
 //! DOM objects of type `T` in Servo have two constructors:
 //!
 //! * a `T::new_inherited` static method that returns a plain `T`, and
-//! * a `T::new` static method that returns `Temporary<T>`.
+//! * a `T::new` static method that returns `Root<T>`.
 //!
 //! (The result of either method can be wrapped in `Result`, if that is
 //! appropriate for the type in question.)
@@ -111,6 +109,7 @@
 //! Implementing methods for a DOM object
 //! =====================================
 //!
+//! XXX JSRef no longer exists - should we remove the *Helpers traits?
 //! In order to ensure that DOM objects are rooted when they are called, we
 //! require that all methods are implemented for `JSRef<'a, Foo>`. This means
 //! that all methods are defined on traits. Conventionally, those traits are
@@ -121,24 +120,12 @@
 //! * `FooHelpers` for public methods;
 //! * `PrivateFooHelpers` for private methods.
 //!
-//! Calling methods on a DOM object
-//! ===============================
-//!
-//! To call a method on a DOM object, we require that the object is rooted, by
-//! calling `.root()` on a `Temporary` or `JS` pointer. This constructs a
-//! `Root` on the stack, which ensures the DOM object stays alive for the
-//! duration of its lifetime. A `JSRef` on which to call the method can then be
-//! obtained by calling the `r()` method on the `Root`.
-//!
 //! Accessing fields of a DOM object
 //! ================================
 //!
 //! All fields of DOM objects are private; accessing them from outside their
 //! module is done through explicit getter or setter methods.
 //!
-//! However, `JSRef<T>` dereferences to `&T`, so fields can be accessed on a
-//! `JSRef<T>` directly within the module that defines the struct.
-//!
 //! Inheritance and casting
 //! =======================
 //!
@@ -147,14 +134,13 @@
 //! to other types in the inheritance chain. For example:
 //!
 //! ```ignore
-//! # use script::dom::bindings::js::JSRef;
 //! # use script::dom::bindings::codegen::InheritTypes::{NodeCast, HTMLElementCast};
 //! # use script::dom::element::Element;
 //! # use script::dom::node::Node;
 //! # use script::dom::htmlelement::HTMLElement;
-//! fn f(element: JSRef<Element>) {
-//!     let base: JSRef<Node> = NodeCast::from_ref(element);
-//!     let derived: Option<JSRef<HTMLElement>> = HTMLElementCast::to_ref(element);
+//! fn f(element: &Element) {
+//!     let base: &Node = NodeCast::from_ref(element);
+//!     let derived: Option<&HTMLElement> = HTMLElementCast::to_ref(element);
 //! }
 //! ```
 //!
@@ -170,7 +156,7 @@
 //!   superclass or `Reflector` member, and other members as appropriate;
 //! * implementing the
 //!   `dom::bindings::codegen::Bindings::FooBindings::FooMethods` trait for
-//!   `JSRef<Foo>`.
+//!   `&'a Foo`.
 //!
 //! More information is available in the [bindings module](bindings/index.html).
 //!