Rename Reflectable to DomObject.

Fixes https://github.com/servo/servo/issues/8473.

components/script/dom/bindings/callback.rs

@@ -5,7 +5,7 @@
 //! Base classes to work with IDL callbacks.
 
 use dom::bindings::error::{Error, Fallible, report_pending_exception};
-use dom::bindings::reflector::Reflectable;
+use dom::bindings::reflector::DomObject;
 use dom::globalscope::GlobalScope;
 use js::jsapi::{Heap, MutableHandleObject, RootedObject};
 use js::jsapi::{IsCallable, JSContext, JSObject, JS_WrapObject};
@@ -132,9 +132,9 @@ impl CallbackInterface {
 }
 
 /// Wraps the reflector for `p` into the compartment of `cx`.
-pub fn wrap_call_this_object<T: Reflectable>(cx: *mut JSContext,
-                                             p: &T,
-                                             rval: MutableHandleObject) {
+pub fn wrap_call_this_object<T: DomObject>(cx: *mut JSContext,
+                                           p: &T,
+                                           rval: MutableHandleObject) {
     rval.set(p.reflector().get_jsobject().get());
     assert!(!rval.get().is_null());
 

components/script/dom/bindings/codegen/CodegenRust.py

@@ -5528,8 +5528,8 @@ def generate_imports(config, cgthings, descriptors, callbacks=None, dictionaries
         'dom::bindings::js::RootedReference',
         'dom::bindings::namespace::NamespaceObjectClass',
         'dom::bindings::namespace::create_namespace_object',
-        'dom::bindings::reflector::MutReflectable',
-        'dom::bindings::reflector::Reflectable',
+        'dom::bindings::reflector::MutDomObject',
+        'dom::bindings::reflector::DomObject',
         'dom::bindings::utils::DOMClass',
         'dom::bindings::utils::DOMJSClass',
         'dom::bindings::utils::DOM_PROTO_UNFORGEABLE_HOLDER_SLOT',
@@ -6294,7 +6294,7 @@ class CGCallback(CGClass):
             })
         return [ClassMethod(method.name + '_', method.returnType, args,
                             bodyInHeader=True,
-                            templateArgs=["T: Reflectable"],
+                            templateArgs=["T: DomObject"],
                             body=bodyWithThis,
                             visibility='pub'),
                 ClassMethod(method.name + '__', method.returnType, argsWithoutThis,
@@ -6917,7 +6917,7 @@ class GlobalGenRoots():
                    CGGeneric("use dom::bindings::inheritance::Castable;\n"),
                    CGGeneric("use dom::bindings::js::{JS, LayoutJS, Root};\n"),
                    CGGeneric("use dom::bindings::trace::JSTraceable;\n"),
-                   CGGeneric("use dom::bindings::reflector::Reflectable;\n"),
+                   CGGeneric("use dom::bindings::reflector::DomObject;\n"),
                    CGGeneric("use js::jsapi::JSTracer;\n\n"),
                    CGGeneric("use std::mem;\n\n")]
         allprotos = []

components/script/dom/bindings/conversions.rs

@@ -35,7 +35,7 @@
 use dom::bindings::inheritance::Castable;
 use dom::bindings::js::Root;
 use dom::bindings::num::Finite;
-use dom::bindings::reflector::{Reflectable, Reflector};
+use dom::bindings::reflector::{DomObject, Reflector};
 use dom::bindings::str::{ByteString, DOMString, USVString};
 use dom::bindings::utils::DOMClass;
 use js;
@@ -102,7 +102,7 @@ impl<T: Float + FromJSValConvertible<Config=()>> FromJSValConvertible for Finite
     }
 }
 
