Rename Reflectable to DomObject.

Fixes #8473.

components/plugins/lib.rs

@@ -35,7 +35,7 @@ use syntax::symbol::Symbol;
 /// Handles the auto-deriving for `#[derive(JSTraceable)]`
 pub mod jstraceable;
 pub mod lints;
-/// Autogenerates implementations of Reflectable on DOM structs
+/// Autogenerates implementations of DomObject on DOM structs
 pub mod reflector;
 /// Utilities for writing plugins
 mod utils;

components/plugins/reflector.rs

@@ -25,14 +25,14 @@ pub fn expand_reflector(cx: &mut ExtCtxt, span: Span, _: &MetaItem, annotatable:
                 Some(f) => {
                     let field_name = f.ident;
                     let impl_item = quote_item!(cx,
-                        impl ::dom::bindings::reflector::Reflectable for $struct_name {
+                        impl ::dom::bindings::reflector::DomObject for $struct_name {
                             fn reflector<'a>(&'a self) -> &'a ::dom::bindings::reflector::Reflector {
                                 &self.$field_name
                             }
                         }
                     );
                     let impl_item_mut = quote_item!(cx,
-                        impl ::dom::bindings::reflector::MutReflectable for $struct_name {
+                        impl ::dom::bindings::reflector::MutDomObject for $struct_name {
                             fn init_reflector(&mut self, obj: *mut ::js::jsapi::JSObject) {
                                 self.$field_name.set_jsobject(obj);
                             }
@@ -45,14 +45,14 @@ pub fn expand_reflector(cx: &mut ExtCtxt, span: Span, _: &MetaItem, annotatable:
                 None => {
                     let field_name = def.fields()[0].ident;
                     let impl_item = quote_item!(cx,
-                        impl ::dom::bindings::reflector::Reflectable for $struct_name {
+                        impl ::dom::bindings::reflector::DomObject for $struct_name {
                             fn reflector<'a>(&'a self) -> &'a ::dom::bindings::reflector::Reflector {
                                 self.$field_name.reflector()
                             }
                         }
                     );
                     let impl_item_mut = quote_item!(cx,
-                        impl ::dom::bindings::reflector::MutReflectable for $struct_name {
+                        impl ::dom::bindings::reflector::MutDomObject for $struct_name {
                             fn init_reflector(&mut self, obj: *mut ::js::jsapi::JSObject) {
                                 self.$field_name.init_reflector(obj);
                             }
@@ -69,7 +69,7 @@ pub fn expand_reflector(cx: &mut ExtCtxt, span: Span, _: &MetaItem, annotatable:
                     unsafe fn to_jsval(&self,
                                        cx: *mut ::js::jsapi::JSContext,
                                        rval: ::js::jsapi::MutableHandleValue) {
-                        let object = ::dom::bindings::reflector::Reflectable::reflector(self).get_jsobject();
+                        let object = ::dom::bindings::reflector::DomObject::reflector(self).get_jsobject();
                         object.to_jsval(cx, rval)
                     }
                 }

components/script/body.rs

@@ -5,7 +5,7 @@
 use dom::bindings::codegen::Bindings::FormDataBinding::FormDataMethods;
 use dom::bindings::error::{Error, Fallible};
 use dom::bindings::js::Root;
-use dom::bindings::reflector::Reflectable;
+use dom::bindings::reflector::DomObject;
 use dom::bindings::str::USVString;
 use dom::blob::{Blob, BlobImpl};
 use dom::formdata::FormData;
@@ -41,7 +41,7 @@ pub enum FetchedData {
 
 // https://fetch.spec.whatwg.org/#concept-body-consume-body
 #[allow(unrooted_must_root)]
-pub fn consume_body<T: BodyOperations + Reflectable>(object: &T, body_type: BodyType) -> Rc<Promise> {
+pub fn consume_body<T: BodyOperations + DomObject>(object: &T, body_type: BodyType) -> Rc<Promise> {
     let promise = Promise::new(&object.global());
 
     // Step 1
@@ -63,9 +63,9 @@ pub fn consume_body<T: BodyOperations + Reflectable>(object: &T, body_type: Body
 
 // https://fetch.spec.whatwg.org/#concept-body-consume-body
 #[allow(unrooted_must_root)]
-pub fn consume_body_with_promise<T: BodyOperations + Reflectable>(object: &T,
-                                                                  body_type: BodyType,
-                                                                  promise: &Promise) {
+pub fn consume_body_with_promise<T: BodyOperations + DomObject>(object: &T,
+                                                                body_type: BodyType,
+                                                                promise: &Promise) {
     // Step 5
     let body = match object.take_body() {
         Some(body) => body,
@@ -93,11 +93,11 @@ pub fn consume_body_with_promise<T: BodyOperations + Reflectable>(object: &T,
 
 // https://fetch.spec.whatwg.org/#concept-body-package-data
 #[allow(unsafe_code)]
-fn run_package_data_algorithm<T: BodyOperations + Reflectable>(object: &T,
-                                                               bytes: Vec<u8>,
-                                                               body_type: BodyType,
-                                                               mime_type: Ref<Vec<u8>>)
-                                                               -> Fallible<FetchedData> {
+fn run_package_data_algorithm<T: BodyOperations + DomObject>(object: &T,
+                                                             bytes: Vec<u8>,
+                                                             body_type: BodyType,
+                                                             mime_type: Ref<Vec<u8>>)
+                                                             -> Fallible<FetchedData> {
     let global = object.global();
     let cx = global.get_cx();
     let mime = &*mime_type;

components/script/devtools.rs

@@ -15,7 +15,7 @@ use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
 use dom::bindings::conversions::{ConversionResult, FromJSValConvertible, jsstring_to_str};
 use dom::bindings::inheritance::Castable;
 use dom::bindings::js::Root;
-use dom::bindings::reflector::Reflectable;
+use dom::bindings::reflector::DomObject;
 use dom::bindings::str::DOMString;
 use dom::document::AnimationFrameCallback;
 use dom::element::Element;

components/script/docs/JS-Servos-only-GC.md

@@ -181,7 +181,7 @@ pub fn trace_reflector(tracer: *mut JSTracer, description: &str, reflector: &Ref
     }
 }
 
-impl<T: Reflectable> JSTraceable for JS<T> {
+impl<T: DomObject> JSTraceable for JS<T> {
     unsafe fn trace(&self, trc: *mut JSTracer) {
         trace_reflector(trc, "", unsafe { (**self.ptr).reflector() });
     }

components/script/dom/abstractworker.rs

@@ -3,7 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::refcounted::Trusted;
-use dom::bindings::reflector::Reflectable;
+use dom::bindings::reflector::DomObject;
 use dom::bindings::structuredclone::StructuredCloneData;
 use js::jsapi::{JSRuntime, JS_RequestInterruptCallback};
 use js::rust::Runtime;
@@ -17,11 +17,11 @@ pub enum WorkerScriptMsg {
     DOMMessage(StructuredCloneData)
 }
 
-pub struct SimpleWorkerErrorHandler<T: Reflectable> {
+pub struct SimpleWorkerErrorHandler<T: DomObject> {
     pub addr: Trusted<T>,
 }
 
-impl<T: Reflectable> SimpleWorkerErrorHandler<T> {
+impl<T: DomObject> SimpleWorkerErrorHandler<T> {
     pub fn new(addr: Trusted<T>) -> SimpleWorkerErrorHandler<T> {
         SimpleWorkerErrorHandler {
             addr: addr

components/script/dom/abstractworkerglobalscope.rs

@@ -4,7 +4,7 @@
 
 use dom::abstractworker::WorkerScriptMsg;
 use dom::bindings::refcounted::Trusted;
-use dom::bindings::reflector::Reflectable;
+use dom::bindings::reflector::DomObject;
 use dom::bindings::trace::JSTraceable;
 use script_runtime::{ScriptChan, CommonScriptMsg, ScriptPort};
 use std::sync::mpsc::{Receiver, Sender};
@@ -13,12 +13,12 @@ use std::sync::mpsc::{Receiver, Sender};
 /// common event loop messages. While this SendableWorkerScriptChan is alive, the associated
 /// Worker object will remain alive.
 #[derive(JSTraceable, Clone)]
-pub struct SendableWorkerScriptChan<T: Reflectable> {
+pub struct SendableWorkerScriptChan<T: DomObject> {
     pub sender: Sender<(Trusted<T>, CommonScriptMsg)>,
     pub worker: Trusted<T>,
 }
 
-impl<T: JSTraceable + Reflectable + 'static> ScriptChan for SendableWorkerScriptChan<T> {
+impl<T: JSTraceable + DomObject + 'static> ScriptChan for SendableWorkerScriptChan<T> {
     fn send(&self, msg: CommonScriptMsg) -> Result<(), ()> {
         self.sender.send((self.worker.clone(), msg)).map_err(|_| ())
     }
@@ -35,12 +35,12 @@ impl<T: JSTraceable + Reflectable + 'static> ScriptChan for SendableWorkerScript
 /// worker event loop messages. While this SendableWorkerScriptChan is alive, the associated
 /// Worker object will remain alive.
 #[derive(JSTraceable, Clone)]
-pub struct WorkerThreadWorkerChan<T: Reflectable> {
+pub struct WorkerThreadWorkerChan<T: DomObject> {
     pub sender: Sender<(Trusted<T>, WorkerScriptMsg)>,
     pub worker: Trusted<T>,
 }
 
-impl<T: JSTraceable + Reflectable + 'static> ScriptChan for WorkerThreadWorkerChan<T> {
+impl<T: JSTraceable + DomObject + 'static> ScriptChan for WorkerThreadWorkerChan<T> {
     fn send(&self, msg: CommonScriptMsg) -> Result<(), ()> {
         self.sender
             .send((self.worker.clone(), WorkerScriptMsg::Common(msg)))
@@ -55,7 +55,7 @@ impl<T: JSTraceable + Reflectable + 'static> ScriptChan for WorkerThreadWorkerCh
     }
 }
 
-impl<T: Reflectable> ScriptPort for Receiver<(Trusted<T>, WorkerScriptMsg)> {
+impl<T: DomObject> ScriptPort for Receiver<(Trusted<T>, WorkerScriptMsg)> {
     fn recv(&self) -> Result<CommonScriptMsg, ()> {
         match self.recv().map(|(_, msg)| msg) {
             Ok(WorkerScriptMsg::Common(script_msg)) => Ok(script_msg),

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 @@ def getMethodImpls(self, method):
             })
         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 @@ def InheritTypes(config):
                    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,15 +418,15 @@ 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) })
 }
 
 /// 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,