-impl <T: Reflectable + IDLInterface> FromJSValConvertible for Root<T> {
+impl <T: DomObject + IDLInterface> FromJSValConvertible for Root<T> {
     type Config = ();
 
     unsafe fn from_jsval(_cx: *mut JSContext,
@@ -404,7 +404,7 @@ pub unsafe fn private_from_proto_check<F>(mut obj: *mut JSObject,
 
 /// Get a `*const T` for a DOM object accessible from a `JSObject`.
 pub fn native_from_object<T>(obj: *mut JSObject) -> Result<*const T, ()>
-    where T: Reflectable + IDLInterface
+    where T: DomObject + IDLInterface
 {
     unsafe {
         private_from_proto_check(obj, T::derives).map(|ptr| ptr as *const T)
@@ -418,7 +418,7 @@ pub fn native_from_object<T>(obj: *mut JSObject) -> Result<*const T, ()>
 /// not a reflector for a DOM object of the given type (as defined by the
 /// proto_id and proto_depth).
 pub fn root_from_object<T>(obj: *mut JSObject) -> Result<Root<T>, ()>
-    where T: Reflectable + IDLInterface
+    where T: DomObject + IDLInterface
 {
     native_from_object(obj).map(|ptr| unsafe { Root::from_ref(&*ptr) })
 }
@@ -426,7 +426,7 @@ pub fn root_from_object<T>(obj: *mut JSObject) -> Result<Root<T>, ()>
 /// Get a `*const T` for a DOM object accessible from a `HandleValue`.
 /// Caller is responsible for throwing a JS exception if needed in case of error.
 pub fn native_from_handlevalue<T>(v: HandleValue) -> Result<*const T, ()>
-    where T: Reflectable + IDLInterface
+    where T: DomObject + IDLInterface
 {
     if !v.get().is_object() {
         return Err(());
@@ -437,7 +437,7 @@ pub fn native_from_handlevalue<T>(v: HandleValue) -> Result<*const T, ()>
 /// Get a `Root<T>` for a DOM object accessible from a `HandleValue`.
 /// Caller is responsible for throwing a JS exception if needed in case of error.
 pub fn root_from_handlevalue<T>(v: HandleValue) -> Result<Root<T>, ()>
-    where T: Reflectable + IDLInterface
+    where T: DomObject + IDLInterface
 {
     if !v.get().is_object() {
         return Err(());
@@ -447,12 +447,12 @@ pub fn root_from_handlevalue<T>(v: HandleValue) -> Result<Root<T>, ()>
 
 /// Get a `Root<T>` for a DOM object accessible from a `HandleObject`.
 pub fn root_from_handleobject<T>(obj: HandleObject) -> Result<Root<T>, ()>
-    where T: Reflectable + IDLInterface
+    where T: DomObject + IDLInterface
 {
     root_from_object(obj.get())
 }
 
-impl<T: Reflectable> ToJSValConvertible for Root<T> {
+impl<T: DomObject> ToJSValConvertible for Root<T> {
     unsafe fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue) {
         self.reflector().to_jsval(cx, rval);
     }

components/script/dom/bindings/inheritance.rs

@@ -8,12 +8,12 @@ pub use dom::bindings::codegen::InheritTypes::*;
 
 use dom::bindings::conversions::{DerivedFrom, IDLInterface};
 use dom::bindings::conversions::get_dom_class;
-use dom::bindings::reflector::Reflectable;
+use dom::bindings::reflector::DomObject;
 use std::mem;
 
 /// A trait to hold the cast functions of IDL interfaces that either derive
 /// or are derived from other interfaces.
-pub trait Castable: IDLInterface + Reflectable + Sized {
+pub trait Castable: IDLInterface + DomObject + Sized {
     /// Check whether a DOM object implements one of its deriving interfaces.
     fn is<T>(&self) -> bool
         where T: DerivedFrom<Self>

components/script/dom/bindings/iterable.rs

@@ -11,7 +11,7 @@ use dom::bindings::codegen::Bindings::IterableIteratorBinding::IterableKeyAndVal
 use dom::bindings::codegen::Bindings::IterableIteratorBinding::IterableKeyOrValueResult;
 use dom::bindings::error::Fallible;
 use dom::bindings::js::{JS, Root};
-use dom::bindings::reflector::{Reflector, Reflectable, MutReflectable, reflect_dom_object};
+use dom::bindings::reflector::{Reflector, DomObject, MutDomObject, reflect_dom_object};
 use dom::bindings::trace::JSTraceable;
 use dom::globalscope::GlobalScope;
 use js::conversions::ToJSValConvertible;
@@ -52,36 +52,36 @@ pub trait Iterable {
 #[privatize]
 #[derive(JSTraceable)]
 #[derive(HeapSizeOf)]
-pub struct IterableIterator<T: Reflectable + JSTraceable + Iterable> {
+pub struct IterableIterator<T: DomObject + JSTraceable + Iterable> {
     reflector: Reflector,
     iterable: JS<T>,
     type_: IteratorType,
     index: Cell<u32>,
 }
 
-impl<T: Reflectable + JSTraceable + Iterable> Reflectable for IterableIterator<T> {
+impl<T: DomObject + JSTraceable + Iterable> DomObject for IterableIterator<T> {
     fn reflector<'a>(&'a self) -> &'a Reflector {
         &self.reflector
     }
 }
 
-impl<T: Reflectable + JSTraceable + Iterable> MutReflectable for IterableIterator<T> {
+impl<T: DomObject + JSTraceable + Iterable> MutDomObject for IterableIterator<T> {
     fn init_reflector(&mut self, obj: *mut JSObject) {
         self.reflector.set_jsobject(obj);
     }
 }
 
-impl<T: Reflectable + JSTraceable + Iterable> ToJSValConvertible for IterableIterator<T> {
+impl<T: DomObject + JSTraceable + Iterable> ToJSValConvertible for IterableIterator<T> {
     #[allow(unsafe_code)]
     unsafe fn to_jsval(&self,
                        cx: *mut JSContext,
                        rval: MutableHandleValue) {
-        let object = Reflectable::reflector(self).get_jsobject();
+        let object = DomObject::reflector(self).get_jsobject();
         object.to_jsval(cx, rval)
     }
 }
 
-impl<T: Reflectable + JSTraceable + Iterable> IterableIterator<T> {
+impl<T: DomObject + JSTraceable + Iterable> IterableIterator<T> {
     /// Create a new iterator instance for the provided iterable DOM interface.
     pub fn new(iterable: &T,
                type_: IteratorType,

components/script/dom/bindings/js.rs

@@ -26,7 +26,7 @@
 use core::nonzero::NonZero;
 use dom::bindings::conversions::DerivedFrom;
 use dom::bindings::inheritance::Castable;
-use dom::bindings::reflector::{Reflectable, Reflector};
+use dom::bindings::reflector::{DomObject, Reflector};
 use dom::bindings::trace::JSTraceable;
 use dom::bindings::trace::trace_reflector;
 use dom::node::Node;
@@ -76,7 +76,7 @@ impl<T> JS<T> {
     }
 }
 
-impl<T: Reflectable> JS<T> {
+impl<T: DomObject> JS<T> {
     /// Create a JS<T> from a &T
     #[allow(unrooted_must_root)]
     pub fn from_ref(obj: &T) -> JS<T> {
@@ -87,14 +87,14 @@ impl<T: Reflectable> JS<T> {
     }
 }
 
-impl<'root, T: Reflectable + 'root> RootedReference<'root> for JS<T> {
+impl<'root, T: DomObject + 'root> RootedReference<'root> for JS<T> {
     type Ref = &'root T;
     fn r(&'root self) -> &'root T {
         &self
     }
 }
 
-impl<T: Reflectable> Deref for JS<T> {
+impl<T: DomObject> Deref for JS<T> {
     type Target = T;
 
     fn deref(&self) -> &T {
@@ -105,7 +105,7 @@ impl<T: Reflectable> Deref for JS<T> {
     }
 }
 
-unsafe impl<T: Reflectable> JSTraceable for JS<T> {
+unsafe impl<T: DomObject> JSTraceable for JS<T> {
     unsafe fn trace(&self, trc: *mut JSTracer) {
         #[cfg(debug_assertions)]
         let trace_str = format!("for {} on heap", type_name::<T>());
@@ -158,7 +158,7 @@ impl<T: Castable> LayoutJS<T> {
     }
 }
 
-impl<T: Reflectable> LayoutJS<T> {
+impl<T: DomObject> LayoutJS<T> {
     /// Get the reflector.
     pub unsafe fn get_jsobject(&self) -> *mut JSObject {
         debug_assert!(thread_state::get().is_layout());
@@ -240,7 +240,7 @@ pub trait HeapGCValue: JSTraceable {
 impl HeapGCValue for Heap<JSVal> {
 }
 
-impl<T: Reflectable> HeapGCValue for JS<T> {
+impl<T: DomObject> HeapGCValue for JS<T> {
 }
 
 /// A holder that provides interior mutability for GC-managed JSVals.
@@ -297,7 +297,7 @@ pub struct MutHeap<T: HeapGCValue> {
     val: UnsafeCell<T>,
 }
 
-impl<T: Reflectable> MutHeap<JS<T>> {
+impl<T: DomObject> MutHeap<JS<T>> {
     /// Create a new `MutHeap`.
     pub fn new(initial: &T) -> MutHeap<JS<T>> {
         debug_assert!(thread_state::get().is_script());
@@ -330,7 +330,7 @@ impl<T: HeapGCValue> HeapSizeOf for MutHeap<T> {
     }
 }
 
-impl<T: Reflectable> PartialEq for MutHeap<JS<T>> {
+impl<T: DomObject> PartialEq for MutHeap<JS<T>> {
    fn eq(&self, other: &Self) -> bool {
         unsafe {
             *self.val.get() == *other.val.get()
@@ -338,7 +338,7 @@ impl<T: Reflectable> PartialEq for MutHeap<JS<T>> {
     }
 }
 
-impl<T: Reflectable + PartialEq> PartialEq<T> for MutHeap<JS<T>> {
+impl<T: DomObject + PartialEq> PartialEq<T> for MutHeap<JS<T>> {
     fn eq(&self, other: &T) -> bool {
         unsafe {
             **self.val.get() == *other
@@ -358,7 +358,7 @@ pub struct MutNullableHeap<T: HeapGCValue> {
     ptr: UnsafeCell<Option<T>>,
 }
 
-impl<T: Reflectable> MutNullableHeap<JS<T>> {
+impl<T: DomObject> MutNullableHeap<JS<T>> {
     /// Create a new `MutNullableHeap`.
     pub fn new(initial: Option<&T>) -> MutNullableHeap<JS<T>> {
         debug_assert!(thread_state::get().is_script());
@@ -416,7 +416,7 @@ impl<T: Reflectable> MutNullableHeap<JS<T>> {
     }
 }
 
-impl<T: Reflectable> PartialEq for MutNullableHeap<JS<T>> {
+impl<T: DomObject> PartialEq for MutNullableHeap<JS<T>> {
     fn eq(&self, other: &Self) -> bool {
         unsafe {
             *self.ptr.get() == *other.ptr.get()
@@ -424,7 +424,7 @@ impl<T: Reflectable> PartialEq for MutNullableHeap<JS<T>> {
     }
 }
 
-impl<'a, T: Reflectable> PartialEq<Option<&'a T>> for MutNullableHeap<JS<T>> {
+impl<'a, T: DomObject> PartialEq<Option<&'a T>> for MutNullableHeap<JS<T>> {
     fn eq(&self, other: &Option<&T>) -> bool {
         unsafe {
             *self.ptr.get() == other.map(JS::from_ref)
@@ -449,7 +449,7 @@ impl<T: HeapGCValue> HeapSizeOf for MutNullableHeap<T> {
     }
 }
 
-impl<T: Reflectable> LayoutJS<T> {
+impl<T: DomObject> LayoutJS<T> {
     /// Returns an unsafe pointer to the interior of this JS object. This is
     /// the only method that be safely accessed from layout. (The fact that
     /// this is unsafe is what necessitates the layout wrappers.)
@@ -475,14 +475,14 @@ pub trait RootedReference<'root> {
     fn r(&'root self) -> Self::Ref;
 }
 
-impl<'root, T: JSTraceable + Reflectable + 'root> RootedReference<'root> for [JS<T>] {
+impl<'root, T: JSTraceable + DomObject + 'root> RootedReference<'root> for [JS<T>] {
     type Ref = &'root [&'root T];
     fn r(&'root self) -> &'root [&'root T] {
         unsafe { mem::transmute(self) }
     }
 }
 
-impl<'root, T: Reflectable + 'root> RootedReference<'root> for Rc<T> {
+impl<'root, T: DomObject + 'root> RootedReference<'root> for Rc<T> {
     type Ref = &'root T;
     fn r(&'root self) -> &'root T {
         self
@@ -566,7 +566,7 @@ pub unsafe fn trace_roots(tracer: *mut JSTracer) {
 /// for the same JS value. `Root`s cannot outlive the associated
 /// `RootCollection` object.
 #[allow_unrooted_interior]
-pub struct Root<T: Reflectable> {
+pub struct Root<T: DomObject> {
     /// Reference to rooted value that must not outlive this container
     ptr: NonZero<*const T>,
     /// List that ensures correct dynamic root ordering
@@ -594,7 +594,7 @@ impl<T: Castable> Root<T> {
     }
 }
 
-impl<T: Reflectable> Root<T> {
+impl<T: DomObject> Root<T> {
     /// Create a new stack-bounded root for the provided JS-owned value.
     /// It cannot outlive its associated `RootCollection`, and it gives
     /// out references which cannot outlive this new `Root`.
@@ -616,14 +616,14 @@ impl<T: Reflectable> Root<T> {
     }
 }
 
-impl<'root, T: Reflectable + 'root> RootedReference<'root> for Root<T> {
+impl<'root, T: DomObject + 'root> RootedReference<'root> for Root<T> {
     type Ref = &'root T;
     fn r(&'root self) -> &'root T {
         self
     }
 }
 
-impl<T: Reflectable> Deref for Root<T> {
+impl<T: DomObject> Deref for Root<T> {
     type Target = T;
     fn deref(&self) -> &T {
         debug_assert!(thread_state::get().is_script());
@@ -631,25 +631,25 @@ impl<T: Reflectable> Deref for Root<T> {
     }
 }
 
-impl<T: Reflectable + HeapSizeOf> HeapSizeOf for Root<T> {
+impl<T: DomObject + HeapSizeOf> HeapSizeOf for Root<T> {
     fn heap_size_of_children(&self) -> usize {
         (**self).heap_size_of_children()
     }
 }
 
-impl<T: Reflectable> PartialEq for Root<T> {
+impl<T: DomObject> PartialEq for Root<T> {
     fn eq(&self, other: &Self) -> bool {
         self.ptr == other.ptr
     }
 }
 
-impl<T: Reflectable> Clone for Root<T> {
+impl<T: DomObject> Clone for Root<T> {
     fn clone(&self) -> Root<T> {
         Root::from_ref(&*self)
     }
 }
 
-impl<T: Reflectable> Drop for Root<T> {
+impl<T: DomObject> Drop for Root<T> {
     fn drop(&mut self) {
         unsafe {
             (*self.root_list).unroot(self.reflector());

components/script/dom/bindings/refcounted.rs

@@ -24,7 +24,7 @@
 
 use core::nonzero::NonZero;
 use dom::bindings::js::Root;
-use dom::bindings::reflector::{Reflectable, Reflector};
+use dom::bindings::reflector::{DomObject, Reflector};
 use dom::bindings::trace::trace_reflector;
 use dom::promise::Promise;
 use js::jsapi::JSTracer;
@@ -55,7 +55,7 @@ pub struct TrustedReference(*const libc::c_void);
 unsafe impl Send for TrustedReference {}
 
 impl TrustedReference {
-    fn new<T: Reflectable>(ptr: *const T) -> TrustedReference {
+    fn new<T: DomObject>(ptr: *const T) -> TrustedReference {
         TrustedReference(ptr as *const libc::c_void)
     }
 }
@@ -122,7 +122,7 @@ impl TrustedPromise {
 /// DOM object is guaranteed to live at least as long as the last outstanding
 /// `Trusted<T>` instance.
 #[allow_unrooted_interior]
-pub struct Trusted<T: Reflectable> {
+pub struct Trusted<T: DomObject> {
     /// A pointer to the Rust DOM object of type T, but void to allow
     /// sending `Trusted<T>` between threads, regardless of T's sendability.
     refcount: Arc<TrustedReference>,
@@ -130,9 +130,9 @@ pub struct Trusted<T: Reflectable> {
     phantom: PhantomData<T>,
 }
 
-unsafe impl<T: Reflectable> Send for Trusted<T> {}
+unsafe impl<T: DomObject> Send for Trusted<T> {}
 
-impl<T: Reflectable> Trusted<T> {
+impl<T: DomObject> Trusted<T> {
     /// Create a new `Trusted<T>` instance from an existing DOM pointer. The DOM object will
     /// be prevented from being GCed for the duration of the resulting `Trusted<T>` object's
     /// lifetime.
@@ -164,7 +164,7 @@ impl<T: Reflectable> Trusted<T> {
     }
 }
 
-impl<T: Reflectable> Clone for Trusted<T> {
+impl<T: DomObject> Clone for Trusted<T> {
     fn clone(&self) -> Trusted<T> {
         Trusted {
             refcount: self.refcount.clone(),
@@ -200,7 +200,7 @@ impl LiveDOMReferences {
         table.entry(&*promise).or_insert(vec![]).push(promise)
     }
 
-    fn addref<T: Reflectable>(&self, ptr: *const T) -> Arc<TrustedReference> {
+    fn addref<T: DomObject>(&self, ptr: *const T) -> Arc<TrustedReference> {
         let mut table = self.reflectable_table.borrow_mut();
         let capacity = table.capacity();
         let len = table.len();

components/script/dom/bindings/reflector.rs

@@ -18,7 +18,7 @@ pub fn reflect_dom_object<T, U>(
         global: &U,
         wrap_fn: unsafe fn(*mut JSContext, &GlobalScope, Box<T>) -> Root<T>)
         -> Root<T>
-    where T: Reflectable, U: DerivedFrom<GlobalScope>
+    where T: DomObject, U: DerivedFrom<GlobalScope>
 {
     let global_scope = global.upcast();
     unsafe {
@@ -77,18 +77,18 @@ impl Reflector {
 }
 
 /// A trait to provide access to the `Reflector` for a DOM object.
-pub trait Reflectable {
+pub trait DomObject {
     /// Returns the receiver's reflector.
     fn reflector(&self) -> &Reflector;
 
-    /// Returns the global scope of the realm that the Reflectable was created in.
+    /// Returns the global scope of the realm that the DomObject was created in.
     fn global(&self) -> Root<GlobalScope> where Self: Sized {
         GlobalScope::from_reflector(self)
     }
 }
 
 /// A trait to initialize the `Reflector` for a DOM object.
-pub trait MutReflectable: Reflectable {
+pub trait MutDomObject: DomObject {
     /// Initializes the Reflector
     fn init_reflector(&mut self, obj: *mut JSObject);
 }

components/script/dom/bindings/trace.rs

@@ -38,7 +38,7 @@ use dom::abstractworker::SharedRt;
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::js::{JS, Root};
 use dom::bindings::refcounted::{Trusted, TrustedPromise};
-use dom::bindings::reflector::{Reflectable, Reflector};
+use dom::bindings::reflector::{DomObject, Reflector};
 use dom::bindings::str::{DOMString, USVString};
 use dom::bindings::utils::WindowProxyHandler;
 use dom::document::PendingRestyle;
@@ -426,7 +426,7 @@ unsafe impl<T> JSTraceable for IpcReceiver<T> where T: Deserialize + Serialize {
     }
 }
 
-unsafe impl<T: Reflectable> JSTraceable for Trusted<T> {
+unsafe impl<T: DomObject> JSTraceable for Trusted<T> {
     #[inline]
     unsafe fn trace(&self, _: *mut JSTracer) {
         // Do nothing
@@ -635,9 +635,9 @@ impl RootedTraceableSet {
 
 /// Roots any JSTraceable thing
 ///
-/// If you have a valid Reflectable, use Root.
+/// If you have a valid DomObject, use Root.
 /// If you have GC things like *mut JSObject or JSVal, use rooted!.
-/// If you have an arbitrary number of Reflectables to root, use rooted_vec!.
+/// If you have an arbitrary number of DomObjects to root, use rooted_vec!.
 /// If you know what you're doing, use this.
 #[derive(JSTraceable)]
 pub struct RootedTraceable<'a, T: 'a + JSTraceable> {
@@ -690,7 +690,7 @@ pub struct RootedVec<'a, T: 'a + JSTraceable> {
     root: &'a mut RootableVec<T>,
 }
 
-impl<'a, T: JSTraceable + Reflectable> RootedVec<'a, JS<T>> {
+impl<'a, T: JSTraceable + DomObject> RootedVec<'a, JS<T>> {
     /// Create a vector of items of type T that is rooted for
     /// the lifetime of this struct
     pub fn new<I: Iterator<Item = Root<T>>>(root: &'a mut RootableVec<JS<T>>, iter: I)

components/script/dom/bindings/weakref.rs

@@ -13,7 +13,7 @@
 
 use core::nonzero::NonZero;
 use dom::bindings::js::Root;
-use dom::bindings::reflector::Reflectable;
+use dom::bindings::reflector::DomObject;
 use dom::bindings::trace::JSTraceable;
 use heapsize::HeapSizeOf;
 use js::jsapi::{JSTracer, JS_GetReservedSlot, JS_SetReservedSlot};
@@ -46,7 +46,7 @@ pub struct WeakBox<T: WeakReferenceable> {
 }
 
 /// Trait implemented by weak-referenceable interfaces.
-pub trait WeakReferenceable: Reflectable + Sized {
+pub trait WeakReferenceable: DomObject + Sized {
     /// Downgrade a DOM object reference to a weak one.
     fn downgrade(&self) -> WeakRef<Self> {
         unsafe {