From c77d3b965f6099ffcb2eddc359948f106afca7b5 Mon Sep 17 00:00:00 2001
From: Anthony Ramine <n.oxyde@gmail.com>
Date: Tue, 6 Oct 2015 02:59:38 +0200
Subject: [PATCH 1/5] Introduce IDLInterface::derives()

This method is given a DOMClass value and returns whether it derives from Self.

Interfaces with no descendants directly check whether the given DOMClass is the
same as their own.
---
 .../dom/bindings/codegen/CodegenRust.py       | 45 +++++++++----------
 components/script/dom/bindings/conversions.rs | 24 ++++------
 components/script/dom/bindings/utils.rs       |  7 ++-
 3 files changed, 35 insertions(+), 41 deletions(-)

diff --git a/components/script/dom/bindings/codegen/CodegenRust.py b/components/script/dom/bindings/codegen/CodegenRust.py
index c71e0f354dc..13a3cd51a1b 100644
--- a/components/script/dom/bindings/codegen/CodegenRust.py
+++ b/components/script/dom/bindings/codegen/CodegenRust.py
@@ -2246,20 +2246,24 @@ class CGIDLInterface(CGThing):
         self.descriptor = descriptor
 
     def define(self):
-        replacer = {
-            'type': self.descriptor.name,
-            'depth': self.descriptor.interface.inheritanceDepth(),
-        }
-        return string.Template("""\
-impl IDLInterface for ${type} {
-    fn get_prototype_id() -> PrototypeList::ID {
-        PrototypeList::ID::${type}
-    }
-    fn get_prototype_depth() -> usize {
-        ${depth}
+        interface = self.descriptor.interface
+        name = self.descriptor.name
+        if (interface.getUserData("hasConcreteDescendant", False) or
+                interface.getUserData("hasProxyDescendant", False)):
+            depth = len(self.descriptor.prototypeChain)
+            check = "class.interface_chain[%s] == PrototypeList::ID::%s" % (depth - 1, name)
+        elif self.descriptor.proxy:
+            check = "class as *const _ == &Class as *const _"
+        else:
+            check = "class as *const _ == &Class.dom_class as *const _"
+        return """\
+impl IDLInterface for %(name)s {
+    #[inline]
+    fn derives(class: &'static DOMClass) -> bool {
+        %(check)s
     }
 }
-""").substitute(replacer)
+""" % {'check': check, 'name': name}
 
 
 class CGAbstractExternMethod(CGAbstractMethod):
@@ -5820,7 +5824,7 @@ class GlobalGenRoots():
 
         descriptors = config.getDescriptors(register=True, isCallback=False)
         imports = [CGGeneric("use dom::types::*;\n"),
-                   CGGeneric("use dom::bindings::conversions::get_dom_class;\n"),
+                   CGGeneric("use dom::bindings::conversions::{IDLInterface, get_dom_class};\n"),
                    CGGeneric("use dom::bindings::js::{JS, LayoutJS, Root};\n"),
                    CGGeneric("use dom::bindings::trace::JSTraceable;\n"),
                    CGGeneric("use dom::bindings::utils::Reflectable;\n"),
@@ -5886,18 +5890,11 @@ impl %(name)sCast {
                 # Define a `FooDerived` trait for superclasses to implement,
                 # as well as the `FooCast::to_*` methods that use it.
                 baseName = descriptor.prototypeChain[0]
-                typeIdPat = descriptor.prototypeChain[-1]
-                if upcast:
-                    typeIdPat += "(_)"
-                for base in reversed(descriptor.prototypeChain[1:-1]):
-                    typeIdPat = "%s(%sTypeId::%s)" % (base, base, typeIdPat)
-                typeIdPat = "%sTypeId::%s" % (baseName, typeIdPat)
                 args = {
                     'baseName': baseName,
                     'derivedTrait': name + 'Derived',
                     'methodName': 'is_' + name.lower(),
                     'name': name,
-                    'typeIdPat': typeIdPat,
                 }
                 allprotos.append(CGGeneric("""\
 /// Types which `%(name)s` derives from
@@ -5938,10 +5935,10 @@ impl %(name)sCast {
 
 impl %(derivedTrait)s for %(baseName)s {
     fn %(methodName)s(&self) -> bool {
-        match *self.type_id() {
-            %(typeIdPat)s => true,
-            _ => false,
-        }
+        let dom_class = unsafe {
+            get_dom_class(self.reflector().get_jsobject().get()).unwrap()
+        };
+        %(name)s::derives(dom_class)
     }
 }
 
diff --git a/components/script/dom/bindings/conversions.rs b/components/script/dom/bindings/conversions.rs
index eb9c1c81305..593c5458452 100644
--- a/components/script/dom/bindings/conversions.rs
+++ b/components/script/dom/bindings/conversions.rs
@@ -33,7 +33,6 @@
 //! | union types             | `T`                              |
 
 use core::nonzero::NonZero;
-use dom::bindings::codegen::PrototypeList;
 use dom::bindings::error::throw_type_error;
 use dom::bindings::js::Root;
 use dom::bindings::num::Finite;
@@ -101,14 +100,10 @@ impl_as!(u32, u32);
 impl_as!(i64, i64);
 impl_as!(u64, u64);
 
-/// A trait to retrieve the constants necessary to check if a `JSObject`
-/// implements a given interface.
+/// A trait to check whether a given `JSObject` implements an IDL interface.
 pub trait IDLInterface {
-    /// Returns the prototype ID.
-    fn get_prototype_id() -> PrototypeList::ID;
-    /// Returns the prototype depth, i.e., the number of interfaces this
-    /// interface inherits from.
-    fn get_prototype_depth() -> usize;
+    /// Returns whether the given DOM class derives that interface.
+    fn derives(&'static DOMClass) -> bool;
 }
 
 /// A trait to convert Rust types to `JSVal`s.
@@ -696,9 +691,10 @@ pub unsafe fn get_dom_class(obj: *mut JSObject) -> Result<&'static DOMClass, ()>
 /// Returns Err(()) if `obj` is an opaque security wrapper or if the object is
 /// not an object for a DOM object of the given type (as defined by the
 /// proto_id and proto_depth).
-pub unsafe fn private_from_proto_chain(mut obj: *mut JSObject,
-                                       proto_id: u16, proto_depth: u16)
-                                       -> Result<*const libc::c_void, ()> {
+#[inline]
+pub unsafe fn private_from_proto_check<F>(mut obj: *mut JSObject, proto_check: F)
+                                          -> Result<*const libc::c_void, ()>
+                                          where F: Fn(&'static DOMClass) -> bool {
     let dom_class = try!(get_dom_class(obj).or_else(|_| {
         if IsWrapper(obj) {
             debug!("found wrapper");
@@ -717,7 +713,7 @@ pub unsafe fn private_from_proto_chain(mut obj: *mut JSObject,
         }
     }));
 
-    if dom_class.interface_chain[proto_depth as usize] as u16 == proto_id {
+    if proto_check(dom_class) {
         debug!("good prototype");
         Ok(private_from_reflector(obj))
     } else {
@@ -735,10 +731,8 @@ pub unsafe fn private_from_proto_chain(mut obj: *mut JSObject,
 pub fn native_from_reflector_jsmanaged<T>(obj: *mut JSObject) -> Result<Root<T>, ()>
     where T: Reflectable + IDLInterface
 {
-    let proto_id = <T as IDLInterface>::get_prototype_id() as u16;
-    let proto_depth = <T as IDLInterface>::get_prototype_depth() as u16;
     unsafe {
-        private_from_proto_chain(obj, proto_id, proto_depth).map(|obj| {
+        private_from_proto_check(obj, T::derives).map(|obj| {
             Root::new(NonZero::new(obj as *const T))
         })
     }
diff --git a/components/script/dom/bindings/utils.rs b/components/script/dom/bindings/utils.rs
index af028ebfcbc..4b4e6cfea93 100644
--- a/components/script/dom/bindings/utils.rs
+++ b/components/script/dom/bindings/utils.rs
@@ -8,7 +8,7 @@ use dom::bindings::codegen::InheritTypes::TopTypeId;
 use dom::bindings::codegen::PrototypeList;
 use dom::bindings::codegen::PrototypeList::MAX_PROTO_CHAIN_LENGTH;
 use dom::bindings::conversions::native_from_handleobject;
-use dom::bindings::conversions::private_from_proto_chain;
+use dom::bindings::conversions::private_from_proto_check;
 use dom::bindings::conversions::{is_dom_class, jsstring_to_str};
 use dom::bindings::error::throw_type_error;
 use dom::bindings::error::{Error, ErrorResult, Fallible, throw_invalid_this};
@@ -755,7 +755,10 @@ unsafe fn generic_call(cx: *mut JSContext, argc: libc::c_uint, vp: *mut JSVal,
     let info = RUST_FUNCTION_VALUE_TO_JITINFO(JS_CALLEE(cx, vp));
     let proto_id = (*info).protoID;
     let depth = (*info).depth;
-    let this = match private_from_proto_chain(obj.ptr, proto_id, depth) {
+    let proto_check = |class: &'static DOMClass| {
+        class.interface_chain[depth as usize] as u16 == proto_id
+    };
+    let this = match private_from_proto_check(obj.ptr, proto_check) {
         Ok(val) => val,
         Err(()) => {
             if is_lenient {

From bd363b009db8e5e233cd862aef5c8d497495a10e Mon Sep 17 00:00:00 2001
From: Anthony Ramine <n.oxyde@gmail.com>
Date: Thu, 8 Oct 2015 02:22:27 +0200
Subject: [PATCH 2/5] Make test-tidy ignore braces surrounded by backticks

---
 python/tidy.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/python/tidy.py b/python/tidy.py
index 0fac94240c7..b0c61dba333 100644
--- a/python/tidy.py
+++ b/python/tidy.py
@@ -305,13 +305,13 @@ def check_rust(file_name, contents):
         if match:
             yield (idx + 1, "missing space before {")
 
-        # ignored cases like {} and }}
-        match = re.search(r"[^\s{}]}", line)
+        # ignored cases like {}, }` and }}
+        match = re.search(r"[^\s{}]}[^`]", line)
         if match and not (line.startswith("use") or line.startswith("pub use")):
             yield (idx + 1, "missing space before }")
 
-        # ignored cases like {} and {{
-        match = re.search(r"{[^\s{}]", line)
+        # ignored cases like {}, `{ and {{
+        match = re.search(r"[^`]{[^\s{}]", line)
         if match and not (line.startswith("use") or line.startswith("pub use")):
             yield (idx + 1, "missing space after {")
 

From 13ea3ac413c511872784ccde416956217746553c Mon Sep 17 00:00:00 2001
From: Anthony Ramine <n.oxyde@gmail.com>
Date: Tue, 6 Oct 2015 17:21:44 +0200
Subject: [PATCH 3/5] Introduce trait Castable

This trait is used to hold onto the downcast and upcast functions of all
castable IDL interfaces. A castable IDL interface is one which either derives
from or is derived by other interfaces.

The deriving relation is represented by implementations of marker trait
DerivedFrom<T: Castable> generated in InheritTypes.

/^[ ]*use dom::bindings::codegen::InheritTypes::.*(Base|Cast|Derived)/ {
    /::[a-zA-Z]+(Base|Cast|Derived);/d
    s/([{ ])[a-zA-Z]+(Base|Cast|Derived), /\1/g
    s/([{ ])[a-zA-Z]+(Base|Cast|Derived), /\1/g
    s/, [a-zA-Z]+(Base|Cast|Derived)([},])/\2/g
    s/, [a-zA-Z]+(Base|Cast|Derived)([},])/\2/g
    /\{([a-zA-Z]+(Base|Cast|Derived))?\};$/d
    s/\{([a-zA-Z_]+)\};$/\1;/
}

s/([a-zA-Z]+)Cast::from_ref\(\&?\**([a-zA-Z_]+)(\.r\(\))?\)/\2.upcast::<\1>()/g
s/([a-zA-Z]+)Cast::from_ref\(\&?\**([a-zA-Z_]+)(\.[a-zA-Z_]+\(\))?\)/\2\3.upcast::<\1>()/g
s/\(([a-zA-Z]+)Cast::from_ref\)/\(Castable::upcast::<\1>\)/g

s/([a-zA-Z]+)Cast::from_root/Root::upcast::<\1>/g

s/([a-zA-Z]+)Cast::from_layout_js\(\&([a-zA-Z_.]+)\)/\2.upcast::<\1>()/g

s/([a-zA-Z]+)Cast::to_ref\(\&?\**([a-zA-Z_]+)(\.r\(\))?\)/\2.downcast::<\1>()/g
s/([a-zA-Z]+)Cast::to_ref\(\&?\**([a-zA-Z_]+)(\.[a-zA-Z_]+\(\))?\)/\2\3.downcast::<\1>()/g
s/\(([a-zA-Z]+)Cast::to_ref\)/\(Castable::downcast::<\1>\)/g

s/([a-zA-Z]+)Cast::to_root/Root::downcast::<\1>/g

s/([a-zA-Z]+)Cast::to_layout_js\(&?([a-zA-Z_.]+(\(\))?)\)/\2.downcast::<\1>()/g

s/\.is_document\(\)/.is::<Document>()/g
s/\.is_htmlanchorelement\(\)/.is::<HTMLAnchorElement>()/g
s/\.is_htmlappletelement\(\)/.is::<HTMLAppletElement>()/g
s/\.is_htmlareaelement\(\)/.is::<HTMLAreaElement>()/g
s/\.is_htmlbodyelement\(\)/.is::<HTMLBodyElement>()/g
s/\.is_htmlembedelement\(\)/.is::<HTMLEmbedElement>()/g
s/\.is_htmlfieldsetelement\(\)/.is::<HTMLFieldSetElement>()/g
s/\.is_htmlformelement\(\)/.is::<HTMLFormElement>()/g
s/\.is_htmlframesetelement\(\)/.is::<HTMLFrameSetElement>()/g
s/\.is_htmlhtmlelement\(\)/.is::<HTMLHtmlElement>()/g
s/\.is_htmlimageelement\(\)/.is::<HTMLImageElement>()/g
s/\.is_htmllegendelement\(\)/.is::<HTMLLegendElement>()/g
s/\.is_htmloptgroupelement\(\)/.is::<HTMLOptGroupElement>()/g
s/\.is_htmloptionelement\(\)/.is::<HTMLOptionElement>()/g
s/\.is_htmlscriptelement\(\)/.is::<HTMLScriptElement>()/g
s/\.is_htmltabledatacellelement\(\)/.is::<HTMLTableDataCellElement>()/g
s/\.is_htmltableheadercellelement\(\)/.is::<HTMLTableHeaderCellElement>()/g
s/\.is_htmltablerowelement\(\)/.is::<HTMLTableRowElement>()/g
s/\.is_htmltablesectionelement\(\)/.is::<HTMLTableSectionElement>()/g
s/\.is_htmltitleelement\(\)/.is::<HTMLTitleElement>()/g
---
 components/layout/wrapper.rs                  |  58 ++--
 components/script/devtools.rs                 |  15 +-
 components/script/dom/activation.rs           |   6 +-
 components/script/dom/attr.rs                 |   5 +-
 .../dom/bindings/codegen/CodegenRust.py       | 125 +--------
 components/script/dom/bindings/conversions.rs |  31 +++
 components/script/dom/bindings/js.rs          |  36 +++
 .../script/dom/canvasrenderingcontext2d.rs    |   6 +-
 components/script/dom/characterdata.rs        |  20 +-
 components/script/dom/closeevent.rs           |   4 +-
 components/script/dom/create.rs               |   5 +-
 components/script/dom/cssstyledeclaration.rs  |  20 +-
 components/script/dom/customevent.rs          |   4 +-
 .../script/dom/dedicatedworkerglobalscope.rs  |  17 +-
 components/script/dom/document.rs             | 253 +++++++++---------
 components/script/dom/documentfragment.rs     |  22 +-
 components/script/dom/documenttype.rs         |  10 +-
 components/script/dom/domimplementation.rs    |  25 +-
 components/script/dom/element.rs              | 225 ++++++++--------
 components/script/dom/errorevent.rs           |   4 +-
 components/script/dom/eventdispatcher.rs      |   8 +-
 components/script/dom/filereader.rs           |   8 +-
 components/script/dom/formdata.rs             |   4 +-
 components/script/dom/htmlanchorelement.rs    |  27 +-
 components/script/dom/htmlappletelement.rs    |   4 +-
 components/script/dom/htmlareaelement.rs      |   7 +-
 components/script/dom/htmlbaseelement.rs      |  10 +-
 components/script/dom/htmlbodyelement.rs      |  15 +-
 components/script/dom/htmlbuttonelement.rs    |  28 +-
 components/script/dom/htmlcanvaselement.rs    |  10 +-
 components/script/dom/htmlcollection.rs       |   6 +-
 components/script/dom/htmldatalistelement.rs  |   7 +-
 components/script/dom/htmlelement.rs          |  59 ++--
 components/script/dom/htmlfieldsetelement.rs  |  20 +-
 components/script/dom/htmlfontelement.rs      |  10 +-
 components/script/dom/htmlformelement.rs      |  41 ++-
 components/script/dom/htmlheadelement.rs      |   4 +-
 components/script/dom/htmliframeelement.rs    |  36 +--
 components/script/dom/htmlimageelement.rs     |  24 +-
 components/script/dom/htmlinputelement.rs     |  54 ++--
 components/script/dom/htmllinkelement.rs      |  18 +-
 components/script/dom/htmlmetaelement.rs      |  11 +-
 components/script/dom/htmlobjectelement.rs    |   8 +-
 components/script/dom/htmloptgroupelement.rs  |  23 +-
 components/script/dom/htmloptionelement.rs    |  39 +--
 components/script/dom/htmlscriptelement.rs    |  26 +-
 components/script/dom/htmlselectelement.rs    |  17 +-
 components/script/dom/htmlstyleelement.rs     |  11 +-
 components/script/dom/htmltablecellelement.rs |  15 +-
 components/script/dom/htmltableelement.rs     |  32 ++-
 components/script/dom/htmltablerowelement.rs  |  18 +-
 .../script/dom/htmltablesectionelement.rs     |  16 +-
 components/script/dom/htmltemplateelement.rs  |  12 +-
 components/script/dom/htmltextareaelement.rs  |  32 +--
 components/script/dom/htmltitleelement.rs     |  18 +-
 components/script/dom/keyboardevent.rs        |   7 +-
 components/script/dom/macros.rs               |  63 +++--
 components/script/dom/messageevent.rs         |   6 +-
 components/script/dom/mod.rs                  |   4 +-
 components/script/dom/mouseevent.rs           |   6 +-
 components/script/dom/node.rs                 | 179 ++++++-------
 components/script/dom/progressevent.rs        |   4 +-
 components/script/dom/range.rs                |  76 +++---
 components/script/dom/servohtmlparser.rs      |   3 +-
 components/script/dom/storage.rs              |   9 +-
 components/script/dom/storageevent.rs         |   4 +-
 components/script/dom/text.rs                 |  18 +-
 components/script/dom/uievent.rs              |   4 +-
 components/script/dom/userscripts.rs          |   7 +-
 components/script/dom/virtualmethods.rs       | 126 ++++-----
 components/script/dom/webglcontextevent.rs    |   6 +-
 .../script/dom/webglrenderingcontext.rs       |  16 +-
 components/script/dom/websocket.rs            |  14 +-
 components/script/dom/window.rs               |  14 +-
 components/script/dom/worker.rs               |  10 +-
 components/script/dom/workerglobalscope.rs    |  11 +-
 components/script/dom/xmlhttprequest.rs       |  14 +-
 .../script/dom/xmlhttprequesteventtarget.rs   |   1 -
 components/script/lib.rs                      |   1 +
 components/script/parse/html.rs               |  53 ++--
 components/script/script_task.rs              |  31 ++-
 components/script/webdriver_handlers.rs       |  16 +-
 82 files changed, 1124 insertions(+), 1148 deletions(-)

diff --git a/components/layout/wrapper.rs b/components/layout/wrapper.rs
index 7c13cc6d97c..17b54883fa0 100644
--- a/components/layout/wrapper.rs
+++ b/components/layout/wrapper.rs
@@ -40,20 +40,18 @@ use ipc_channel::ipc::IpcSender;
 use msg::constellation_msg::PipelineId;
 use opaque_node::OpaqueNodeMethods;
 use script::dom::attr::AttrValue;
-use script::dom::bindings::codegen::InheritTypes::{CharacterDataCast, CharacterDataTypeId};
-use script::dom::bindings::codegen::InheritTypes::{ElementCast, ElementTypeId};
-use script::dom::bindings::codegen::InheritTypes::{HTMLCanvasElementCast, HTMLElementTypeId};
-use script::dom::bindings::codegen::InheritTypes::{HTMLIFrameElementCast, HTMLImageElementCast};
-use script::dom::bindings::codegen::InheritTypes::{HTMLInputElementCast, HTMLTextAreaElementCast};
-use script::dom::bindings::codegen::InheritTypes::{NodeCast, NodeTypeId, TextCast};
+use script::dom::bindings::codegen::InheritTypes::{CharacterDataTypeId, ElementTypeId};
+use script::dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, NodeTypeId};
+use script::dom::bindings::conversions::Castable;
 use script::dom::bindings::js::LayoutJS;
-use script::dom::characterdata::LayoutCharacterDataHelpers;
+use script::dom::characterdata::{CharacterData, LayoutCharacterDataHelpers};
 use script::dom::element;
 use script::dom::element::{Element, LayoutElementHelpers, RawLayoutElementHelpers};
-use script::dom::htmlcanvaselement::LayoutHTMLCanvasElementHelpers;
-use script::dom::htmlimageelement::LayoutHTMLImageElementHelpers;
-use script::dom::htmlinputelement::LayoutHTMLInputElementHelpers;
-use script::dom::htmltextareaelement::LayoutHTMLTextAreaElementHelpers;
+use script::dom::htmlcanvaselement::{HTMLCanvasElement, LayoutHTMLCanvasElementHelpers};
+use script::dom::htmliframeelement::HTMLIFrameElement;
+use script::dom::htmlimageelement::{HTMLImageElement, LayoutHTMLImageElementHelpers};
+use script::dom::htmlinputelement::{HTMLInputElement, LayoutHTMLInputElementHelpers};
+use script::dom::htmltextareaelement::{HTMLTextAreaElement, LayoutHTMLTextAreaElementHelpers};
 use script::dom::node::{HAS_CHANGED, HAS_DIRTY_DESCENDANTS, HAS_DIRTY_SIBLINGS, IS_DIRTY};
 use script::dom::node::{LayoutNodeHelpers, Node, SharedLayoutData};
 use script::dom::text::Text;
@@ -360,14 +358,14 @@ impl<'le> LayoutElement<'le> {
 
     pub fn as_node(&self) -> LayoutNode<'le> {
         LayoutNode {
-            node: NodeCast::from_layout_js(&self.element),
+            node: self.element.upcast::<Node>(),
             chain: PhantomData,
         }
     }
 }
 
 fn as_element<'le>(node: LayoutJS<Node>) -> Option<LayoutElement<'le>> {
-    ElementCast::to_layout_js(&node).map(|element| {
+    node.downcast().map(|element| {
         LayoutElement {
             element: element,
             chain: PhantomData,
@@ -379,7 +377,7 @@ fn as_element<'le>(node: LayoutJS<Node>) -> Option<LayoutElement<'le>> {
 impl<'le> ::selectors::Element for LayoutElement<'le> {
     fn parent_element(&self) -> Option<LayoutElement<'le>> {
         unsafe {
-            NodeCast::from_layout_js(&self.element).parent_node_ref().and_then(as_element)
+            self.element.upcast::<Node>().parent_node_ref().and_then(as_element)
         }
     }
 
@@ -424,7 +422,7 @@ impl<'le> ::selectors::Element for LayoutElement<'le> {
         self.as_node().children().all(|node| match node.type_id() {
             NodeTypeId::Element(..) => false,
             NodeTypeId::CharacterData(CharacterDataTypeId::Text) => unsafe {
-                CharacterDataCast::to_layout_js(&node.node).unwrap().data_for_layout().is_empty()
+                node.node.downcast::<CharacterData>().unwrap().data_for_layout().is_empty()
             },
             _ => true
         })
@@ -697,7 +695,7 @@ impl<'ln> ThreadSafeLayoutNode<'ln> {
     #[inline]
     pub fn as_element(&self) -> ThreadSafeLayoutElement<'ln> {
         unsafe {
-            let element = match ElementCast::to_layout_js(self.get_jsmanaged()) {
+            let element = match self.get_jsmanaged().downcast::<Element>() {
                 Some(e) => e.unsafe_get(),
                 None => panic!("not an element")
             };
@@ -788,12 +786,12 @@ impl<'ln> ThreadSafeLayoutNode<'ln> {
 
     pub fn is_ignorable_whitespace(&self) -> bool {
         unsafe {
-            let text: LayoutJS<Text> = match TextCast::to_layout_js(self.get_jsmanaged()) {
+            let text: LayoutJS<Text> = match self.get_jsmanaged().downcast::<Text>() {
                 Some(text) => text,
                 None => return false
             };
 
-            if !is_whitespace(CharacterDataCast::from_layout_js(&text).data_for_layout()) {
+            if !is_whitespace(text.upcast::<CharacterData>().data_for_layout()) {
                 return false
             }
 
@@ -816,7 +814,7 @@ impl<'ln> ThreadSafeLayoutNode<'ln> {
     pub fn get_unsigned_integer_attribute(self, attribute: UnsignedIntegerAttribute)
                                           -> Option<u32> {
         unsafe {
-            let elem: Option<LayoutJS<Element>> = ElementCast::to_layout_js(self.get_jsmanaged());
+            let elem: Option<LayoutJS<Element>> = self.get_jsmanaged().downcast::<Element>();
             match elem {
                 Some(element) => {
                     element.get_unsigned_integer_attribute_for_layout(attribute)
@@ -902,19 +900,19 @@ impl<'ln> ThreadSafeLayoutNode<'ln> {
         }
 
         let this = unsafe { self.get_jsmanaged() };
-        let text = TextCast::to_layout_js(this);
+        let text = this.downcast::<Text>();
         if let Some(text) = text {
             let data = unsafe {
-                CharacterDataCast::from_layout_js(&text).data_for_layout().to_owned()
+                text.upcast::<CharacterData>().data_for_layout().to_owned()
             };
             return TextContent::Text(data);
         }
-        let input = HTMLInputElementCast::to_layout_js(this);
+        let input = this.downcast::<HTMLInputElement>();
         if let Some(input) = input {
             let data = unsafe { input.get_value_for_layout() };
             return TextContent::Text(data);
         }
-        let area = HTMLTextAreaElementCast::to_layout_js(this);
+        let area = this.downcast::<HTMLTextAreaElement>();
         if let Some(area) = area {
             let data = unsafe { area.get_value_for_layout() };
             return TextContent::Text(data);
@@ -928,7 +926,7 @@ impl<'ln> ThreadSafeLayoutNode<'ln> {
         let this = unsafe {
             self.get_jsmanaged()
         };
-        let input = HTMLInputElementCast::to_layout_js(this);
+        let input = this.downcast::<HTMLInputElement>();
         if let Some(input) = input {
             let insertion_point = unsafe {
                 input.get_insertion_point_for_layout()
@@ -956,7 +954,7 @@ impl<'ln> ThreadSafeLayoutNode<'ln> {
     /// FIXME(pcwalton): Don't copy URLs.
     pub fn image_url(&self) -> Option<Url> {
         unsafe {
-            HTMLImageElementCast::to_layout_js(self.get_jsmanaged())
+            self.get_jsmanaged().downcast::<HTMLImageElement>()
                 .expect("not an image!")
                 .image_url()
         }
@@ -964,28 +962,28 @@ impl<'ln> ThreadSafeLayoutNode<'ln> {
 
     pub fn canvas_renderer_id(&self) -> Option<usize> {
         unsafe {
-            let canvas_element = HTMLCanvasElementCast::to_layout_js(self.get_jsmanaged());
+            let canvas_element = self.get_jsmanaged().downcast::<HTMLCanvasElement>();
             canvas_element.and_then(|elem| elem.get_renderer_id())
         }
     }
 
     pub fn canvas_ipc_renderer(&self) -> Option<IpcSender<CanvasMsg>> {
         unsafe {
-            let canvas_element = HTMLCanvasElementCast::to_layout_js(self.get_jsmanaged());
+            let canvas_element = self.get_jsmanaged().downcast::<HTMLCanvasElement>();
             canvas_element.and_then(|elem| elem.get_ipc_renderer())
         }
     }
 
     pub fn canvas_width(&self) -> u32 {
         unsafe {
-            let canvas_element = HTMLCanvasElementCast::to_layout_js(self.get_jsmanaged());
+            let canvas_element = self.get_jsmanaged().downcast::<HTMLCanvasElement>();
             canvas_element.unwrap().get_canvas_width()
         }
     }
 
     pub fn canvas_height(&self) -> u32 {
         unsafe {
-            let canvas_element = HTMLCanvasElementCast::to_layout_js(self.get_jsmanaged());
+            let canvas_element = self.get_jsmanaged().downcast::<HTMLCanvasElement>();
             canvas_element.unwrap().get_canvas_height()
         }
     }
@@ -995,7 +993,7 @@ impl<'ln> ThreadSafeLayoutNode<'ln> {
     pub fn iframe_pipeline_id(&self) -> PipelineId {
         use script::dom::htmliframeelement::HTMLIFrameElementLayoutMethods;
         unsafe {
-            let iframe_element = HTMLIFrameElementCast::to_layout_js(self.get_jsmanaged())
+            let iframe_element = self.get_jsmanaged().downcast::<HTMLIFrameElement>()
                 .expect("not an iframe element!");
             iframe_element.pipeline_id().unwrap()
         }
diff --git a/components/script/devtools.rs b/components/script/devtools.rs
index 2356a4896f9..bc6dc34ad4f 100644
--- a/components/script/devtools.rs
+++ b/components/script/devtools.rs
@@ -8,11 +8,10 @@ use devtools_traits::{EvaluateJSReply, Modification, NodeInfo, TimelineMarker, T
 use dom::bindings::codegen::Bindings::DOMRectBinding::{DOMRectMethods};
 use dom::bindings::codegen::Bindings::DocumentBinding::DocumentMethods;
 use dom::bindings::codegen::Bindings::ElementBinding::{ElementMethods};
-use dom::bindings::codegen::InheritTypes::{ElementCast, NodeCast};
-use dom::bindings::conversions::FromJSValConvertible;
-use dom::bindings::conversions::jsstring_to_str;
+use dom::bindings::conversions::{Castable, FromJSValConvertible, jsstring_to_str};
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
+use dom::element::Element;
 use dom::node::Node;
 use ipc_channel::ipc::IpcSender;
 use js::jsapi::{ObjectClassName, RootedObject, RootedValue};
@@ -60,7 +59,7 @@ pub fn handle_get_root_node(page: &Rc<Page>, pipeline: PipelineId, reply: IpcSen
     let page = get_page(&*page, pipeline);
     let document = page.document();
 
-    let node = NodeCast::from_ref(document.r());
+    let node = document.upcast::<Node>();
     reply.send(node.summarize()).unwrap();
 }
 
@@ -69,14 +68,14 @@ pub fn handle_get_document_element(page: &Rc<Page>, pipeline: PipelineId, reply:
     let document = page.document();
     let document_element = document.r().GetDocumentElement().unwrap();
 
-    let node = NodeCast::from_ref(document_element.r());
+    let node = document_element.upcast::<Node>();
     reply.send(node.summarize()).unwrap();
 }
 
 fn find_node_by_unique_id(page: &Rc<Page>, pipeline: PipelineId, node_id: String) -> Root<Node> {
     let page = get_page(&*page, pipeline);
     let document = page.document();
-    let node = NodeCast::from_ref(document.r());
+    let node = document.upcast::<Node>();
 
     for candidate in node.traverse_preorder() {
         if candidate.r().get_unique_id() == node_id {
@@ -100,7 +99,7 @@ pub fn handle_get_layout(page: &Rc<Page>,
                          node_id: String,
                          reply: IpcSender<ComputedNodeLayout>) {
     let node = find_node_by_unique_id(&*page, pipeline, node_id);
-    let elem = ElementCast::to_ref(node.r()).expect("should be getting layout of element");
+    let elem = node.downcast::<Element>().expect("should be getting layout of element");
     let rect = elem.GetBoundingClientRect();
     let width = rect.Width() as f32;
     let height = rect.Height() as f32;
@@ -154,7 +153,7 @@ pub fn handle_modify_attribute(page: &Rc<Page>,
                                node_id: String,
                                modifications: Vec<Modification>) {
     let node = find_node_by_unique_id(&*page, pipeline, node_id);
-    let elem = ElementCast::to_ref(node.r()).expect("should be getting layout of element");
+    let elem = node.downcast::<Element>().expect("should be getting layout of element");
 
     for modification in &modifications {
         match modification.newValue {
diff --git a/components/script/dom/activation.rs b/components/script/dom/activation.rs
index 10c2020dd31..ba140a04269 100644
--- a/components/script/dom/activation.rs
+++ b/components/script/dom/activation.rs
@@ -3,7 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
-use dom::bindings::codegen::InheritTypes::{EventCast, EventTargetCast};
+use dom::bindings::conversions::Castable;
 use dom::element::Element;
 use dom::event::{Event, EventBubbles, EventCancelable};
 use dom::eventtarget::EventTarget;
@@ -45,12 +45,12 @@ pub trait Activatable {
         // Step 4
         // https://html.spec.whatwg.org/multipage/#fire-a-synthetic-mouse-event
         let win = window_from_node(element);
-        let target = EventTargetCast::from_ref(element);
+        let target = element.upcast::<EventTarget>();
         let mouse = MouseEvent::new(win.r(), "click".to_owned(),
                                     EventBubbles::DoesNotBubble, EventCancelable::NotCancelable, Some(win.r()), 1,
                                     0, 0, 0, 0, ctrlKey, shiftKey, altKey, metaKey,
                                     0, None);
-        let event = EventCast::from_ref(mouse.r());
+        let event = mouse.upcast::<Event>();
         event.fire(target);
 
         // Step 5
diff --git a/components/script/dom/attr.rs b/components/script/dom/attr.rs
index 8f545dac744..ffb2ed2ddd9 100644
--- a/components/script/dom/attr.rs
+++ b/components/script/dom/attr.rs
@@ -6,12 +6,13 @@ use cssparser::RGBA;
 use devtools_traits::AttrInfo;
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::AttrBinding::{self, AttrMethods};
-use dom::bindings::codegen::InheritTypes::NodeCast;
+use dom::bindings::conversions::Castable;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, MutNullableHeap};
 use dom::bindings::js::{LayoutJS, Root, RootedReference};
 use dom::bindings::utils::{Reflector, reflect_dom_object};
 use dom::element::{AttributeMutation, Element};
+use dom::node::Node;
 use dom::values::UNSIGNED_LONG_MAX;
 use dom::virtualmethods::vtable_for;
 use dom::window::Window;
@@ -287,7 +288,7 @@ impl Attr {
         assert!(Some(owner) == self.owner().r());
         mem::swap(&mut *self.value.borrow_mut(), &mut value);
         if self.namespace == ns!("") {
-            vtable_for(NodeCast::from_ref(owner)).attribute_mutated(
+            vtable_for(owner.upcast::<Node>()).attribute_mutated(
                 self, AttributeMutation::Set(Some(&value)));
         }
     }
diff --git a/components/script/dom/bindings/codegen/CodegenRust.py b/components/script/dom/bindings/codegen/CodegenRust.py
index 13a3cd51a1b..d42656ae0e7 100644
--- a/components/script/dom/bindings/codegen/CodegenRust.py
+++ b/components/script/dom/bindings/codegen/CodegenRust.py
@@ -5824,7 +5824,7 @@ class GlobalGenRoots():
 
         descriptors = config.getDescriptors(register=True, isCallback=False)
         imports = [CGGeneric("use dom::types::*;\n"),
-                   CGGeneric("use dom::bindings::conversions::{IDLInterface, get_dom_class};\n"),
+                   CGGeneric("use dom::bindings::conversions::{Castable, DerivedFrom, get_dom_class};\n"),
                    CGGeneric("use dom::bindings::js::{JS, LayoutJS, Root};\n"),
                    CGGeneric("use dom::bindings::trace::JSTraceable;\n"),
                    CGGeneric("use dom::bindings::utils::Reflectable;\n"),
@@ -5839,131 +5839,24 @@ class GlobalGenRoots():
             upcast = descriptor.hasDescendants()
             downcast = len(chain) != 1
 
-            if upcast or downcast:
-                # Define a dummy structure to hold the cast functions.
-                allprotos.append(CGGeneric("pub struct %sCast;\n\n" % name))
-
             if upcast and not downcast:
                 topTypes.append(name)
 
-            if upcast:
-                # Define a `FooBase` trait for subclasses to implement, as well as the
-                # `FooCast::from_*` methods that use it.
-                allprotos.append(CGGeneric("""\
-/// Types which are derived from `%(name)s` and can be freely converted
-/// to `%(name)s`
-pub trait %(baseTrait)s: Sized {}
+            if not upcast:
+                # No other interface will implement DeriveFrom<Foo> for this Foo, so avoid
+                # implementing it for itself.
+                chain = chain[:-1]
 
-impl %(name)sCast {
-    #[inline]
-    /// Upcast an instance of a derived class of `%(name)s` to `%(name)s`
-    pub fn from_ref<T: %(baseTrait)s + Reflectable>(derived: &T) -> &%(name)s {
-        unsafe { mem::transmute(derived) }
-    }
-
-    #[inline]
-    #[allow(unrooted_must_root)]
-    pub fn from_layout_js<T: %(baseTrait)s + Reflectable>(derived: &LayoutJS<T>) -> LayoutJS<%(name)s> {
-        unsafe { mem::transmute_copy(derived) }
-    }
-
-    #[inline]
-    pub fn from_root<T: %(baseTrait)s + Reflectable>(derived: Root<T>) -> Root<%(name)s> {
-        unsafe { mem::transmute(derived) }
-    }
-}
-
-""" % {'baseTrait': name + 'Base', 'name': name}))
-            else:
-                # The `FooBase` trait is not defined, so avoid implementing it by
-                # removing `Foo` itself from the chain.
-                chain = descriptor.prototypeChain[:-1]
-
-            # Implement `BarBase` for `Foo`, for all `Bar` that `Foo` inherits from.
+            # Implement `DerivedFrom<Bar>` for `Foo`, for all `Bar` that `Foo` inherits from.
+            if chain:
+                allprotos.append(CGGeneric("impl Castable for %s {}\n" % name))
             for baseName in chain:
-                allprotos.append(CGGeneric("impl %s for %s {}\n" % (baseName + 'Base', name)))
+                allprotos.append(CGGeneric("impl DerivedFrom<%s> for %s {}\n" % (baseName, name)))
             if chain:
                 allprotos.append(CGGeneric("\n"))
 
             if downcast:
                 hierarchy[descriptor.getParentName()].append(name)
-                # Define a `FooDerived` trait for superclasses to implement,
-                # as well as the `FooCast::to_*` methods that use it.
-                baseName = descriptor.prototypeChain[0]
-                args = {
-                    'baseName': baseName,
-                    'derivedTrait': name + 'Derived',
-                    'methodName': 'is_' + name.lower(),
-                    'name': name,
-                }
-                allprotos.append(CGGeneric("""\
-/// Types which `%(name)s` derives from
-pub trait %(derivedTrait)s: Sized {
-    fn %(methodName)s(&self) -> bool;
-}
-
-impl %(name)sCast {
-    #[inline]
-    /// Downcast an instance of a base class of `%(name)s` to an instance of
-    /// `%(name)s`, if it internally is an instance of `%(name)s`
-    pub fn to_ref<T: %(derivedTrait)s + Reflectable>(base: &T) -> Option<&%(name)s> {
-        match base.%(methodName)s() {
-            true => Some(unsafe { mem::transmute(base) }),
-            false => None
-        }
-    }
-
-    #[inline]
-    #[allow(unrooted_must_root)]
-    pub fn to_layout_js<T: %(derivedTrait)s + Reflectable>(base: &LayoutJS<T>) -> Option<LayoutJS<%(name)s>> {
-        unsafe {
-            match (*base.unsafe_get()).%(methodName)s() {
-                true => Some(mem::transmute_copy(base)),
-                false => None
-            }
-        }
-    }
-
-    #[inline]
-    pub fn to_root<T: %(derivedTrait)s + Reflectable>(base: Root<T>) -> Option<Root<%(name)s>> {
-        match base.%(methodName)s() {
-            true => Some(unsafe { mem::transmute(base) }),
-            false => None
-        }
-    }
-}
-
-impl %(derivedTrait)s for %(baseName)s {
-    fn %(methodName)s(&self) -> bool {
-        let dom_class = unsafe {
-            get_dom_class(self.reflector().get_jsobject().get()).unwrap()
-        };
-        %(name)s::derives(dom_class)
-    }
-}
-
-""" % args))
-
-            # Implement the `FooDerived` trait for non-root superclasses by deferring to
-            # the direct superclass. This leaves the implementation of the `FooDerived`
-            # trait for the root superclass to manual code. `FooDerived` is not
-            # implemented for `Foo` itself.
-            for baseName in descriptor.prototypeChain[1:-1]:
-                args = {
-                    'baseName': baseName,
-                    'derivedTrait': name + 'Derived',
-                    'methodName': 'is_' + name.lower(),
-                    'parentName': config.getDescriptor(baseName).getParentName(),
-                }
-                allprotos.append(CGGeneric("""\
-impl %(derivedTrait)s for %(baseName)s {
-    #[inline]
-    fn %(methodName)s(&self) -> bool {
-        %(parentName)sCast::from_ref(self).%(methodName)s()
-    }
-}
-
-""" % args))
 
         typeIdCode = []
         topTypeVariants = [
diff --git a/components/script/dom/bindings/conversions.rs b/components/script/dom/bindings/conversions.rs
index 593c5458452..b38f2df0382 100644
--- a/components/script/dom/bindings/conversions.rs
+++ b/components/script/dom/bindings/conversions.rs
@@ -55,6 +55,7 @@ use libc;
 use num::Float;
 use num::traits::{Bounded, Zero};
 use std::borrow::ToOwned;
+use std::mem;
 use std::rc::Rc;
 use std::{char, ptr, slice};
 use util::str::DOMString;
@@ -106,6 +107,36 @@ pub trait IDLInterface {
     fn derives(&'static DOMClass) -> bool;
 }
 
+/// 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 {
+    /// Check whether a DOM object implements one of its deriving interfaces.
+    fn is<T>(&self) -> bool where T: DerivedFrom<Self> {
+        let class = unsafe {
+            get_dom_class(self.reflector().get_jsobject().get()).unwrap()
+        };
+        T::derives(class)
+    }
+
+    /// Cast a DOM object upwards to one of the interfaces it derives from.
+    fn upcast<T>(&self) -> &T where T: Castable, Self: DerivedFrom<T> {
+        unsafe { mem::transmute(self) }
+    }
+
+    /// Cast a DOM object downwards to one of the interfaces it might implement.
+    fn downcast<T>(&self) -> Option<&T> where T: DerivedFrom<Self> {
+        if self.is::<T>() {
+            Some(unsafe { mem::transmute(self) })
+        } else {
+            None
+        }
+    }
+}
+
+/// A trait to mark an IDL interface as deriving from another one.
+#[rustc_on_unimplemented = "The IDL interface `{Self}` is not derived from `{T}`."]
+pub trait DerivedFrom<T: Castable>: Castable {}
+
 /// A trait to convert Rust types to `JSVal`s.
 pub trait ToJSValConvertible {
     /// Convert `self` to a `JSVal`. JSAPI failure causes a task failure.
diff --git a/components/script/dom/bindings/js.rs b/components/script/dom/bindings/js.rs
index 1ef1d93a86d..2b908877137 100644
--- a/components/script/dom/bindings/js.rs
+++ b/components/script/dom/bindings/js.rs
@@ -24,6 +24,7 @@
 //!
 
 use core::nonzero::NonZero;
+use dom::bindings::conversions::{Castable, DerivedFrom};
 use dom::bindings::trace::JSTraceable;
 use dom::bindings::trace::trace_reflector;
 use dom::bindings::utils::{Reflectable, Reflector};
@@ -34,6 +35,7 @@ use layout_interface::TrustedNodeAddress;
 use script_task::STACK_ROOTS;
 use std::cell::UnsafeCell;
 use std::default::Default;
+use std::mem;
 use std::ops::Deref;
 use std::ptr;
 use util::mem::HeapSizeOf;
@@ -119,6 +121,24 @@ pub struct LayoutJS<T> {
     ptr: NonZero<*const T>
 }
 
+impl<T: Castable> LayoutJS<T> {
+    /// Cast a DOM object root upwards to one of the interfaces it derives from.
+    pub fn upcast<U>(&self) -> LayoutJS<U> where U: Castable, T: DerivedFrom<U> {
+        unsafe { mem::transmute_copy(self) }
+    }
+
+    /// Cast a DOM object downwards to one of the interfaces it might implement.
+    pub fn downcast<U>(&self) -> Option<LayoutJS<U>> where U: DerivedFrom<T> {
+        unsafe {
+            if (*self.unsafe_get()).is::<U>() {
+                Some(mem::transmute_copy(self))
+            } else {
+                None
+            }
+        }
+    }
+}
+
 impl<T: Reflectable> LayoutJS<T> {
     /// Get the reflector.
     pub unsafe fn get_jsobject(&self) -> *mut JSObject {
@@ -447,6 +467,22 @@ pub struct Root<T: Reflectable> {
     root_list: *const RootCollection,
 }
 
+impl<T: Castable> Root<T> {
+    /// Cast a DOM object root upwards to one of the interfaces it derives from.
+    pub fn upcast<U>(root: Root<T>) -> Root<U> where U: Castable, T: DerivedFrom<U> {
+        unsafe { mem::transmute(root) }
+    }
+
+    /// Cast a DOM object root downwards to one of the interfaces it might implement.
+    pub fn downcast<U>(root: Root<T>) -> Option<Root<U>> where U: DerivedFrom<T> {
+        if root.is::<U>() {
+            Some(unsafe { mem::transmute(root) })
+        } else {
+            None
+        }
+    }
+}
+
 impl<T: Reflectable> Root<T> {
     /// Create a new stack-bounded root for the provided JS-owned value.
     /// It cannot not outlive its associated `RootCollection`, and it gives
diff --git a/components/script/dom/canvasrenderingcontext2d.rs b/components/script/dom/canvasrenderingcontext2d.rs
index 89d07cf815c..3166ef4c583 100644
--- a/components/script/dom/canvasrenderingcontext2d.rs
+++ b/components/script/dom/canvasrenderingcontext2d.rs
@@ -12,9 +12,9 @@ use dom::bindings::codegen::Bindings::CanvasRenderingContext2DBinding;
 use dom::bindings::codegen::Bindings::CanvasRenderingContext2DBinding::CanvasRenderingContext2DMethods;
 use dom::bindings::codegen::Bindings::CanvasRenderingContext2DBinding::CanvasWindingRule;
 use dom::bindings::codegen::Bindings::ImageDataBinding::ImageDataMethods;
-use dom::bindings::codegen::InheritTypes::NodeCast;
 use dom::bindings::codegen::UnionTypes::HTMLImageElementOrHTMLCanvasElementOrCanvasRenderingContext2D;
 use dom::bindings::codegen::UnionTypes::StringOrCanvasGradientOrCanvasPattern;
+use dom::bindings::conversions::Castable;
 use dom::bindings::error::{Error, Fallible};
 use dom::bindings::global::{GlobalField, GlobalRef};
 use dom::bindings::js::{JS, LayoutJS, Root};
@@ -26,7 +26,7 @@ use dom::htmlcanvaselement::HTMLCanvasElement;
 use dom::htmlcanvaselement::utils as canvas_utils;
 use dom::htmlimageelement::HTMLImageElement;
 use dom::imagedata::ImageData;
-use dom::node::{NodeDamage, window_from_node};
+use dom::node::{Node, NodeDamage, window_from_node};
 use euclid::matrix2d::Matrix2D;
 use euclid::point::Point2D;
 use euclid::rect::Rect;
@@ -148,7 +148,7 @@ impl CanvasRenderingContext2D {
 
     fn mark_as_dirty(&self) {
         let canvas = self.canvas.root();
-        let node = NodeCast::from_ref(canvas.r());
+        let node = canvas.upcast::<Node>();
         node.dirty(NodeDamage::OtherNodeDamage);
     }
 
diff --git a/components/script/dom/characterdata.rs b/components/script/dom/characterdata.rs
index fce14f68c3d..6c76adc7c28 100644
--- a/components/script/dom/characterdata.rs
+++ b/components/script/dom/characterdata.rs
@@ -6,8 +6,8 @@
 
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::CharacterDataBinding::CharacterDataMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, NodeCast};
 use dom::bindings::codegen::UnionTypes::NodeOrString;
+use dom::bindings::conversions::Castable;
 use dom::bindings::error::{Error, ErrorResult, Fallible};
 use dom::bindings::js::{LayoutJS, Root};
 use dom::document::Document;
@@ -113,35 +113,35 @@ impl CharacterDataMethods for CharacterData {
 
     // https://dom.spec.whatwg.org/#dom-childnode-before
     fn Before(&self, nodes: Vec<NodeOrString>) -> ErrorResult {
-        NodeCast::from_ref(self).before(nodes)
+        self.upcast::<Node>().before(nodes)
     }
 
     // https://dom.spec.whatwg.org/#dom-childnode-after
     fn After(&self, nodes: Vec<NodeOrString>) -> ErrorResult {
-        NodeCast::from_ref(self).after(nodes)
+        self.upcast::<Node>().after(nodes)
     }
 
     // https://dom.spec.whatwg.org/#dom-childnode-replacewith
     fn ReplaceWith(&self, nodes: Vec<NodeOrString>) -> ErrorResult {
-        NodeCast::from_ref(self).replace_with(nodes)
+        self.upcast::<Node>().replace_with(nodes)
     }
 
     // https://dom.spec.whatwg.org/#dom-childnode-remove
     fn Remove(&self) {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         node.remove_self();
     }
 
     // https://dom.spec.whatwg.org/#dom-nondocumenttypechildnode-previouselementsibling
     fn GetPreviousElementSibling(&self) -> Option<Root<Element>> {
-        NodeCast::from_ref(self).preceding_siblings()
-                                .filter_map(ElementCast::to_root).next()
+        self.upcast::<Node>().preceding_siblings()
+                             .filter_map(Root::downcast::<Element>).next()
     }
 
     // https://dom.spec.whatwg.org/#dom-nondocumenttypechildnode-nextelementsibling
     fn GetNextElementSibling(&self) -> Option<Root<Element>> {
-        NodeCast::from_ref(self).following_siblings()
-                                .filter_map(ElementCast::to_root).next()
+        self.upcast::<Node>().following_siblings()
+                             .filter_map(Root::downcast::<Element>).next()
     }
 }
 
@@ -157,7 +157,7 @@ impl CharacterData {
     }
 
     fn content_changed(&self) {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         let document = node.owner_doc();
         document.r().content_changed(node, NodeDamage::OtherNodeDamage);
     }
diff --git a/components/script/dom/closeevent.rs b/components/script/dom/closeevent.rs
index bd49f6d8197..75f2f0e5bb0 100644
--- a/components/script/dom/closeevent.rs
+++ b/components/script/dom/closeevent.rs
@@ -5,7 +5,7 @@
 use dom::bindings::codegen::Bindings::CloseEventBinding;
 use dom::bindings::codegen::Bindings::CloseEventBinding::CloseEventMethods;
 use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
-use dom::bindings::codegen::InheritTypes::EventCast;
+use dom::bindings::conversions::Castable;
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
@@ -43,7 +43,7 @@ impl CloseEvent {
         let event = box CloseEvent::new_inherited(wasClean, code, reason);
         let ev = reflect_dom_object(event, global, CloseEventBinding::Wrap);
         {
-            let event = EventCast::from_ref(ev.r());
+            let event = ev.upcast::<Event>();
             event.InitEvent(type_,
                             bubbles == EventBubbles::Bubbles,
                             cancelable == EventCancelable::Cancelable);
diff --git a/components/script/dom/create.rs b/components/script/dom/create.rs
index 14e061c07a0..6416c86dc37 100644
--- a/components/script/dom/create.rs
+++ b/components/script/dom/create.rs
@@ -2,7 +2,6 @@
  * 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 dom::bindings::codegen::InheritTypes::ElementCast;
 use dom::bindings::js::Root;
 use dom::document::Document;
 use dom::element::Element;
@@ -90,11 +89,11 @@ pub fn create_element(name: QualName, prefix: Option<Atom>,
     macro_rules! make(
         ($ctor:ident) => ({
             let obj = $ctor::new((*name.local).to_owned(), prefix, document);
-            ElementCast::from_root(obj)
+            Root::upcast::<Element>(obj)
         });
         ($ctor:ident, $($arg:expr),+) => ({
             let obj = $ctor::new((*name.local).to_owned(), prefix, document, $($arg),+);
-            ElementCast::from_root(obj)
+            Root::upcast::<Element>(obj)
         })
     );
 
diff --git a/components/script/dom/cssstyledeclaration.rs b/components/script/dom/cssstyledeclaration.rs
index 68dd897eb84..7ad150e0cc2 100644
--- a/components/script/dom/cssstyledeclaration.rs
+++ b/components/script/dom/cssstyledeclaration.rs
@@ -3,13 +3,13 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::CSSStyleDeclarationBinding::{self, CSSStyleDeclarationMethods};
-use dom::bindings::codegen::InheritTypes::{ElementCast, NodeCast};
+use dom::bindings::conversions::Castable;
 use dom::bindings::error::{Error, ErrorResult, Fallible};
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, Root};
 use dom::bindings::utils::{Reflector, reflect_dom_object};
 use dom::element::{Element, StylePriority};
-use dom::node::{NodeDamage, document_from_node, window_from_node};
+use dom::node::{Node, NodeDamage, document_from_node, window_from_node};
 use dom::window::Window;
 use selectors::parser::PseudoElement;
 use std::ascii::AsciiExt;
@@ -75,7 +75,7 @@ impl CSSStyleDeclaration {
 
     fn get_computed_style(&self, property: &Atom) -> Option<DOMString> {
         let owner = self.owner.root();
-        let node = NodeCast::from_ref(owner.r());
+        let node = owner.upcast::<Node>();
         if !node.is_in_doc() {
             // TODO: Node should be matched against the style rules of this window.
             // Firefox is currently the only browser to implement this.
@@ -90,7 +90,7 @@ impl CSSStyleDeclarationMethods for CSSStyleDeclaration {
     // https://dev.w3.org/csswg/cssom/#dom-cssstyledeclaration-length
     fn Length(&self) -> u32 {
         let owner = self.owner.root();
-        let elem = ElementCast::from_ref(owner.r());
+        let elem = owner.upcast::<Element>();
         let len = match *elem.style_attribute().borrow() {
             Some(ref declarations) => declarations.normal.len() + declarations.important.len(),
             None => 0
@@ -102,7 +102,7 @@ impl CSSStyleDeclarationMethods for CSSStyleDeclaration {
     fn Item(&self, index: u32) -> DOMString {
         let index = index as usize;
         let owner = self.owner.root();
-        let elem = ElementCast::from_ref(owner.r());
+        let elem = owner.upcast::<Element>();
         let style_attribute = elem.style_attribute().borrow();
         let result = style_attribute.as_ref().and_then(|declarations| {
             if index > declarations.normal.len() {
@@ -233,7 +233,7 @@ impl CSSStyleDeclarationMethods for CSSStyleDeclaration {
         };
 
         let owner = self.owner.root();
-        let element = ElementCast::from_ref(owner.r());
+        let element = owner.upcast::<Element>();
 
         // Step 8
         for decl in declarations {
@@ -242,7 +242,7 @@ impl CSSStyleDeclarationMethods for CSSStyleDeclaration {
         }
 
         let document = document_from_node(element);
-        let node = NodeCast::from_ref(element);
+        let node = element.upcast::<Node>();
         document.r().content_changed(node, NodeDamage::NodeStyleDamaged);
         Ok(())
     }
@@ -267,7 +267,7 @@ impl CSSStyleDeclarationMethods for CSSStyleDeclaration {
         };
 
         let owner = self.owner.root();
-        let element = ElementCast::from_ref(owner.r());
+        let element = owner.upcast::<Element>();
 
         // Step 5 & 6
         match longhands_from_shorthand(&property) {
@@ -276,7 +276,7 @@ impl CSSStyleDeclarationMethods for CSSStyleDeclaration {
         }
 
         let document = document_from_node(element);
-        let node = NodeCast::from_ref(element);
+        let node = element.upcast::<Node>();
         document.r().content_changed(node, NodeDamage::NodeStyleDamaged);
         Ok(())
     }
@@ -300,7 +300,7 @@ impl CSSStyleDeclarationMethods for CSSStyleDeclaration {
         let value = self.GetPropertyValue(property.clone());
 
         let owner = self.owner.root();
-        let elem = ElementCast::from_ref(owner.r());
+        let elem = owner.upcast::<Element>();
 
         match longhands_from_shorthand(&property) {
             // Step 4
diff --git a/components/script/dom/customevent.rs b/components/script/dom/customevent.rs
index 4b6a9d5855b..17e834e318a 100644
--- a/components/script/dom/customevent.rs
+++ b/components/script/dom/customevent.rs
@@ -5,7 +5,7 @@
 use dom::bindings::codegen::Bindings::CustomEventBinding;
 use dom::bindings::codegen::Bindings::CustomEventBinding::CustomEventMethods;
 use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
-use dom::bindings::codegen::InheritTypes::EventCast;
+use dom::bindings::conversions::Castable;
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{MutHeapJSVal, Root};
@@ -70,7 +70,7 @@ impl CustomEventMethods for CustomEvent {
                        can_bubble: bool,
                        cancelable: bool,
                        detail: HandleValue) {
-        let event = EventCast::from_ref(self);
+        let event = self.upcast::<Event>();
         if event.dispatching() {
             return;
         }
diff --git a/components/script/dom/dedicatedworkerglobalscope.rs b/components/script/dom/dedicatedworkerglobalscope.rs
index 1ef9b8d956d..6ec19c4a3e4 100644
--- a/components/script/dom/dedicatedworkerglobalscope.rs
+++ b/components/script/dom/dedicatedworkerglobalscope.rs
@@ -8,13 +8,14 @@ use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::DedicatedWorkerGlobalScopeBinding;
 use dom::bindings::codegen::Bindings::DedicatedWorkerGlobalScopeBinding::DedicatedWorkerGlobalScopeMethods;
 use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
-use dom::bindings::codegen::InheritTypes::{EventTargetCast, WorkerGlobalScopeCast};
+use dom::bindings::conversions::Castable;
 use dom::bindings::error::ErrorResult;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{Root, RootCollection};
 use dom::bindings::refcounted::LiveDOMReferences;
 use dom::bindings::structuredclone::StructuredCloneData;
 use dom::bindings::utils::Reflectable;
+use dom::eventtarget::EventTarget;
 use dom::messageevent::MessageEvent;
 use dom::worker::{SimpleWorkerErrorHandler, TrustedWorkerAddress, WorkerMessageHandler};
 use dom::workerglobalscope::WorkerGlobalScope;
@@ -219,7 +220,7 @@ impl DedicatedWorkerGlobalScope {
                 parent_sender.clone(), own_sender, receiver);
             // FIXME(njn): workers currently don't have a unique ID suitable for using in reporter
             // registration (#6631), so we instead use a random number and cross our fingers.
-            let scope = WorkerGlobalScopeCast::from_ref(global.r());
+            let scope = global.upcast::<WorkerGlobalScope>();
 
             {
                 let _ar = AutoWorkerReset::new(global.r(), worker);
@@ -261,7 +262,7 @@ impl DedicatedWorkerGlobalScope {
 
     #[allow(unsafe_code)]
     fn receive_event(&self) -> Result<MixedMessage, RecvError> {
-        let scope = WorkerGlobalScopeCast::from_ref(self);
+        let scope = self.upcast::<WorkerGlobalScope>();
         let worker_port = &self.receiver;
         let devtools_port = scope.from_devtools_receiver();
 
@@ -287,8 +288,8 @@ impl DedicatedWorkerGlobalScope {
     fn handle_script_event(&self, msg: WorkerScriptMsg) {
         match msg {
             WorkerScriptMsg::DOMMessage(data) => {
-                let scope = WorkerGlobalScopeCast::from_ref(self);
-                let target = EventTargetCast::from_ref(self);
+                let scope = self.upcast::<WorkerGlobalScope>();
+                let target = self.upcast::<EventTarget>();
                 let _ar = JSAutoRequest::new(scope.get_cx());
                 let _ac = JSAutoCompartment::new(scope.get_cx(), scope.reflector().get_jsobject().get());
                 let mut message = RootedValue::new(scope.get_cx(), UndefinedValue());
@@ -303,11 +304,11 @@ impl DedicatedWorkerGlobalScope {
             },
             WorkerScriptMsg::Common(
                 CommonScriptMsg::FireTimer(TimerSource::FromWorker, timer_id)) => {
-                let scope = WorkerGlobalScopeCast::from_ref(self);
+                let scope = self.upcast::<WorkerGlobalScope>();
                 scope.handle_fire_timer(timer_id);
             },
             WorkerScriptMsg::Common(CommonScriptMsg::CollectReports(reports_chan)) => {
-                let scope = WorkerGlobalScopeCast::from_ref(self);
+                let scope = self.upcast::<WorkerGlobalScope>();
                 let cx = scope.get_cx();
                 let path_seg = format!("url({})", scope.get_url());
                 let reports = ScriptTask::get_reports(cx, path_seg);
@@ -322,7 +323,7 @@ impl DedicatedWorkerGlobalScope {
     fn handle_event(&self, event: MixedMessage) {
         match event {
             MixedMessage::FromDevtools(msg) => {
-                let global_ref = GlobalRef::Worker(WorkerGlobalScopeCast::from_ref(self));
+                let global_ref = GlobalRef::Worker(self.upcast::<WorkerGlobalScope>());
                 match msg {
                     DevtoolScriptControlMsg::EvaluateJS(_pipe_id, string, sender) =>
                         devtools::handle_evaluate_js(&global_ref, string, sender),
diff --git a/components/script/dom/document.rs b/components/script/dom/document.rs
index c29e3a2d2cc..2078c872978 100644
--- a/components/script/dom/document.rs
+++ b/components/script/dom/document.rs
@@ -14,19 +14,9 @@ use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
 use dom::bindings::codegen::Bindings::NodeFilterBinding::NodeFilter;
 use dom::bindings::codegen::Bindings::PerformanceBinding::PerformanceMethods;
 use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
-use dom::bindings::codegen::InheritTypes::{DocumentDerived, DocumentTypeCast, ElementCast};
-use dom::bindings::codegen::InheritTypes::{ElementDerived, ElementTypeId};
-use dom::bindings::codegen::InheritTypes::{EventCast, EventTargetCast};
-use dom::bindings::codegen::InheritTypes::{HTMLAnchorElementCast, HTMLAnchorElementDerived};
-use dom::bindings::codegen::InheritTypes::{HTMLAppletElementDerived, HTMLAreaElementDerived};
-use dom::bindings::codegen::InheritTypes::{HTMLBaseElementCast, HTMLBodyElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLElementTypeId};
-use dom::bindings::codegen::InheritTypes::{HTMLEmbedElementDerived, HTMLFormElementDerived};
-use dom::bindings::codegen::InheritTypes::{HTMLHeadElementCast, HTMLHtmlElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLIFrameElementCast, HTMLImageElementDerived};
-use dom::bindings::codegen::InheritTypes::{HTMLScriptElementDerived, HTMLTitleElementDerived};
-use dom::bindings::codegen::InheritTypes::{NodeCast, NodeTypeId};
+use dom::bindings::codegen::InheritTypes::{ElementTypeId, HTMLElementTypeId, NodeTypeId};
 use dom::bindings::codegen::UnionTypes::NodeOrString;
+use dom::bindings::conversions::Castable;
 use dom::bindings::error::{Error, ErrorResult, Fallible};
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::RootedReference;
@@ -45,13 +35,20 @@ use dom::element::{Element, ElementCreator};
 use dom::event::{Event, EventBubbles, EventCancelable};
 use dom::eventtarget::{EventTarget};
 use dom::htmlanchorelement::HTMLAnchorElement;
+use dom::htmlappletelement::HTMLAppletElement;
+use dom::htmlareaelement::HTMLAreaElement;
 use dom::htmlbaseelement::HTMLBaseElement;
+use dom::htmlbodyelement::HTMLBodyElement;
 use dom::htmlcollection::{CollectionFilter, HTMLCollection};
 use dom::htmlelement::{HTMLElement};
+use dom::htmlembedelement::HTMLEmbedElement;
+use dom::htmlformelement::HTMLFormElement;
 use dom::htmlheadelement::HTMLHeadElement;
 use dom::htmlhtmlelement::HTMLHtmlElement;
 use dom::htmliframeelement::{self, HTMLIFrameElement};
+use dom::htmlimageelement::HTMLImageElement;
 use dom::htmlscriptelement::HTMLScriptElement;
+use dom::htmltitleelement::HTMLTitleElement;
 use dom::keyboardevent::KeyboardEvent;
 use dom::location::Location;
 use dom::messageevent::MessageEvent;
@@ -167,7 +164,7 @@ impl PartialEq for Document {
 struct ImagesFilter;
 impl CollectionFilter for ImagesFilter {
     fn filter(&self, elem: &Element, _root: &Node) -> bool {
-        elem.is_htmlimageelement()
+        elem.is::<HTMLImageElement>()
     }
 }
 
@@ -175,7 +172,7 @@ impl CollectionFilter for ImagesFilter {
 struct EmbedsFilter;
 impl CollectionFilter for EmbedsFilter {
     fn filter(&self, elem: &Element, _root: &Node) -> bool {
-        elem.is_htmlembedelement()
+        elem.is::<HTMLEmbedElement>()
     }
 }
 
@@ -183,7 +180,7 @@ impl CollectionFilter for EmbedsFilter {
 struct LinksFilter;
 impl CollectionFilter for LinksFilter {
     fn filter(&self, elem: &Element, _root: &Node) -> bool {
-        (elem.is_htmlanchorelement() || elem.is_htmlareaelement()) &&
+        (elem.is::<HTMLAnchorElement>() || elem.is::<HTMLAreaElement>()) &&
             elem.has_attribute(&atom!("href"))
     }
 }
@@ -192,7 +189,7 @@ impl CollectionFilter for LinksFilter {
 struct FormsFilter;
 impl CollectionFilter for FormsFilter {
     fn filter(&self, elem: &Element, _root: &Node) -> bool {
-        elem.is_htmlformelement()
+        elem.is::<HTMLFormElement>()
     }
 }
 
@@ -200,7 +197,7 @@ impl CollectionFilter for FormsFilter {
 struct ScriptsFilter;
 impl CollectionFilter for ScriptsFilter {
     fn filter(&self, elem: &Element, _root: &Node) -> bool {
-        elem.is_htmlscriptelement()
+        elem.is::<HTMLScriptElement>()
     }
 }
 
@@ -208,7 +205,7 @@ impl CollectionFilter for ScriptsFilter {
 struct AnchorsFilter;
 impl CollectionFilter for AnchorsFilter {
     fn filter(&self, elem: &Element, _root: &Node) -> bool {
-        elem.is_htmlanchorelement() && elem.has_attribute(&atom!("href"))
+        elem.is::<HTMLAnchorElement>() && elem.has_attribute(&atom!("href"))
     }
 }
 
@@ -216,7 +213,7 @@ impl CollectionFilter for AnchorsFilter {
 struct AppletsFilter;
 impl CollectionFilter for AppletsFilter {
     fn filter(&self, elem: &Element, _root: &Node) -> bool {
-        elem.is_htmlappletelement()
+        elem.is::<HTMLAppletElement>()
     }
 }
 
@@ -290,10 +287,10 @@ impl Document {
     /// Refresh the cached first base element in the DOM.
     /// https://github.com/w3c/web-platform-tests/issues/2122
     pub fn refresh_base_element(&self) {
-        let base = NodeCast::from_ref(self)
+        let base = self.upcast::<Node>()
             .traverse_preorder()
-            .filter_map(HTMLBaseElementCast::to_root)
-            .filter(|element| ElementCast::from_ref(&**element).has_attribute(&atom!("href")))
+            .filter_map(Root::downcast::<HTMLBaseElement>)
+            .filter(|element| element.upcast::<Element>().has_attribute(&atom!("href")))
             .next();
         self.base_element.set(base.r());
     }
@@ -383,7 +380,7 @@ impl Document {
                               id: Atom) {
         debug!("Adding named element to document {:p}: {:p} id={}", self, element, id);
         assert!({
-            let node = NodeCast::from_ref(element);
+            let node = element.upcast::<Node>();
             node.is_in_doc()
         });
         assert!(!id.is_empty());
@@ -400,11 +397,11 @@ impl Document {
             Occupied(entry) => {
                 let elements = entry.into_mut();
 
-                let new_node = NodeCast::from_ref(element);
+                let new_node = element.upcast::<Node>();
                 let mut head: usize = 0;
-                let root = NodeCast::from_ref(root.r());
+                let root = root.upcast::<Node>();
                 for node in root.traverse_preorder() {
-                    if let Some(elem) = ElementCast::to_ref(node.r()) {
+                    if let Some(elem) = node.downcast::<Element>() {
                         if (*elements)[head].root().r() == elem {
                             head += 1;
                         }
@@ -424,16 +421,16 @@ impl Document {
     pub fn find_fragment_node(&self, fragid: &str) -> Option<Root<Element>> {
         self.GetElementById(fragid.to_owned()).or_else(|| {
             let check_anchor = |&node: &&HTMLAnchorElement| {
-                let elem = ElementCast::from_ref(node);
+                let elem = node.upcast::<Element>();
                 elem.get_attribute(&ns!(""), &atom!("name")).map_or(false, |attr| {
                     &**attr.r().value() == fragid
                 })
             };
-            let doc_node = NodeCast::from_ref(self);
+            let doc_node = self.upcast::<Node>();
             doc_node.traverse_preorder()
-                    .filter_map(HTMLAnchorElementCast::to_root)
+                    .filter_map(Root::downcast::<HTMLAnchorElement>)
                     .find(|node| check_anchor(&node.r()))
-                    .map(ElementCast::from_root)
+                    .map(Root::upcast::<Element>)
         })
     }
 
@@ -443,7 +440,7 @@ impl Document {
             Some(root) => root,
             None => return None,
         };
-        let root = NodeCast::from_ref(root);
+        let root = root.upcast::<Node>();
         let address = match self.window.layout().hit_test(root.to_trusted_node_address(), *point) {
             Ok(HitTestResponse(node_address)) => Some(node_address),
             Err(()) => {
@@ -460,7 +457,7 @@ impl Document {
             Some(root) => root,
             None => return vec!(),
         };
-        let root = NodeCast::from_ref(root);
+        let root = root.upcast::<Node>();
         match self.window.layout().mouse_over(root.to_trusted_node_address(), *point) {
             Ok(MouseOverResponse(node_address)) => node_address,
             Err(()) => vec!(),
@@ -474,7 +471,7 @@ impl Document {
         let event = Event::new(GlobalRef::Window(&self.window), "readystatechange".to_owned(),
                                EventBubbles::DoesNotBubble,
                                EventCancelable::NotCancelable);
-        let target = EventTargetCast::from_ref(self);
+        let target = self.upcast::<EventTarget>();
         let _ = event.r().fire(target);
     }
 
@@ -542,7 +539,7 @@ impl Document {
     }
 
     pub fn dirty_all_nodes(&self) {
-        let root = NodeCast::from_ref(self);
+        let root = self.upcast::<Node>();
         for node in root.traverse_preorder() {
             node.r().dirty(NodeDamage::OtherNodeDamage)
         }
@@ -565,18 +562,18 @@ impl Document {
             None => return,
         };
 
-        let el = match ElementCast::to_ref(node.r()) {
+        let el = match node.downcast::<Element>() {
             Some(el) => Root::from_ref(el),
             None => {
                 let parent = node.r().GetParentNode();
-                match parent.and_then(ElementCast::to_root) {
+                match parent.and_then(Root::downcast::<Element>) {
                     Some(parent) => parent,
                     None => return,
                 }
             },
         };
 
-        let node = NodeCast::from_ref(el.r());
+        let node = el.upcast::<Node>();
         debug!("{} on {:?}", mouse_event_type_string, node.debug_str());
         // Prevent click event if form control element is disabled.
         if let  MouseEventType::Click = mouse_event_type {
@@ -601,7 +598,7 @@ impl Document {
                                     false, false, false, false,
                                     0i16,
                                     None);
-        let event = EventCast::from_ref(event.r());
+        let event = event.upcast::<Event>();
 
         // https://dvcs.w3.org/hg/dom3events/raw-file/tip/html/DOM3-Events.html#trusted-events
         event.set_trusted(true);
@@ -609,7 +606,7 @@ impl Document {
         match mouse_event_type {
             MouseEventType::Click => el.authentic_click_activation(event),
             _ =>  {
-                let target = EventTargetCast::from_ref(node);
+                let target = node.upcast::<EventTarget>();
                 event.fire(target);
             },
         }
@@ -639,7 +636,7 @@ impl Document {
                                           false, false, false, false,
                                           0i16,
                                           None);
-        let event = EventCast::from_ref(mouse_event.r());
+        let event = mouse_event.upcast::<Event>();
         event.fire(target);
     }
 
@@ -653,8 +650,8 @@ impl Document {
         for node_address in &mouse_over_addresses {
             let node = node::from_untrusted_node_address(js_runtime, *node_address);
             mouse_over_targets.push(node.r().inclusive_ancestors()
-                                            .find(|node| node.r().is_element())
-                                            .map(|node| JS::from_ref(ElementCast::to_ref(node.r()).unwrap()))
+                                            .find(|node| node.is::<Element>())
+                                            .map(|node| JS::from_ref(node.downcast::<Element>().unwrap()))
                                             .unwrap());
         };
 
@@ -667,7 +664,7 @@ impl Document {
                 if target_ref.get_hover_state() {
                     target_ref.set_hover_state(false);
 
-                    let target = EventTargetCast::from_ref(target_ref);
+                    let target = target_ref.upcast::<EventTarget>();
 
                     self.fire_mouse_event(point, &target, "mouseout".to_owned());
                 }
@@ -681,7 +678,7 @@ impl Document {
             if !target.get_hover_state() {
                 target.set_hover_state(true);
 
-                let target = EventTargetCast::from_ref(*target);
+                let target = target.upcast::<EventTarget>();
 
                 self.fire_mouse_event(point, target, "mouseover".to_owned());
 
@@ -693,7 +690,7 @@ impl Document {
             let top_most_node =
                 node::from_untrusted_node_address(js_runtime, mouse_over_addresses[0]);
 
-            let target = EventTargetCast::from_ref(top_most_node.r());
+            let target = top_most_node.upcast::<EventTarget>();
             self.fire_mouse_event(point, target, "mousemove".to_owned());
         }
 
@@ -716,9 +713,9 @@ impl Document {
         let body = self.GetBody();
 
         let target = match (&focused, &body) {
-            (&Some(ref focused), _) => EventTargetCast::from_ref(focused.r()),
-            (&None, &Some(ref body)) => EventTargetCast::from_ref(body.r()),
-            (&None, &None) => EventTargetCast::from_ref(&*self.window),
+            (&Some(ref focused), _) => focused.upcast::<EventTarget>(),
+            (&None, &Some(ref body)) => body.upcast::<EventTarget>(),
+            (&None, &None) => self.window.upcast::<EventTarget>(),
         };
 
         let ctrl = modifiers.contains(CONTROL);
@@ -741,7 +738,7 @@ impl Document {
                                           props.location, is_repeating, is_composing,
                                           ctrl, alt, shift, meta,
                                           None, props.key_code);
-        let event = EventCast::from_ref(keyevent.r());
+        let event = keyevent.upcast::<Event>();
         event.fire(target);
         let mut prevented = event.DefaultPrevented();
 
@@ -754,7 +751,7 @@ impl Document {
                                            props.location, is_repeating, is_composing,
                                            ctrl, alt, shift, meta,
                                            props.char_code, 0);
-            let ev = EventCast::from_ref(event.r());
+            let ev = event.upcast::<Event>();
             ev.fire(target);
             prevented = ev.DefaultPrevented();
             // TODO: if keypress event is canceled, prevent firing input events
@@ -771,7 +768,7 @@ impl Document {
         // https://www.w3.org/Bugs/Public/show_bug.cgi?id=27337
         match key {
             Key::Space if !prevented && state == KeyState::Released => {
-                let maybe_elem: Option<&Element> = ElementCast::to_ref(target);
+                let maybe_elem: Option<&Element> = target.downcast::<Element>();
                 if let Some(el) = maybe_elem {
                     if let Some(a) = el.as_maybe_activatable() {
                         a.synthetic_click_activation(ctrl, alt, shift, meta);
@@ -779,7 +776,7 @@ impl Document {
                 }
             }
             Key::Enter if !prevented && state == KeyState::Released => {
-                let maybe_elem: Option<&Element> = ElementCast::to_ref(target);
+                let maybe_elem: Option<&Element> = target.downcast::<Element>();
                 if let Some(el) = maybe_elem {
                     if let Some(a) = el.as_maybe_activatable() {
                         a.implicit_submission(ctrl, alt, shift, meta);
@@ -800,18 +797,18 @@ impl Document {
             match nodes.into_iter().next().unwrap() {
                 NodeOrString::eNode(node) => Ok(node),
                 NodeOrString::eString(string) => {
-                    Ok(NodeCast::from_root(self.CreateTextNode(string)))
+                    Ok(Root::upcast::<Node>(self.CreateTextNode(string)))
                 },
             }
         } else {
-            let fragment = NodeCast::from_root(self.CreateDocumentFragment());
+            let fragment = Root::upcast::<Node>(self.CreateDocumentFragment());
             for node in nodes {
                 match node {
                     NodeOrString::eNode(node) => {
                         try!(fragment.r().AppendChild(node.r()));
                     },
                     NodeOrString::eString(string) => {
-                        let node = NodeCast::from_root(self.CreateTextNode(string));
+                        let node = Root::upcast::<Node>(self.CreateTextNode(string));
                         // No try!() here because appending a text node
                         // should not fail.
                         fragment.r().AppendChild(node.r()).unwrap();
@@ -823,17 +820,17 @@ impl Document {
     }
 
     pub fn get_body_attribute(&self, local_name: &Atom) -> DOMString {
-        match self.GetBody().and_then(HTMLBodyElementCast::to_root) {
+        match self.GetBody().and_then(Root::downcast::<HTMLBodyElement>) {
             Some(ref body) => {
-                ElementCast::from_ref(body.r()).get_string_attribute(local_name)
+                body.upcast::<Element>().get_string_attribute(local_name)
             },
             None => "".to_owned()
         }
     }
 
     pub fn set_body_attribute(&self, local_name: &Atom, value: DOMString) {
-        if let Some(ref body) = self.GetBody().and_then(HTMLBodyElementCast::to_root) {
-            ElementCast::from_ref(body.r()).set_string_attribute(local_name, value);
+        if let Some(ref body) = self.GetBody().and_then(Root::downcast::<HTMLBodyElement>) {
+            body.upcast::<Element>().set_string_attribute(local_name, value);
         }
     }
 
@@ -943,8 +940,8 @@ impl Document {
 
     /// Find an iframe element in the document.
     pub fn find_iframe(&self, subpage_id: SubpageId) -> Option<Root<HTMLIFrameElement>> {
-        NodeCast::from_ref(self).traverse_preorder()
-            .filter_map(HTMLIFrameElementCast::to_root)
+        self.upcast::<Node>().traverse_preorder()
+            .filter_map(Root::downcast::<HTMLIFrameElement>)
             .find(|node| node.r().subpage_id() == Some(subpage_id))
     }
 }
@@ -1061,7 +1058,7 @@ impl Document {
                                           GlobalRef::Window(window),
                                           DocumentBinding::Wrap);
         {
-            let node = NodeCast::from_ref(document.r());
+            let node = document.upcast::<Node>();
             node.set_owner_doc(document.r());
         }
         document
@@ -1069,7 +1066,7 @@ impl Document {
 
     fn create_node_list<F: Fn(&Node) -> bool>(&self, callback: F) -> Root<NodeList> {
         let doc = self.GetDocumentElement();
-        let maybe_node = doc.r().map(NodeCast::from_ref);
+        let maybe_node = doc.r().map(Castable::upcast::<Node>);
         let iter = maybe_node.iter().flat_map(|node| node.traverse_preorder())
                              .filter(|node| callback(node.r()));
         NodeList::new_simple_list(&self.window, iter)
@@ -1078,7 +1075,7 @@ impl Document {
     fn get_html_element(&self) -> Option<Root<HTMLHtmlElement>> {
         self.GetDocumentElement()
             .r()
-            .and_then(HTMLHtmlElementCast::to_ref)
+            .and_then(Castable::downcast::<HTMLHtmlElement>)
             .map(Root::from_ref)
     }
 
@@ -1102,7 +1099,7 @@ impl Document {
 
 impl Element {
     fn click_event_filter_by_disabled_state(&self) -> bool {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         match node.type_id() {
             NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLButtonElement)) |
             NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLInputElement)) |
@@ -1134,7 +1131,7 @@ impl DocumentMethods for Document {
         match self.get_focused_element() {
             Some(element) => Some(element),     // Step 3. and 4.
             None => match self.GetBody() {      // Step 5.
-                Some(body) => Some(ElementCast::from_root(body)),
+                Some(body) => Some(Root::upcast::<Element>(body)),
                 None => self.GetDocumentElement(),
             }
         }
@@ -1189,32 +1186,32 @@ impl DocumentMethods for Document {
 
     // https://dom.spec.whatwg.org/#dom-document-doctype
     fn GetDoctype(&self) -> Option<Root<DocumentType>> {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         node.children()
-            .filter_map(|c| DocumentTypeCast::to_ref(c.r()).map(Root::from_ref))
+            .filter_map(|c| c.downcast::<DocumentType>().map(Root::from_ref))
             .next()
     }
 
     // https://dom.spec.whatwg.org/#dom-document-documentelement
     fn GetDocumentElement(&self) -> Option<Root<Element>> {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         node.child_elements().next()
     }
 
     // https://dom.spec.whatwg.org/#dom-document-getelementsbytagname
     fn GetElementsByTagName(&self, tag_name: DOMString) -> Root<HTMLCollection> {
-        HTMLCollection::by_tag_name(&self.window, NodeCast::from_ref(self), tag_name)
+        HTMLCollection::by_tag_name(&self.window, self.upcast::<Node>(), tag_name)
     }
 
     // https://dom.spec.whatwg.org/#dom-document-getelementsbytagnamens
     fn GetElementsByTagNameNS(&self, maybe_ns: Option<DOMString>, tag_name: DOMString)
                               -> Root<HTMLCollection> {
-        HTMLCollection::by_tag_name_ns(&self.window, NodeCast::from_ref(self), tag_name, maybe_ns)
+        HTMLCollection::by_tag_name_ns(&self.window, self.upcast::<Node>(), tag_name, maybe_ns)
     }
 
     // https://dom.spec.whatwg.org/#dom-document-getelementsbyclassname
     fn GetElementsByClassName(&self, classes: DOMString) -> Root<HTMLCollection> {
-        HTMLCollection::by_class_name(&self.window, NodeCast::from_ref(self), classes)
+        HTMLCollection::by_class_name(&self.window, self.upcast::<Node>(), classes)
     }
 
     // https://dom.spec.whatwg.org/#dom-nonelementparentnode-getelementbyid
@@ -1307,7 +1304,7 @@ impl DocumentMethods for Document {
     // https://dom.spec.whatwg.org/#dom-document-importnode
     fn ImportNode(&self, node: &Node, deep: bool) -> Fallible<Root<Node>> {
         // Step 1.
-        if node.is_document() {
+        if node.is::<Document>() {
             return Err(Error::NotSupported);
         }
 
@@ -1323,7 +1320,7 @@ impl DocumentMethods for Document {
     // https://dom.spec.whatwg.org/#dom-document-adoptnode
     fn AdoptNode(&self, node: &Node) -> Fallible<Root<Node>> {
         // Step 1.
-        if node.is_document() {
+        if node.is::<Document>() {
             return Err(Error::NotSupported);
         }
 
@@ -1338,17 +1335,17 @@ impl DocumentMethods for Document {
     fn CreateEvent(&self, mut interface: DOMString) -> Fallible<Root<Event>> {
         interface.make_ascii_lowercase();
         match &*interface {
-            "uievents" | "uievent" => Ok(EventCast::from_root(
+            "uievents" | "uievent" => Ok(Root::upcast::<Event>(
                 UIEvent::new_uninitialized(&self.window))),
-            "mouseevents" | "mouseevent" => Ok(EventCast::from_root(
+            "mouseevents" | "mouseevent" => Ok(Root::upcast::<Event>(
                 MouseEvent::new_uninitialized(&self.window))),
-            "customevent" => Ok(EventCast::from_root(
+            "customevent" => Ok(Root::upcast::<Event>(
                 CustomEvent::new_uninitialized(GlobalRef::Window(&self.window)))),
             "htmlevents" | "events" | "event" => Ok(Event::new_uninitialized(
                 GlobalRef::Window(&self.window))),
-            "keyboardevent" | "keyevents" => Ok(EventCast::from_root(
+            "keyboardevent" | "keyevents" => Ok(Root::upcast::<Event>(
                 KeyboardEvent::new_uninitialized(&self.window))),
-            "messageevent" => Ok(EventCast::from_root(
+            "messageevent" => Ok(Root::upcast::<Event>(
                 MessageEvent::new_uninitialized(GlobalRef::Window(&self.window)))),
             _ => Err(Error::NotSupported)
         }
@@ -1384,15 +1381,15 @@ impl DocumentMethods for Document {
         let title = self.GetDocumentElement().and_then(|root| {
             if root.r().namespace() == &ns!(SVG) && root.r().local_name() == &atom!("svg") {
                 // Step 1.
-                NodeCast::from_ref(root.r()).child_elements().find(|node| {
+                root.upcast::<Node>().child_elements().find(|node| {
                     node.r().namespace() == &ns!(SVG) &&
                     node.r().local_name() == &atom!("title")
-                }).map(NodeCast::from_root)
+                }).map(Root::upcast::<Node>)
             } else {
                 // Step 2.
-                NodeCast::from_ref(root.r())
-                         .traverse_preorder()
-                         .find(|node| node.r().is_htmltitleelement())
+                root.upcast::<Node>()
+                    .traverse_preorder()
+                    .find(|node| node.r().is::<HTMLTitleElement>())
             }
         });
 
@@ -1415,25 +1412,25 @@ impl DocumentMethods for Document {
 
         let elem = if root.r().namespace() == &ns!(SVG) &&
                        root.r().local_name() == &atom!("svg") {
-            let elem = NodeCast::from_ref(root.r()).child_elements().find(|node| {
+            let elem = root.upcast::<Node>().child_elements().find(|node| {
                 node.r().namespace() == &ns!(SVG) &&
                 node.r().local_name() == &atom!("title")
             });
             match elem {
-                Some(elem) => NodeCast::from_root(elem),
+                Some(elem) => Root::upcast::<Node>(elem),
                 None => {
                     let name = QualName::new(ns!(SVG), atom!("title"));
                     let elem = Element::create(name, None, self,
                                                ElementCreator::ScriptCreated);
-                    NodeCast::from_ref(root.r())
-                             .AppendChild(NodeCast::from_ref(elem.r()))
-                             .unwrap()
+                    root.upcast::<Node>()
+                        .AppendChild(elem.upcast::<Node>())
+                        .unwrap()
                 }
             }
         } else if root.r().namespace() == &ns!(HTML) {
-            let elem = NodeCast::from_ref(root.r())
-                                .traverse_preorder()
-                                .find(|node| node.r().is_htmltitleelement());
+            let elem = root.upcast::<Node>()
+                           .traverse_preorder()
+                           .find(|node| node.r().is::<HTMLTitleElement>());
             match elem {
                 Some(elem) => elem,
                 None => {
@@ -1442,9 +1439,9 @@ impl DocumentMethods for Document {
                             let name = QualName::new(ns!(HTML), atom!("title"));
                             let elem = Element::create(name, None, self,
                                                        ElementCreator::ScriptCreated);
-                            NodeCast::from_ref(head.r())
-                                     .AppendChild(NodeCast::from_ref(elem.r()))
-                                     .unwrap()
+                            head.upcast::<Node>()
+                                .AppendChild(elem.upcast::<Node>())
+                                .unwrap()
                         },
                         None => return,
                     }
@@ -1460,9 +1457,9 @@ impl DocumentMethods for Document {
     // https://html.spec.whatwg.org/multipage/#dom-document-head
     fn GetHead(&self) -> Option<Root<HTMLHeadElement>> {
         self.get_html_element().and_then(|root| {
-            let node = NodeCast::from_ref(root.r());
+            let node = root.upcast::<Node>();
             node.children()
-                .filter_map(|c| HTMLHeadElementCast::to_ref(c.r()).map(Root::from_ref))
+                .filter_map(|c| c.downcast::<HTMLHeadElement>().map(Root::from_ref))
                 .next()
         })
     }
@@ -1475,7 +1472,7 @@ impl DocumentMethods for Document {
     // https://html.spec.whatwg.org/multipage/#dom-document-body
     fn GetBody(&self) -> Option<Root<HTMLElement>> {
         self.get_html_element().and_then(|root| {
-            let node = NodeCast::from_ref(root.r());
+            let node = root.upcast::<Node>();
             node.children().find(|child| {
                 match child.r().type_id() {
                     NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLBodyElement)) |
@@ -1483,7 +1480,7 @@ impl DocumentMethods for Document {
                     _ => false
                 }
             }).map(|node| {
-                Root::from_ref(HTMLElementCast::to_ref(node.r()).unwrap())
+                Root::from_ref(node.downcast::<HTMLElement>().unwrap())
             })
         })
     }
@@ -1496,7 +1493,7 @@ impl DocumentMethods for Document {
             None => return Err(Error::HierarchyRequest),
         };
 
-        let node = NodeCast::from_ref(new_body);
+        let node = new_body.upcast::<Node>();
         match node.type_id() {
             NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLBodyElement)) |
             NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLFrameSetElement)) => {}
@@ -1512,9 +1509,9 @@ impl DocumentMethods for Document {
         match (self.get_html_element(), &old_body) {
             // Step 3.
             (Some(ref root), &Some(ref child)) => {
-                let root = NodeCast::from_ref(root.r());
-                let child = NodeCast::from_ref(child.r());
-                let new_body = NodeCast::from_ref(new_body);
+                let root = root.upcast::<Node>();
+                let child = child.upcast::<Node>();
+                let new_body = new_body.upcast::<Node>();
                 assert!(root.ReplaceChild(new_body, child).is_ok())
             },
 
@@ -1523,8 +1520,8 @@ impl DocumentMethods for Document {
 
             // Step 5.
             (Some(ref root), &None) => {
-                let root = NodeCast::from_ref(root.r());
-                let new_body = NodeCast::from_ref(new_body);
+                let root = root.upcast::<Node>();
+                let new_body = new_body.upcast::<Node>();
                 assert!(root.AppendChild(new_body).is_ok());
             }
         }
@@ -1534,7 +1531,7 @@ impl DocumentMethods for Document {
     // https://html.spec.whatwg.org/multipage/#dom-document-getelementsbyname
     fn GetElementsByName(&self, name: DOMString) -> Root<NodeList> {
         self.create_node_list(|node| {
-            let element = match ElementCast::to_ref(node) {
+            let element = match node.downcast::<Element>() {
                 Some(element) => element,
                 None => return false,
             };
@@ -1550,7 +1547,7 @@ impl DocumentMethods for Document {
     // https://html.spec.whatwg.org/multipage/#dom-document-images
     fn Images(&self) -> Root<HTMLCollection> {
         self.images.or_init(|| {
-            let root = NodeCast::from_ref(self);
+            let root = self.upcast::<Node>();
             let filter = box ImagesFilter;
             HTMLCollection::create(&self.window, root, filter)
         })
@@ -1559,7 +1556,7 @@ impl DocumentMethods for Document {
     // https://html.spec.whatwg.org/multipage/#dom-document-embeds
     fn Embeds(&self) -> Root<HTMLCollection> {
         self.embeds.or_init(|| {
-            let root = NodeCast::from_ref(self);
+            let root = self.upcast::<Node>();
             let filter = box EmbedsFilter;
             HTMLCollection::create(&self.window, root, filter)
         })
@@ -1573,7 +1570,7 @@ impl DocumentMethods for Document {
     // https://html.spec.whatwg.org/multipage/#dom-document-links
     fn Links(&self) -> Root<HTMLCollection> {
         self.links.or_init(|| {
-            let root = NodeCast::from_ref(self);
+            let root = self.upcast::<Node>();
             let filter = box LinksFilter;
             HTMLCollection::create(&self.window, root, filter)
         })
@@ -1582,7 +1579,7 @@ impl DocumentMethods for Document {
     // https://html.spec.whatwg.org/multipage/#dom-document-forms
     fn Forms(&self) -> Root<HTMLCollection> {
         self.forms.or_init(|| {
-            let root = NodeCast::from_ref(self);
+            let root = self.upcast::<Node>();
             let filter = box FormsFilter;
             HTMLCollection::create(&self.window, root, filter)
         })
@@ -1591,7 +1588,7 @@ impl DocumentMethods for Document {
     // https://html.spec.whatwg.org/multipage/#dom-document-scripts
     fn Scripts(&self) -> Root<HTMLCollection> {
         self.scripts.or_init(|| {
-            let root = NodeCast::from_ref(self);
+            let root = self.upcast::<Node>();
             let filter = box ScriptsFilter;
             HTMLCollection::create(&self.window, root, filter)
         })
@@ -1600,7 +1597,7 @@ impl DocumentMethods for Document {
     // https://html.spec.whatwg.org/multipage/#dom-document-anchors
     fn Anchors(&self) -> Root<HTMLCollection> {
         self.anchors.or_init(|| {
-            let root = NodeCast::from_ref(self);
+            let root = self.upcast::<Node>();
             let filter = box AnchorsFilter;
             HTMLCollection::create(&self.window, root, filter)
         })
@@ -1610,7 +1607,7 @@ impl DocumentMethods for Document {
     fn Applets(&self) -> Root<HTMLCollection> {
         // FIXME: This should be return OBJECT elements containing applets.
         self.applets.or_init(|| {
-            let root = NodeCast::from_ref(self);
+            let root = self.upcast::<Node>();
             let filter = box AppletsFilter;
             HTMLCollection::create(&self.window, root, filter)
         })
@@ -1623,43 +1620,43 @@ impl DocumentMethods for Document {
 
     // https://dom.spec.whatwg.org/#dom-parentnode-children
     fn Children(&self) -> Root<HTMLCollection> {
-        HTMLCollection::children(&self.window, NodeCast::from_ref(self))
+        HTMLCollection::children(&self.window, self.upcast::<Node>())
     }
 
     // https://dom.spec.whatwg.org/#dom-parentnode-firstelementchild
     fn GetFirstElementChild(&self) -> Option<Root<Element>> {
-        NodeCast::from_ref(self).child_elements().next()
+        self.upcast::<Node>().child_elements().next()
     }
 
     // https://dom.spec.whatwg.org/#dom-parentnode-lastelementchild
     fn GetLastElementChild(&self) -> Option<Root<Element>> {
-        NodeCast::from_ref(self).rev_children().filter_map(ElementCast::to_root).next()
+        self.upcast::<Node>().rev_children().filter_map(Root::downcast::<Element>).next()
     }
 
     // https://dom.spec.whatwg.org/#dom-parentnode-childelementcount
     fn ChildElementCount(&self) -> u32 {
-        NodeCast::from_ref(self).child_elements().count() as u32
+        self.upcast::<Node>().child_elements().count() as u32
     }
 
     // https://dom.spec.whatwg.org/#dom-parentnode-prepend
     fn Prepend(&self, nodes: Vec<NodeOrString>) -> ErrorResult {
-        NodeCast::from_ref(self).prepend(nodes)
+        self.upcast::<Node>().prepend(nodes)
     }
 
     // https://dom.spec.whatwg.org/#dom-parentnode-append
     fn Append(&self, nodes: Vec<NodeOrString>) -> ErrorResult {
-        NodeCast::from_ref(self).append(nodes)
+        self.upcast::<Node>().append(nodes)
     }
 
     // https://dom.spec.whatwg.org/#dom-parentnode-queryselector
     fn QuerySelector(&self, selectors: DOMString) -> Fallible<Option<Root<Element>>> {
-        let root = NodeCast::from_ref(self);
+        let root = self.upcast::<Node>();
         root.query_selector(selectors)
     }
 
     // https://dom.spec.whatwg.org/#dom-parentnode-queryselectorall
     fn QuerySelectorAll(&self, selectors: DOMString) -> Fallible<Root<NodeList>> {
-        let root = NodeCast::from_ref(self);
+        let root = self.upcast::<Node>();
         root.query_selector_all(selectors)
     }
 
@@ -1716,7 +1713,7 @@ impl DocumentMethods for Document {
         }
         impl CollectionFilter for NamedElementFilter {
             fn filter(&self, elem: &Element, _root: &Node) -> bool {
-                filter_by_name(&self.name, NodeCast::from_ref(elem))
+                filter_by_name(&self.name, elem.upcast::<Node>())
             }
         }
         // https://html.spec.whatwg.org/multipage/#dom-document-nameditem-filter
@@ -1725,7 +1722,7 @@ impl DocumentMethods for Document {
                 NodeTypeId::Element(ElementTypeId::HTMLElement(type_)) => type_,
                 _ => return false,
             };
-            let elem = match ElementCast::to_ref(node) {
+            let elem = match node.downcast::<Element>() {
                 Some(elem) => elem,
                 None => return false,
             };
@@ -1767,7 +1764,7 @@ impl DocumentMethods for Document {
             }
         }
         let name = Atom::from_slice(&name);
-        let root = NodeCast::from_ref(self);
+        let root = self.upcast::<Node>();
         {
             // Step 1.
             let mut elements = root.traverse_preorder().filter(|node| {
@@ -1849,7 +1846,7 @@ impl DocumentProgressHandler {
         let event = Event::new(GlobalRef::Window(window), "DOMContentLoaded".to_owned(),
                                EventBubbles::DoesNotBubble,
                                EventCancelable::NotCancelable);
-        let doctarget = EventTargetCast::from_ref(document.r());
+        let doctarget = document.upcast::<EventTarget>();
         let _ = doctarget.DispatchEvent(event.r());
 
         window.reflow(ReflowGoal::ForDisplay,
@@ -1868,8 +1865,8 @@ impl DocumentProgressHandler {
         let event = Event::new(GlobalRef::Window(window), "load".to_owned(),
                                EventBubbles::DoesNotBubble,
                                EventCancelable::NotCancelable);
-        let wintarget = EventTargetCast::from_ref(window);
-        let doctarget = EventTargetCast::from_ref(document.r());
+        let wintarget = window.upcast::<EventTarget>();
+        let doctarget = document.upcast::<EventTarget>();
         event.r().set_trusted(true);
         let _ = wintarget.dispatch_event_with_target(doctarget, event.r());
 
@@ -1881,7 +1878,7 @@ impl DocumentProgressHandler {
             let event = Event::new(GlobalRef::Window(frame_window.r()), "load".to_owned(),
                                    EventBubbles::DoesNotBubble,
                                    EventCancelable::NotCancelable);
-            let target = EventTargetCast::from_ref(frame_element);
+            let target = frame_element.upcast::<EventTarget>();
             event.r().fire(target);
         };
 
diff --git a/components/script/dom/documentfragment.rs b/components/script/dom/documentfragment.rs
index fd6716802ec..3a5a1800e91 100644
--- a/components/script/dom/documentfragment.rs
+++ b/components/script/dom/documentfragment.rs
@@ -5,8 +5,8 @@
 use dom::bindings::codegen::Bindings::DocumentFragmentBinding;
 use dom::bindings::codegen::Bindings::DocumentFragmentBinding::DocumentFragmentMethods;
 use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, NodeCast};
 use dom::bindings::codegen::UnionTypes::NodeOrString;
+use dom::bindings::conversions::Castable;
 use dom::bindings::error::{ErrorResult, Fallible};
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
@@ -48,14 +48,14 @@ impl DocumentFragmentMethods for DocumentFragment {
     // https://dom.spec.whatwg.org/#dom-parentnode-children
     fn Children(&self) -> Root<HTMLCollection> {
         let window = window_from_node(self);
-        HTMLCollection::children(window.r(), NodeCast::from_ref(self))
+        HTMLCollection::children(window.r(), self.upcast::<Node>())
     }
 
     // https://dom.spec.whatwg.org/#dom-nonelementparentnode-getelementbyid
     fn GetElementById(&self, id: DOMString) -> Option<Root<Element>> {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         let id = Atom::from_slice(&id);
-        node.traverse_preorder().filter_map(ElementCast::to_root).find(|descendant| {
+        node.traverse_preorder().filter_map(Root::downcast::<Element>).find(|descendant| {
             match descendant.get_attribute(&ns!(""), &atom!(id)) {
                 None => false,
                 Some(attr) => *attr.value().as_atom() == id,
@@ -65,38 +65,38 @@ impl DocumentFragmentMethods for DocumentFragment {
 
     // https://dom.spec.whatwg.org/#dom-parentnode-firstelementchild
     fn GetFirstElementChild(&self) -> Option<Root<Element>> {
-        NodeCast::from_ref(self).child_elements().next()
+        self.upcast::<Node>().child_elements().next()
     }
 
     // https://dom.spec.whatwg.org/#dom-parentnode-lastelementchild
     fn GetLastElementChild(&self) -> Option<Root<Element>> {
-        NodeCast::from_ref(self).rev_children().filter_map(ElementCast::to_root).next()
+        self.upcast::<Node>().rev_children().filter_map(Root::downcast::<Element>).next()
     }
 
     // https://dom.spec.whatwg.org/#dom-parentnode-childelementcount
     fn ChildElementCount(&self) -> u32 {
-        NodeCast::from_ref(self).child_elements().count() as u32
+        self.upcast::<Node>().child_elements().count() as u32
     }
 
     // https://dom.spec.whatwg.org/#dom-parentnode-prepend
     fn Prepend(&self, nodes: Vec<NodeOrString>) -> ErrorResult {
-        NodeCast::from_ref(self).prepend(nodes)
+        self.upcast::<Node>().prepend(nodes)
     }
 
     // https://dom.spec.whatwg.org/#dom-parentnode-append
     fn Append(&self, nodes: Vec<NodeOrString>) -> ErrorResult {
-        NodeCast::from_ref(self).append(nodes)
+        self.upcast::<Node>().append(nodes)
     }
 
     // https://dom.spec.whatwg.org/#dom-parentnode-queryselector
     fn QuerySelector(&self, selectors: DOMString) -> Fallible<Option<Root<Element>>> {
-        let root = NodeCast::from_ref(self);
+        let root = self.upcast::<Node>();
         root.query_selector(selectors)
     }
 
     // https://dom.spec.whatwg.org/#dom-parentnode-queryselectorall
     fn QuerySelectorAll(&self, selectors: DOMString) -> Fallible<Root<NodeList>> {
-        let root = NodeCast::from_ref(self);
+        let root = self.upcast::<Node>();
         root.query_selector_all(selectors)
     }
 }
diff --git a/components/script/dom/documenttype.rs b/components/script/dom/documenttype.rs
index 4372ac1abfb..590baf4a576 100644
--- a/components/script/dom/documenttype.rs
+++ b/components/script/dom/documenttype.rs
@@ -4,8 +4,8 @@
 
 use dom::bindings::codegen::Bindings::DocumentTypeBinding;
 use dom::bindings::codegen::Bindings::DocumentTypeBinding::DocumentTypeMethods;
-use dom::bindings::codegen::InheritTypes::NodeCast;
 use dom::bindings::codegen::UnionTypes::NodeOrString;
+use dom::bindings::conversions::Castable;
 use dom::bindings::error::ErrorResult;
 use dom::bindings::js::Root;
 use dom::document::Document;
@@ -83,22 +83,22 @@ impl DocumentTypeMethods for DocumentType {
 
     // https://dom.spec.whatwg.org/#dom-childnode-before
     fn Before(&self, nodes: Vec<NodeOrString>) -> ErrorResult {
-        NodeCast::from_ref(self).before(nodes)
+        self.upcast::<Node>().before(nodes)
     }
 
     // https://dom.spec.whatwg.org/#dom-childnode-after
     fn After(&self, nodes: Vec<NodeOrString>) -> ErrorResult {
-        NodeCast::from_ref(self).after(nodes)
+        self.upcast::<Node>().after(nodes)
     }
 
     // https://dom.spec.whatwg.org/#dom-childnode-replacewith
     fn ReplaceWith(&self, nodes: Vec<NodeOrString>) -> ErrorResult {
-        NodeCast::from_ref(self).replace_with(nodes)
+        self.upcast::<Node>().replace_with(nodes)
     }
 
     // https://dom.spec.whatwg.org/#dom-childnode-remove
     fn Remove(&self) {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         node.remove_self();
     }
 }
diff --git a/components/script/dom/domimplementation.rs b/components/script/dom/domimplementation.rs
index 93eb8cf8e0a..af94a32b854 100644
--- a/components/script/dom/domimplementation.rs
+++ b/components/script/dom/domimplementation.rs
@@ -7,7 +7,7 @@ use dom::bindings::codegen::Bindings::DOMImplementationBinding;
 use dom::bindings::codegen::Bindings::DOMImplementationBinding::DOMImplementationMethods;
 use dom::bindings::codegen::Bindings::DocumentBinding::DocumentMethods;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
-use dom::bindings::codegen::InheritTypes::NodeCast;
+use dom::bindings::conversions::Castable;
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, Root};
@@ -20,6 +20,7 @@ use dom::htmlbodyelement::HTMLBodyElement;
 use dom::htmlheadelement::HTMLHeadElement;
 use dom::htmlhtmlelement::HTMLHtmlElement;
 use dom::htmltitleelement::HTMLTitleElement;
+use dom::node::Node;
 use dom::text::Text;
 use std::borrow::ToOwned;
 use util::str::DOMString;
@@ -76,13 +77,13 @@ impl DOMImplementationMethods for DOMImplementation {
         };
 
         {
-            let doc_node = NodeCast::from_ref(doc.r());
+            let doc_node = doc.upcast::<Node>();
 
             // Step 4.
             match maybe_doctype {
                 None => (),
                 Some(ref doctype) => {
-                    let doc_type = NodeCast::from_ref(*doctype);
+                    let doc_type = doctype.upcast::<Node>();
                     assert!(doc_node.AppendChild(doc_type).is_ok())
                 }
             }
@@ -91,7 +92,7 @@ impl DOMImplementationMethods for DOMImplementation {
             match maybe_elem {
                 None => (),
                 Some(ref elem) => {
-                    assert!(doc_node.AppendChild(NodeCast::from_ref(elem.r())).is_ok())
+                    assert!(doc_node.AppendChild(elem.upcast::<Node>()).is_ok())
                 }
             }
         }
@@ -114,21 +115,21 @@ impl DOMImplementationMethods for DOMImplementation {
 
         {
             // Step 3.
-            let doc_node = NodeCast::from_ref(doc.r());
+            let doc_node = doc.upcast::<Node>();
             let doc_type = DocumentType::new("html".to_owned(), None, None, doc.r());
-            assert!(doc_node.AppendChild(NodeCast::from_ref(doc_type.r())).is_ok());
+            assert!(doc_node.AppendChild(doc_type.upcast::<Node>()).is_ok());
         }
 
         {
             // Step 4.
-            let doc_node = NodeCast::from_ref(doc.r());
-            let doc_html = NodeCast::from_root(
+            let doc_node = doc.upcast::<Node>();
+            let doc_html = Root::upcast::<Node>(
                 HTMLHtmlElement::new("html".to_owned(), None, doc.r()));
             assert!(doc_node.AppendChild(doc_html.r()).is_ok());
 
             {
                 // Step 5.
-                let doc_head = NodeCast::from_root(
+                let doc_head = Root::upcast::<Node>(
                     HTMLHeadElement::new("head".to_owned(), None, doc.r()));
                 assert!(doc_html.r().AppendChild(doc_head.r()).is_ok());
 
@@ -137,20 +138,20 @@ impl DOMImplementationMethods for DOMImplementation {
                     None => (),
                     Some(title_str) => {
                         // Step 6.1.
-                        let doc_title = NodeCast::from_root(
+                        let doc_title = Root::upcast::<Node>(
                             HTMLTitleElement::new("title".to_owned(), None, doc.r()));
                         assert!(doc_head.r().AppendChild(doc_title.r()).is_ok());
 
                         // Step 6.2.
                         let title_text = Text::new(title_str, doc.r());
-                        assert!(doc_title.r().AppendChild(NodeCast::from_ref(title_text.r())).is_ok());
+                        assert!(doc_title.r().AppendChild(title_text.upcast::<Node>()).is_ok());
                     }
                 }
             }
 
             // Step 7.
             let doc_body = HTMLBodyElement::new("body".to_owned(), None, doc.r());
-            assert!(doc_html.r().AppendChild(NodeCast::from_ref(doc_body.r())).is_ok());
+            assert!(doc_html.r().AppendChild(doc_body.upcast::<Node>()).is_ok());
         }
 
         // Step 8.
diff --git a/components/script/dom/element.rs b/components/script/dom/element.rs
index 85b94de04d0..52f2bbc5423 100644
--- a/components/script/dom/element.rs
+++ b/components/script/dom/element.rs
@@ -19,39 +19,44 @@ use dom::bindings::codegen::Bindings::HTMLInputElementBinding::HTMLInputElementM
 use dom::bindings::codegen::Bindings::HTMLTemplateElementBinding::HTMLTemplateElementMethods;
 use dom::bindings::codegen::Bindings::NamedNodeMapBinding::NamedNodeMapMethods;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
-use dom::bindings::codegen::InheritTypes::{CharacterDataCast, DocumentDerived, ElementCast};
-use dom::bindings::codegen::InheritTypes::{ElementDerived, ElementTypeId, EventTargetCast};
-use dom::bindings::codegen::InheritTypes::{HTMLAnchorElementCast, HTMLBodyElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, HTMLFieldSetElementDerived, HTMLFontElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLIFrameElementCast, HTMLInputElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLLegendElementDerived, HTMLOptGroupElementDerived};
-use dom::bindings::codegen::InheritTypes::{HTMLTableCellElementCast, HTMLTableElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLTableRowElementCast, HTMLTableSectionElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLTemplateElementCast, HTMLTextAreaElementCast};
-use dom::bindings::codegen::InheritTypes::{NodeCast, NodeTypeId, TextCast};
+use dom::bindings::codegen::InheritTypes::{ElementTypeId, HTMLElementTypeId, NodeTypeId};
 use dom::bindings::codegen::UnionTypes::NodeOrString;
+use dom::bindings::conversions::Castable;
 use dom::bindings::error::{Error, ErrorResult, Fallible};
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, LayoutJS, MutNullableHeap};
 use dom::bindings::js::{Root, RootedReference};
 use dom::bindings::utils::XMLName::InvalidXMLName;
 use dom::bindings::utils::{namespace_from_domstring, validate_and_extract, xml_name_type};
+use dom::characterdata::CharacterData;
 use dom::create::create_element;
 use dom::document::{Document, LayoutDocumentHelpers};
 use dom::domrect::DOMRect;
 use dom::domrectlist::DOMRectList;
 use dom::domtokenlist::DOMTokenList;
 use dom::event::Event;
+use dom::eventtarget::EventTarget;
+use dom::htmlanchorelement::HTMLAnchorElement;
+use dom::htmlbodyelement::HTMLBodyElement;
 use dom::htmlcollection::HTMLCollection;
+use dom::htmlfieldsetelement::HTMLFieldSetElement;
+use dom::htmlfontelement::HTMLFontElement;
+use dom::htmliframeelement::HTMLIFrameElement;
 use dom::htmlinputelement::{HTMLInputElement, RawLayoutHTMLInputElementHelpers};
-use dom::htmltablecellelement::HTMLTableCellElementLayoutHelpers;
+use dom::htmllegendelement::HTMLLegendElement;
+use dom::htmloptgroupelement::HTMLOptGroupElement;
+use dom::htmltablecellelement::{HTMLTableCellElement, HTMLTableCellElementLayoutHelpers};
 use dom::htmltableelement::HTMLTableElement;
-use dom::htmltextareaelement::RawLayoutHTMLTextAreaElementHelpers;
+use dom::htmltablerowelement::HTMLTableRowElement;
+use dom::htmltablesectionelement::HTMLTableSectionElement;
+use dom::htmltemplateelement::HTMLTemplateElement;
+use dom::htmltextareaelement::{HTMLTextAreaElement, RawLayoutHTMLTextAreaElementHelpers};
 use dom::namednodemap::NamedNodeMap;
 use dom::node::{CLICK_IN_PROGRESS, LayoutNodeHelpers, Node};
 use dom::node::{NodeDamage, SEQUENTIALLY_FOCUSABLE};
 use dom::node::{document_from_node, window_from_node};
 use dom::nodelist::NodeList;
+use dom::text::Text;
 use dom::virtualmethods::{VirtualMethods, vtable_for};
 use html5ever::serialize;
 use html5ever::serialize::SerializeOpts;
@@ -281,15 +286,15 @@ impl LayoutElementHelpers for LayoutJS<Element> {
     unsafe fn synthesize_presentational_hints_for_legacy_attributes<V>(&self, hints: &mut V)
         where V: VecLike<DeclarationBlock<Vec<PropertyDeclaration>>>
     {
-        let bgcolor = if let Some(this) = HTMLBodyElementCast::to_layout_js(self) {
+        let bgcolor = if let Some(this) = self.downcast::<HTMLBodyElement>() {
             (*this.unsafe_get()).get_background_color()
-        } else if let Some(this) = HTMLTableElementCast::to_layout_js(self) {
+        } else if let Some(this) = self.downcast::<HTMLTableElement>() {
             (*this.unsafe_get()).get_background_color()
-        } else if let Some(this) = HTMLTableCellElementCast::to_layout_js(self) {
+        } else if let Some(this) = self.downcast::<HTMLTableCellElement>() {
             this.get_background_color()
-        } else if let Some(this) = HTMLTableRowElementCast::to_layout_js(self) {
+        } else if let Some(this) = self.downcast::<HTMLTableRowElement>() {
             (*this.unsafe_get()).get_background_color()
-        } else if let Some(this) = HTMLTableSectionElementCast::to_layout_js(self) {
+        } else if let Some(this) = self.downcast::<HTMLTableSectionElement>() {
             (*this.unsafe_get()).get_background_color()
         } else {
             None
@@ -301,7 +306,7 @@ impl LayoutElementHelpers for LayoutJS<Element> {
                     CSSColor { parsed: Color::RGBA(color), authored: None }))));
         }
 
-        let background = if let Some(this) = HTMLBodyElementCast::to_layout_js(self) {
+        let background = if let Some(this) = self.downcast::<HTMLBodyElement>() {
             (*this.unsafe_get()).get_background()
         } else {
             None
@@ -313,9 +318,9 @@ impl LayoutElementHelpers for LayoutJS<Element> {
                     background_image::SpecifiedValue(Some(specified::Image::Url(url)))))));
         }
 
-        let color = if let Some(this) = HTMLFontElementCast::to_layout_js(self) {
+        let color = if let Some(this) = self.downcast::<HTMLFontElement>() {
             (*this.unsafe_get()).get_color()
-        } else if let Some(this) = HTMLBodyElementCast::to_layout_js(self) {
+        } else if let Some(this) = self.downcast::<HTMLBodyElement>() {
             // https://html.spec.whatwg.org/multipage/#the-page:the-body-element-20
             (*this.unsafe_get()).get_color()
         } else {
@@ -330,7 +335,7 @@ impl LayoutElementHelpers for LayoutJS<Element> {
                 }))));
         }
 
-        let font_family = if let Some(this) = HTMLFontElementCast::to_layout_js(self) {
+        let font_family = if let Some(this) = self.downcast::<HTMLFontElement>() {
             (*this.unsafe_get()).get_face()
         } else {
             None
@@ -345,7 +350,7 @@ impl LayoutElementHelpers for LayoutJS<Element> {
                                 font_family)])))));
         }
 
-        let font_size = if let Some(this) = HTMLFontElementCast::to_layout_js(self) {
+        let font_size = if let Some(this) = self.downcast::<HTMLFontElement>() {
             (*this.unsafe_get()).get_size()
         } else {
             None
@@ -358,7 +363,7 @@ impl LayoutElementHelpers for LayoutJS<Element> {
                         font_size::SpecifiedValue(font_size)))))
         }
 
-        let cellspacing = if let Some(this) = HTMLTableElementCast::to_layout_js(self) {
+        let cellspacing = if let Some(this) = self.downcast::<HTMLTableElement>() {
             (*this.unsafe_get()).get_cellspacing()
         } else {
             None
@@ -375,7 +380,7 @@ impl LayoutElementHelpers for LayoutJS<Element> {
         }
 
 
-        let size = if let Some(this) = HTMLInputElementCast::to_layout_js(self) {
+        let size = if let Some(this) = self.downcast::<HTMLInputElement>() {
             // FIXME(pcwalton): More use of atoms, please!
             // FIXME(Ms2ger): this is nonsense! Invalid values also end up as
             //                a text field
@@ -401,11 +406,11 @@ impl LayoutElementHelpers for LayoutJS<Element> {
         }
 
 
-        let width = if let Some(this) = HTMLIFrameElementCast::to_layout_js(self) {
+        let width = if let Some(this) = self.downcast::<HTMLIFrameElement>() {
             (*this.unsafe_get()).get_width()
-        } else if let Some(this) = HTMLTableElementCast::to_layout_js(self) {
+        } else if let Some(this) = self.downcast::<HTMLTableElement>() {
             (*this.unsafe_get()).get_width()
-        } else if let Some(this) = HTMLTableCellElementCast::to_layout_js(self) {
+        } else if let Some(this) = self.downcast::<HTMLTableCellElement>() {
             this.get_width()
         } else {
             LengthOrPercentageOrAuto::Auto
@@ -428,7 +433,7 @@ impl LayoutElementHelpers for LayoutJS<Element> {
         }
 
 
-        let height = if let Some(this) = HTMLIFrameElementCast::to_layout_js(self) {
+        let height = if let Some(this) = self.downcast::<HTMLIFrameElement>() {
             (*this.unsafe_get()).get_height()
         } else {
             LengthOrPercentageOrAuto::Auto
@@ -451,7 +456,7 @@ impl LayoutElementHelpers for LayoutJS<Element> {
         }
 
 
-        let cols = if let Some(this) = HTMLTextAreaElementCast::to_layout_js(self) {
+        let cols = if let Some(this) = self.downcast::<HTMLTextAreaElement>() {
             match (*this.unsafe_get()).get_cols_for_layout() {
                 0 => None,
                 c => Some(c as i32),
@@ -473,7 +478,7 @@ impl LayoutElementHelpers for LayoutJS<Element> {
         }
 
 
-        let rows = if let Some(this) = HTMLTextAreaElementCast::to_layout_js(self) {
+        let rows = if let Some(this) = self.downcast::<HTMLTextAreaElement>() {
             match (*this.unsafe_get()).get_rows_for_layout() {
                 0 => None,
                 r => Some(r as i32),
@@ -493,7 +498,7 @@ impl LayoutElementHelpers for LayoutJS<Element> {
         }
 
 
-        let border = if let Some(this) = HTMLTableElementCast::to_layout_js(self) {
+        let border = if let Some(this) = self.downcast::<HTMLTableElement>() {
             (*this.unsafe_get()).get_border()
         } else {
             None
@@ -522,7 +527,7 @@ impl LayoutElementHelpers for LayoutJS<Element> {
                                                         -> Option<u32> {
         match attribute {
             UnsignedIntegerAttribute::ColSpan => {
-                if let Some(this) = HTMLTableCellElementCast::to_layout_js(self) {
+                if let Some(this) = self.downcast::<HTMLTableCellElement>() {
                     this.get_colspan()
                 } else {
                     // Don't panic since `display` can cause this to be called on arbitrary
@@ -539,7 +544,7 @@ impl LayoutElementHelpers for LayoutJS<Element> {
         if (*self.unsafe_get()).namespace != ns!(HTML) {
             return false
         }
-        let node = NodeCast::from_layout_js(&self);
+        let node = self.upcast::<Node>();
         node.owner_doc_for_layout().is_html_document_for_layout()
     }
 
@@ -580,7 +585,7 @@ impl LayoutElementHelpers for LayoutJS<Element> {
     #[allow(unsafe_code)]
     fn get_checked_state_for_layout(&self) -> bool {
         // TODO option and menuitem can also have a checked state.
-        match HTMLInputElementCast::to_layout_js(self) {
+        match self.downcast::<HTMLInputElement>() {
             Some(input) => unsafe {
                 (*input.unsafe_get()).get_checked_state_for_layout()
             },
@@ -592,7 +597,7 @@ impl LayoutElementHelpers for LayoutJS<Element> {
     #[allow(unsafe_code)]
     fn get_indeterminate_state_for_layout(&self) -> bool {
         // TODO progress elements can also be matched with :indeterminate
-        match HTMLInputElementCast::to_layout_js(self) {
+        match self.downcast::<HTMLInputElement>() {
             Some(input) => unsafe {
                 (*input.unsafe_get()).get_indeterminate_state_for_layout()
             },
@@ -618,7 +623,7 @@ pub enum StylePriority {
 
 impl Element {
     pub fn html_element_in_html_document(&self) -> bool {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         self.namespace == ns!(HTML) && node.is_in_html_doc()
     }
 
@@ -779,7 +784,7 @@ impl Element {
     }
 
     pub fn serialize(&self, traversal_scope: TraversalScope) -> Fallible<DOMString> {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         let mut writer = vec![];
         match serialize(&mut writer, &node,
                         SerializeOpts {
@@ -793,17 +798,17 @@ impl Element {
 
     // https://html.spec.whatwg.org/multipage/#root-element
     pub fn get_root_element(&self) -> Root<Element> {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         node.inclusive_ancestors()
-            .filter_map(ElementCast::to_root)
+            .filter_map(Root::downcast::<Element>)
             .last()
             .expect("We know inclusive_ancestors will return `self` which is an element")
     }
 
     // https://dom.spec.whatwg.org/#locate-a-namespace-prefix
     pub fn lookup_prefix(&self, namespace: Namespace) -> Option<DOMString> {
-        for node in NodeCast::from_ref(self).inclusive_ancestors() {
-            match ElementCast::to_ref(node.r()) {
+        for node in self.upcast::<Node>().inclusive_ancestors() {
+            match node.downcast::<Element>() {
                 Some(element) => {
                     // Step 1.
                     if *element.namespace() == namespace {
@@ -836,7 +841,7 @@ impl Element {
             return false;
         }
         // TODO: Check whether the element is being rendered (i.e. not hidden).
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         if node.get_flag(SEQUENTIALLY_FOCUSABLE) {
             return true;
         }
@@ -853,7 +858,7 @@ impl Element {
     }
 
     pub fn is_actually_disabled(&self) -> bool {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         match node.type_id() {
             NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLButtonElement)) |
             NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLInputElement)) |
@@ -884,7 +889,7 @@ impl Element {
         let attr = Attr::new(&window, local_name, value, name, namespace, prefix, Some(self));
         self.attrs.borrow_mut().push(JS::from_rooted(&attr));
         if in_empty_ns {
-            vtable_for(NodeCast::from_ref(self)).attribute_mutated(
+            vtable_for(self.upcast::<Node>()).attribute_mutated(
                 &attr, AttributeMutation::Set(None));
         }
     }
@@ -969,7 +974,7 @@ impl Element {
     pub fn parse_attribute(&self, namespace: &Namespace, local_name: &Atom,
                        value: DOMString) -> AttrValue {
         if *namespace == ns!("") {
-            vtable_for(&NodeCast::from_ref(self))
+            vtable_for(&self.upcast::<Node>())
                 .parse_plain_attribute(local_name, value)
         } else {
             AttrValue::String(value)
@@ -996,7 +1001,7 @@ impl Element {
             let attr = (*self.attrs.borrow())[idx].root();
             self.attrs.borrow_mut().remove(idx);
             attr.set_owner(None);
-            let node = NodeCast::from_ref(self);
+            let node = self.upcast::<Node>();
             if attr.namespace() == &ns!("") {
                 vtable_for(node).attribute_mutated(&attr, AttributeMutation::Removed);
             }
@@ -1006,7 +1011,7 @@ impl Element {
 
     pub fn has_class(&self, name: &Atom) -> bool {
         let quirks_mode = {
-            let node = NodeCast::from_ref(self);
+            let node = self.upcast::<Node>();
             let owner_doc = node.owner_doc();
             owner_doc.r().quirks_mode()
         };
@@ -1172,7 +1177,7 @@ impl ElementMethods for Element {
     fn Attributes(&self) -> Root<NamedNodeMap> {
         self.attr_list.or_init(|| {
             let doc = {
-                let node = NodeCast::from_ref(self);
+                let node = self.upcast::<Node>();
                 node.owner_doc()
             };
             let window = doc.r().window();
@@ -1272,26 +1277,26 @@ impl ElementMethods for Element {
     // https://dom.spec.whatwg.org/#dom-element-getelementsbytagname
     fn GetElementsByTagName(&self, localname: DOMString) -> Root<HTMLCollection> {
         let window = window_from_node(self);
-        HTMLCollection::by_tag_name(window.r(), NodeCast::from_ref(self), localname)
+        HTMLCollection::by_tag_name(window.r(), self.upcast::<Node>(), localname)
     }
 
     // https://dom.spec.whatwg.org/#dom-element-getelementsbytagnamens
     fn GetElementsByTagNameNS(&self, maybe_ns: Option<DOMString>,
                               localname: DOMString) -> Root<HTMLCollection> {
         let window = window_from_node(self);
-        HTMLCollection::by_tag_name_ns(window.r(), NodeCast::from_ref(self), localname, maybe_ns)
+        HTMLCollection::by_tag_name_ns(window.r(), self.upcast::<Node>(), localname, maybe_ns)
     }
 
     // https://dom.spec.whatwg.org/#dom-element-getelementsbyclassname
     fn GetElementsByClassName(&self, classes: DOMString) -> Root<HTMLCollection> {
         let window = window_from_node(self);
-        HTMLCollection::by_class_name(window.r(), NodeCast::from_ref(self), classes)
+        HTMLCollection::by_class_name(window.r(), self.upcast::<Node>(), classes)
     }
 
     // https://drafts.csswg.org/cssom-view/#dom-element-getclientrects
     fn GetClientRects(&self) -> Root<DOMRectList> {
         let win = window_from_node(self);
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         let raw_rects = node.get_content_boxes();
         let rects = raw_rects.iter().map(|rect| {
             DOMRect::new(GlobalRef::Window(win.r()),
@@ -1306,7 +1311,7 @@ impl ElementMethods for Element {
     // https://drafts.csswg.org/cssom-view/#dom-element-getboundingclientrect
     fn GetBoundingClientRect(&self) -> Root<DOMRect> {
         let win = window_from_node(self);
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         let rect = node.get_bounding_content_box();
         DOMRect::new(GlobalRef::Window(win.r()),
                      rect.origin.x.to_f64_px(),
@@ -1317,25 +1322,25 @@ impl ElementMethods for Element {
 
     // https://drafts.csswg.org/cssom-view/#dom-element-clienttop
     fn ClientTop(&self) -> i32 {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         node.get_client_rect().origin.y
     }
 
     // https://drafts.csswg.org/cssom-view/#dom-element-clientleft
     fn ClientLeft(&self) -> i32 {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         node.get_client_rect().origin.x
     }
 
     // https://drafts.csswg.org/cssom-view/#dom-element-clientwidth
     fn ClientWidth(&self) -> i32 {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         node.get_client_rect().size.width
     }
 
     // https://drafts.csswg.org/cssom-view/#dom-element-clientheight
     fn ClientHeight(&self) -> i32 {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         node.get_client_rect().size.height
     }
 
@@ -1347,17 +1352,17 @@ impl ElementMethods for Element {
 
     /// https://w3c.github.io/DOM-Parsing/#widl-Element-innerHTML
     fn SetInnerHTML(&self, value: DOMString) -> Fallible<()> {
-        let context_node = NodeCast::from_ref(self);
+        let context_node = self.upcast::<Node>();
         // Step 1.
         let frag = try!(context_node.parse_fragment(value));
         // Step 2.
         // https://github.com/w3c/DOM-Parsing/issues/1
-        let target = if let Some(template) = HTMLTemplateElementCast::to_ref(self) {
-            NodeCast::from_root(template.Content())
+        let target = if let Some(template) = self.downcast::<HTMLTemplateElement>() {
+            Root::upcast::<Node>(template.Content())
         } else {
             Root::from_ref(context_node)
         };
-        Node::replace_all(Some(NodeCast::from_ref(&*frag)), &target);
+        Node::replace_all(Some(frag.upcast::<Node>()), &target);
         Ok(())
     }
 
@@ -1369,7 +1374,7 @@ impl ElementMethods for Element {
     // https://dvcs.w3.org/hg/innerhtml/raw-file/tip/index.html#widl-Element-outerHTML
     fn SetOuterHTML(&self, value: DOMString) -> Fallible<()> {
         let context_document = document_from_node(self);
-        let context_node = NodeCast::from_ref(self);
+        let context_node = self.upcast::<Node>();
         // Step 1.
         let context_parent = match context_node.GetParentNode() {
             None => {
@@ -1388,7 +1393,7 @@ impl ElementMethods for Element {
                 let body_elem = Element::create(QualName::new(ns!(HTML), atom!(body)),
                                                 None, context_document.r(),
                                                 ElementCreator::ScriptCreated);
-                NodeCast::from_root(body_elem)
+                Root::upcast::<Node>(body_elem)
             },
             _ => context_node.GetParentNode().unwrap()
         };
@@ -1396,84 +1401,84 @@ impl ElementMethods for Element {
         // Step 5.
         let frag = try!(parent.r().parse_fragment(value));
         // Step 6.
-        try!(context_parent.r().ReplaceChild(NodeCast::from_ref(frag.r()),
+        try!(context_parent.r().ReplaceChild(frag.upcast::<Node>(),
                                              context_node));
         Ok(())
     }
 
     // https://dom.spec.whatwg.org/#dom-nondocumenttypechildnode-previouselementsibling
     fn GetPreviousElementSibling(&self) -> Option<Root<Element>> {
-        NodeCast::from_ref(self).preceding_siblings()
-                                .filter_map(ElementCast::to_root).next()
+        self.upcast::<Node>().preceding_siblings()
+                             .filter_map(Root::downcast::<Element>).next()
     }
 
     // https://dom.spec.whatwg.org/#dom-nondocumenttypechildnode-nextelementsibling
     fn GetNextElementSibling(&self) -> Option<Root<Element>> {
-        NodeCast::from_ref(self).following_siblings()
-                                .filter_map(ElementCast::to_root).next()
+        self.upcast::<Node>().following_siblings()
+                             .filter_map(Root::downcast::<Element>).next()
     }
 
     // https://dom.spec.whatwg.org/#dom-parentnode-children
     fn Children(&self) -> Root<HTMLCollection> {
         let window = window_from_node(self);
-        HTMLCollection::children(window.r(), NodeCast::from_ref(self))
+        HTMLCollection::children(window.r(), self.upcast::<Node>())
     }
 
     // https://dom.spec.whatwg.org/#dom-parentnode-firstelementchild
     fn GetFirstElementChild(&self) -> Option<Root<Element>> {
-        NodeCast::from_ref(self).child_elements().next()
+        self.upcast::<Node>().child_elements().next()
     }
 
     // https://dom.spec.whatwg.org/#dom-parentnode-lastelementchild
     fn GetLastElementChild(&self) -> Option<Root<Element>> {
-        NodeCast::from_ref(self).rev_children().filter_map(ElementCast::to_root).next()
+        self.upcast::<Node>().rev_children().filter_map(Root::downcast::<Element>).next()
     }
 
     // https://dom.spec.whatwg.org/#dom-parentnode-childelementcount
     fn ChildElementCount(&self) -> u32 {
-        NodeCast::from_ref(self).child_elements().count() as u32
+        self.upcast::<Node>().child_elements().count() as u32
     }
 
     // https://dom.spec.whatwg.org/#dom-parentnode-prepend
     fn Prepend(&self, nodes: Vec<NodeOrString>) -> ErrorResult {
-        NodeCast::from_ref(self).prepend(nodes)
+        self.upcast::<Node>().prepend(nodes)
     }
 
     // https://dom.spec.whatwg.org/#dom-parentnode-append
     fn Append(&self, nodes: Vec<NodeOrString>) -> ErrorResult {
-        NodeCast::from_ref(self).append(nodes)
+        self.upcast::<Node>().append(nodes)
     }
 
     // https://dom.spec.whatwg.org/#dom-parentnode-queryselector
     fn QuerySelector(&self, selectors: DOMString) -> Fallible<Option<Root<Element>>> {
-        let root = NodeCast::from_ref(self);
+        let root = self.upcast::<Node>();
         root.query_selector(selectors)
     }
 
     // https://dom.spec.whatwg.org/#dom-parentnode-queryselectorall
     fn QuerySelectorAll(&self, selectors: DOMString) -> Fallible<Root<NodeList>> {
-        let root = NodeCast::from_ref(self);
+        let root = self.upcast::<Node>();
         root.query_selector_all(selectors)
     }
 
     // https://dom.spec.whatwg.org/#dom-childnode-before
     fn Before(&self, nodes: Vec<NodeOrString>) -> ErrorResult {
-        NodeCast::from_ref(self).before(nodes)
+        self.upcast::<Node>().before(nodes)
     }
 
     // https://dom.spec.whatwg.org/#dom-childnode-after
     fn After(&self, nodes: Vec<NodeOrString>) -> ErrorResult {
-        NodeCast::from_ref(self).after(nodes)
+        self.upcast::<Node>().after(nodes)
     }
 
     // https://dom.spec.whatwg.org/#dom-childnode-replacewith
     fn ReplaceWith(&self, nodes: Vec<NodeOrString>) -> ErrorResult {
-        NodeCast::from_ref(self).replace_with(nodes)
+        self.upcast::<Node>().replace_with(nodes)
     }
 
     // https://dom.spec.whatwg.org/#dom-childnode-remove
     fn Remove(&self) {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         node.remove_self();
     }
 
@@ -1492,9 +1497,9 @@ impl ElementMethods for Element {
         match parse_author_origin_selector_list_from_str(&selectors) {
             Err(()) => Err(Error::Syntax),
             Ok(ref selectors) => {
-                let root = NodeCast::from_ref(self);
+                let root = self.upcast::<Node>();
                 for element in root.inclusive_ancestors() {
-                    if let Some(element) = ElementCast::to_root(element) {
+                    if let Some(element) = Root::downcast::<Element>(element) {
                         if matches(selectors, &element, None) {
                             return Ok(Some(element));
                         }
@@ -1508,13 +1513,13 @@ impl ElementMethods for Element {
 
 impl VirtualMethods for Element {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let node: &Node = NodeCast::from_ref(self);
+        let node: &Node = self.upcast::<Node>();
         Some(node as &VirtualMethods)
     }
 
     fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
         self.super_type().unwrap().attribute_mutated(attr, mutation);
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         let doc = node.owner_doc();
         let damage = match attr.local_name() {
             &atom!(style) => {
@@ -1607,7 +1612,7 @@ impl VirtualMethods for Element {
 
 impl<'a> ::selectors::Element for Root<Element> {
     fn parent_element(&self) -> Option<Root<Element>> {
-        NodeCast::from_ref(&**self).GetParentElement()
+        self.upcast::<Node>().GetParentElement()
     }
 
     fn first_child_element(&self) -> Option<Root<Element>> {
@@ -1615,34 +1620,34 @@ impl<'a> ::selectors::Element for Root<Element> {
     }
 
     fn last_child_element(&self) -> Option<Root<Element>> {
-        self.node.rev_children().filter_map(ElementCast::to_root).next()
+        self.node.rev_children().filter_map(Root::downcast::<Element>).next()
     }
 
     fn prev_sibling_element(&self) -> Option<Root<Element>> {
-        self.node.preceding_siblings().filter_map(ElementCast::to_root).next()
+        self.node.preceding_siblings().filter_map(Root::downcast::<Element>).next()
     }
 
     fn next_sibling_element(&self) -> Option<Root<Element>> {
-        self.node.following_siblings().filter_map(ElementCast::to_root).next()
+        self.node.following_siblings().filter_map(Root::downcast::<Element>).next()
     }
 
     fn is_root(&self) -> bool {
         match self.node.GetParentNode() {
             None => false,
-            Some(node) => node.is_document(),
+            Some(node) => node.is::<Document>(),
         }
     }
 
     fn is_empty(&self) -> bool {
-        self.node.children().all(|node| !node.is_element() && match TextCast::to_ref(&*node) {
+        self.node.children().all(|node| !node.is::<Element>() && match node.downcast::<Text>() {
             None => true,
-            Some(text) => CharacterDataCast::from_ref(text).data().is_empty()
+            Some(text) => text.upcast::<CharacterData>().data().is_empty()
         })
     }
 
     fn is_link(&self) -> bool {
         // FIXME: This is HTML only.
-        let node = NodeCast::from_ref(&**self);
+        let node = self.upcast::<Node>();
         match node.type_id() {
             // https://html.spec.whatwg.org/multipage/#selector-link
             NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLAnchorElement)) |
@@ -1696,14 +1701,14 @@ impl<'a> ::selectors::Element for Root<Element> {
         Element::get_enabled_state(self)
     }
     fn get_checked_state(&self) -> bool {
-        let input_element: Option<&HTMLInputElement> = HTMLInputElementCast::to_ref(&**self);
+        let input_element: Option<&HTMLInputElement> = self.downcast::<HTMLInputElement>();
         match input_element {
             Some(input) => input.Checked(),
             None => false,
         }
     }
     fn get_indeterminate_state(&self) -> bool {
-        let input_element: Option<&HTMLInputElement> = HTMLInputElementCast::to_ref(&**self);
+        let input_element: Option<&HTMLInputElement> = self.downcast::<HTMLInputElement>();
         match input_element {
             Some(input) => input.get_indeterminate_state(),
             None => false,
@@ -1724,7 +1729,7 @@ impl<'a> ::selectors::Element for Root<Element> {
         }
     }
     fn has_servo_nonzero_border(&self) -> bool {
-        let table_element: Option<&HTMLTableElement> = HTMLTableElementCast::to_ref(&**self);
+        let table_element: Option<&HTMLTableElement> = self.downcast::<HTMLTableElement>();
         match table_element {
             None => false,
             Some(this) => {
@@ -1769,14 +1774,14 @@ impl<'a> ::selectors::Element for Root<Element> {
 
 impl Element {
     pub fn as_maybe_activatable(&self) -> Option<&Activatable> {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         let element = match node.type_id() {
             NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLInputElement)) => {
-                let element = HTMLInputElementCast::to_ref(self).unwrap();
+                let element = self.downcast::<HTMLInputElement>().unwrap();
                 Some(element as &Activatable)
             },
             NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLAnchorElement)) => {
-                let element = HTMLAnchorElementCast::to_ref(self).unwrap();
+                let element = self.downcast::<HTMLAnchorElement>().unwrap();
                 Some(element as &Activatable)
             },
             _ => {
@@ -1793,12 +1798,12 @@ impl Element {
     }
 
     pub fn click_in_progress(&self) -> bool {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         node.get_flag(CLICK_IN_PROGRESS)
     }
 
     pub fn set_click_in_progress(&self, click: bool) {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         node.set_flag(CLICK_IN_PROGRESS, click)
     }
 
@@ -1807,9 +1812,9 @@ impl Element {
         match self.as_maybe_activatable() {
             Some(el) => Some(Root::from_ref(el.as_element())),
             None => {
-                let node = NodeCast::from_ref(self);
+                let node = self.upcast::<Node>();
                 for node in node.ancestors() {
-                    if let Some(node) = ElementCast::to_ref(node.r()) {
+                    if let Some(node) = node.downcast::<Element>() {
                         if node.as_maybe_activatable().is_some() {
                             return Some(Root::from_ref(node))
                         }
@@ -1833,7 +1838,7 @@ impl Element {
         // the script can generate more click events from the handler)
         assert!(!self.click_in_progress());
 
-        let target = EventTargetCast::from_ref(self);
+        let target = self.upcast::<EventTarget>();
         // Step 2 (requires canvas support)
         // Step 3
         self.set_click_in_progress(true);
@@ -1870,7 +1875,7 @@ impl Element {
         };
         self.event_state.set(state);
 
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         node.dirty(NodeDamage::NodeStyleDamaged);
     }
 
@@ -1917,20 +1922,20 @@ impl Element {
 
 impl Element {
     pub fn check_ancestors_disabled_state_for_form_control(&self) {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         if self.get_disabled_state() { return; }
         for ancestor in node.ancestors() {
             let ancestor = ancestor;
             let ancestor = ancestor.r();
-            if !ancestor.is_htmlfieldsetelement() { continue; }
-            if !ElementCast::to_ref(ancestor).unwrap().get_disabled_state() { continue; }
+            if !ancestor.is::<HTMLFieldSetElement>() { continue; }
+            if !ancestor.downcast::<Element>().unwrap().get_disabled_state() { continue; }
             if ancestor.is_parent_of(node) {
                 self.set_disabled_state(true);
                 self.set_enabled_state(false);
                 return;
             }
             match ancestor.children()
-                          .find(|child| child.r().is_htmllegendelement())
+                          .find(|child| child.r().is::<HTMLLegendElement>())
             {
                 Some(ref legend) => {
                     // XXXabinader: should we save previous ancestor to avoid this iteration?
@@ -1946,9 +1951,9 @@ impl Element {
 
     pub fn check_parent_disabled_state_for_option(&self) {
         if self.get_disabled_state() { return; }
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         if let Some(ref parent) = node.GetParentNode() {
-            if parent.r().is_htmloptgroupelement() && ElementCast::to_ref(parent.r()).unwrap().get_disabled_state() {
+            if parent.r().is::<HTMLOptGroupElement>() && parent.downcast::<Element>().unwrap().get_disabled_state() {
                 self.set_disabled_state(true);
                 self.set_enabled_state(false);
             }
diff --git a/components/script/dom/errorevent.rs b/components/script/dom/errorevent.rs
index b408b2f8525..39327d967cf 100644
--- a/components/script/dom/errorevent.rs
+++ b/components/script/dom/errorevent.rs
@@ -6,7 +6,7 @@ use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::ErrorEventBinding;
 use dom::bindings::codegen::Bindings::ErrorEventBinding::ErrorEventMethods;
 use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
-use dom::bindings::codegen::InheritTypes::EventCast;
+use dom::bindings::conversions::Castable;
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{MutHeapJSVal, Root};
@@ -59,7 +59,7 @@ impl ErrorEvent {
                error: HandleValue) -> Root<ErrorEvent> {
         let ev = ErrorEvent::new_uninitialized(global);
         {
-            let event = EventCast::from_ref(ev.r());
+            let event = ev.upcast::<Event>();
             event.InitEvent(type_, bubbles == EventBubbles::Bubbles,
                             cancelable == EventCancelable::Cancelable);
             *ev.message.borrow_mut() = message;
diff --git a/components/script/dom/eventdispatcher.rs b/components/script/dom/eventdispatcher.rs
index 64e8b57d2e2..9df978fa589 100644
--- a/components/script/dom/eventdispatcher.rs
+++ b/components/script/dom/eventdispatcher.rs
@@ -5,7 +5,7 @@
 use devtools_traits::{StartedTimelineMarker, TimelineMarker, TimelineMarkerType};
 use dom::bindings::callback::ExceptionHandling::Report;
 use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
-use dom::bindings::codegen::InheritTypes::{EventTargetCast, NodeCast};
+use dom::bindings::conversions::Castable;
 use dom::bindings::global::{GlobalRoot, global_object_for_reflector};
 use dom::bindings::js::{JS, Root, RootedReference};
 use dom::bindings::trace::RootedVec;
@@ -148,9 +148,9 @@ pub fn dispatch_event(target: &EventTarget, pseudo_target: Option<&EventTarget>,
     event.set_dispatching(true);
 
     let mut chain: RootedVec<JS<EventTarget>> = RootedVec::new();
-    if let Some(target_node) = NodeCast::to_ref(target) {
+    if let Some(target_node) = target.downcast::<Node>() {
         for ancestor in target_node.ancestors() {
-            let ancestor_target = EventTargetCast::from_ref(ancestor.r());
+            let ancestor_target = ancestor.upcast::<EventTarget>();
             chain.push(JS::from_ref(ancestor_target))
         }
     }
@@ -161,7 +161,7 @@ pub fn dispatch_event(target: &EventTarget, pseudo_target: Option<&EventTarget>,
     let target = event.GetTarget();
     match target {
         Some(ref target) => {
-            let node: Option<&Node> = NodeCast::to_ref(target.r());
+            let node: Option<&Node> = target.downcast::<Node>();
             match node {
                 Some(node) => {
                     let vtable = vtable_for(&node);
diff --git a/components/script/dom/filereader.rs b/components/script/dom/filereader.rs
index a659908f31c..547234101d1 100644
--- a/components/script/dom/filereader.rs
+++ b/components/script/dom/filereader.rs
@@ -5,7 +5,7 @@
 use dom::bindings::codegen::Bindings::BlobBinding::BlobMethods;
 use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
 use dom::bindings::codegen::Bindings::FileReaderBinding::{self, FileReaderConstants, FileReaderMethods};
-use dom::bindings::codegen::InheritTypes::{EventCast, EventTargetCast};
+use dom::bindings::conversions::Castable;
 use dom::bindings::error::{Error, ErrorResult, Fallible};
 use dom::bindings::global::{GlobalField, GlobalRef};
 use dom::bindings::js::{JS, MutNullableHeap, Root};
@@ -13,7 +13,7 @@ use dom::bindings::refcounted::Trusted;
 use dom::bindings::utils::{Reflectable, reflect_dom_object};
 use dom::blob::Blob;
 use dom::domexception::{DOMErrorName, DOMException};
-use dom::event::{EventBubbles, EventCancelable};
+use dom::event::{Event, EventBubbles, EventCancelable};
 use dom::eventtarget::EventTarget;
 use dom::progressevent::ProgressEvent;
 use encoding::all::UTF_8;
@@ -325,8 +325,8 @@ impl FileReader {
             type_, EventBubbles::DoesNotBubble, EventCancelable::NotCancelable,
             total.is_some(), loaded, total.unwrap_or(0));
 
-        let target = EventTargetCast::from_ref(self);
-        let event = EventCast::from_ref(progressevent.r());
+        let target = self.upcast::<EventTarget>();
+        let event = progressevent.upcast::<Event>();
         event.fire(target);
     }
 
diff --git a/components/script/dom/formdata.rs b/components/script/dom/formdata.rs
index d1de7a4cabd..a70387dabe1 100644
--- a/components/script/dom/formdata.rs
+++ b/components/script/dom/formdata.rs
@@ -5,9 +5,9 @@
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::FormDataBinding;
 use dom::bindings::codegen::Bindings::FormDataBinding::FormDataMethods;
-use dom::bindings::codegen::InheritTypes::FileCast;
 use dom::bindings::codegen::UnionTypes::FileOrString;
 use dom::bindings::codegen::UnionTypes::FileOrString::{eFile, eString};
+use dom::bindings::conversions::Castable;
 use dom::bindings::error::{Fallible};
 use dom::bindings::global::{GlobalField, GlobalRef};
 use dom::bindings::js::{JS, Root};
@@ -116,7 +116,7 @@ impl FormDataMethods for FormData {
 impl FormData {
     fn get_file_from_blob(&self, value: &Blob, filename: Option<DOMString>) -> Root<File> {
         let global = self.global.root();
-        let f: Option<&File> = FileCast::to_ref(value);
+        let f: Option<&File> = value.downcast::<File>();
         let name = filename.unwrap_or(f.map(|inner| inner.name().clone()).unwrap_or("blob".to_owned()));
         File::new(global.r(), value, name)
     }
diff --git a/components/script/dom/htmlanchorelement.rs b/components/script/dom/htmlanchorelement.rs
index 4e2c396b88e..dd1c88e16e6 100644
--- a/components/script/dom/htmlanchorelement.rs
+++ b/components/script/dom/htmlanchorelement.rs
@@ -10,8 +10,7 @@ use dom::bindings::codegen::Bindings::HTMLAnchorElementBinding;
 use dom::bindings::codegen::Bindings::HTMLAnchorElementBinding::HTMLAnchorElementMethods;
 use dom::bindings::codegen::Bindings::MouseEventBinding::MouseEventMethods;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLImageElementDerived, MouseEventCast, NodeCast};
+use dom::bindings::conversions::Castable;
 use dom::bindings::js::{JS, MutNullableHeap, Root};
 use dom::document::Document;
 use dom::domtokenlist::DOMTokenList;
@@ -19,6 +18,8 @@ use dom::element::Element;
 use dom::event::Event;
 use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
+use dom::htmlimageelement::HTMLImageElement;
+use dom::mouseevent::MouseEvent;
 use dom::node::{Node, document_from_node, window_from_node};
 use dom::virtualmethods::VirtualMethods;
 use num::ToPrimitive;
@@ -55,7 +56,7 @@ impl HTMLAnchorElement {
 
 impl VirtualMethods for HTMLAnchorElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = HTMLElementCast::from_ref(self);
+        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
         Some(htmlelement as &VirtualMethods)
     }
 
@@ -70,20 +71,20 @@ impl VirtualMethods for HTMLAnchorElement {
 impl HTMLAnchorElementMethods for HTMLAnchorElement {
     // https://html.spec.whatwg.org/multipage/#dom-a-text
     fn Text(&self) -> DOMString {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         node.GetTextContent().unwrap()
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-a-text
     fn SetText(&self, value: DOMString) {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         node.SetTextContent(Some(value))
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-a-rellist
     fn RelList(&self) -> Root<DOMTokenList> {
         self.rel_list.or_init(|| {
-            DOMTokenList::new(ElementCast::from_ref(self), &atom!("rel"))
+            DOMTokenList::new(self.upcast::<Element>(), &atom!("rel"))
         })
     }
 
@@ -114,7 +115,7 @@ impl HTMLAnchorElementMethods for HTMLAnchorElement {
 
 impl Activatable for HTMLAnchorElement {
     fn as_element(&self) -> &Element {
-        ElementCast::from_ref(self)
+        self.upcast::<Element>()
     }
 
     fn is_instance_activatable(&self) -> bool {
@@ -123,7 +124,7 @@ impl Activatable for HTMLAnchorElement {
         // hyperlink"
         // https://html.spec.whatwg.org/multipage/#the-a-element
         // "The activation behaviour of a elements *that create hyperlinks*"
-        ElementCast::from_ref(self).has_attribute(&atom!("href"))
+        self.upcast::<Element>().has_attribute(&atom!("href"))
     }
 
 
@@ -145,13 +146,13 @@ impl Activatable for HTMLAnchorElement {
         }
         //TODO: Step 2. Check if browsing context is specified and act accordingly.
         //Step 3. Handle <img ismap/>.
-        let element = ElementCast::from_ref(self);
-        let mouse_event = MouseEventCast::to_ref(event).unwrap();
+        let element = self.upcast::<Element>();
+        let mouse_event = event.downcast::<MouseEvent>().unwrap();
         let mut ismap_suffix = None;
-        if let Some(element) = ElementCast::to_ref(target) {
-            if target.is_htmlimageelement() && element.has_attribute(&atom!("ismap")) {
+        if let Some(element) = target.downcast::<Element>() {
+            if target.is::<HTMLImageElement>() && element.has_attribute(&atom!("ismap")) {
 
-                let target_node = NodeCast::from_ref(element);
+                let target_node = element.upcast::<Node>();
                 let rect = window_from_node(target_node).r().content_box_query(
                     target_node.to_trusted_node_address());
                 ismap_suffix = Some(
diff --git a/components/script/dom/htmlappletelement.rs b/components/script/dom/htmlappletelement.rs
index d3ae9eb5bee..801fafa2593 100644
--- a/components/script/dom/htmlappletelement.rs
+++ b/components/script/dom/htmlappletelement.rs
@@ -5,7 +5,7 @@
 use dom::attr::AttrValue;
 use dom::bindings::codegen::Bindings::HTMLAppletElementBinding;
 use dom::bindings::codegen::Bindings::HTMLAppletElementBinding::HTMLAppletElementMethods;
-use dom::bindings::codegen::InheritTypes::HTMLElementCast;
+use dom::bindings::conversions::Castable;
 use dom::bindings::js::Root;
 use dom::document::Document;
 use dom::htmlelement::HTMLElement;
@@ -48,7 +48,7 @@ impl HTMLAppletElementMethods for HTMLAppletElement {
 
 impl VirtualMethods for HTMLAppletElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        Some(HTMLElementCast::from_ref(self) as &VirtualMethods)
+        Some(self.upcast::<HTMLElement>() as &VirtualMethods)
     }
 
     fn parse_plain_attribute(&self, name: &Atom, value: DOMString) -> AttrValue {
diff --git a/components/script/dom/htmlareaelement.rs b/components/script/dom/htmlareaelement.rs
index d03e0045c8f..274d5ce89f0 100644
--- a/components/script/dom/htmlareaelement.rs
+++ b/components/script/dom/htmlareaelement.rs
@@ -5,11 +5,12 @@
 use dom::attr::AttrValue;
 use dom::bindings::codegen::Bindings::HTMLAreaElementBinding;
 use dom::bindings::codegen::Bindings::HTMLAreaElementBinding::HTMLAreaElementMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast};
+use dom::bindings::conversions::Castable;
 use dom::bindings::js::{JS, MutNullableHeap, Root};
 use dom::bindings::utils::Reflectable;
 use dom::document::Document;
 use dom::domtokenlist::DOMTokenList;
+use dom::element::Element;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use dom::virtualmethods::VirtualMethods;
@@ -42,7 +43,7 @@ impl HTMLAreaElement {
 
 impl VirtualMethods for HTMLAreaElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = HTMLElementCast::from_ref(self);
+        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
         Some(htmlelement as &VirtualMethods)
     }
 
@@ -58,7 +59,7 @@ impl HTMLAreaElementMethods for HTMLAreaElement {
     // https://html.spec.whatwg.org/multipage/#dom-area-rellist
     fn RelList(&self) -> Root<DOMTokenList> {
         self.rel_list.or_init(|| {
-            DOMTokenList::new(ElementCast::from_ref(self), &atom!("rel"))
+            DOMTokenList::new(self.upcast::<Element>(), &atom!("rel"))
         })
     }
 }
diff --git a/components/script/dom/htmlbaseelement.rs b/components/script/dom/htmlbaseelement.rs
index 0708d16e2dd..dd3c79b06cd 100644
--- a/components/script/dom/htmlbaseelement.rs
+++ b/components/script/dom/htmlbaseelement.rs
@@ -4,10 +4,10 @@
 
 use dom::attr::Attr;
 use dom::bindings::codegen::Bindings::HTMLBaseElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast};
+use dom::bindings::conversions::Castable;
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::element::AttributeMutation;
+use dom::element::{AttributeMutation, Element};
 use dom::htmlelement::HTMLElement;
 use dom::node::{Node, document_from_node};
 use dom::virtualmethods::VirtualMethods;
@@ -36,7 +36,7 @@ impl HTMLBaseElement {
 
     /// https://html.spec.whatwg.org/multipage/#frozen-base-url
     pub fn frozen_base_url(&self) -> Url {
-        let href = ElementCast::from_ref(self).get_attribute(&ns!(""), &atom!("href"))
+        let href = self.upcast::<Element>().get_attribute(&ns!(""), &atom!("href"))
             .expect("The frozen base url is only defined for base elements \
                      that have a base url.");
         let document = document_from_node(self);
@@ -52,7 +52,7 @@ impl HTMLBaseElement {
             return;
         }
 
-        if ElementCast::from_ref(self).has_attribute(&atom!("href")) {
+        if self.upcast::<Element>().has_attribute(&atom!("href")) {
             let document = document_from_node(self);
             document.refresh_base_element();
         }
@@ -61,7 +61,7 @@ impl HTMLBaseElement {
 
 impl VirtualMethods for HTMLBaseElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        Some(HTMLElementCast::from_ref(self) as &VirtualMethods)
+        Some(self.upcast::<HTMLElement>() as &VirtualMethods)
     }
 
     fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
diff --git a/components/script/dom/htmlbodyelement.rs b/components/script/dom/htmlbodyelement.rs
index d2c0ddadcd3..6cef068716f 100644
--- a/components/script/dom/htmlbodyelement.rs
+++ b/components/script/dom/htmlbodyelement.rs
@@ -8,11 +8,12 @@ use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
 use dom::bindings::codegen::Bindings::HTMLBodyElementBinding::{self, HTMLBodyElementMethods};
 use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, EventTargetCast, HTMLElementCast};
+use dom::bindings::conversions::Castable;
 use dom::bindings::js::Root;
 use dom::bindings::utils::Reflectable;
 use dom::document::Document;
-use dom::element::{AttributeMutation, RawLayoutElementHelpers};
+use dom::element::{AttributeMutation, Element, RawLayoutElementHelpers};
+use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::{Node, document_from_node, window_from_node};
 use dom::virtualmethods::VirtualMethods;
@@ -67,7 +68,7 @@ impl HTMLBodyElementMethods for HTMLBodyElement {
 
     // https://html.spec.whatwg.org/multipage/#dom-body-text
     fn SetText(&self, value: DOMString) {
-        let element = ElementCast::from_ref(self);
+        let element = self.upcast::<Element>();
         let color = str::parse_legacy_color(&value).ok();
         element.set_attribute(&Atom::from_slice("text"), AttrValue::Color(value, color));
     }
@@ -106,7 +107,7 @@ impl HTMLBodyElement {
     #[allow(unsafe_code)]
     pub fn get_color(&self) -> Option<RGBA> {
         unsafe {
-            ElementCast::from_ref(self)
+            self.upcast::<Element>()
                 .get_attr_for_layout(&ns!(""), &atom!("text"))
                 .and_then(AttrValue::as_color)
                 .cloned()
@@ -123,7 +124,7 @@ impl HTMLBodyElement {
 
 impl VirtualMethods for HTMLBodyElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let element: &HTMLElement = HTMLElementCast::from_ref(self);
+        let element: &HTMLElement = self.upcast::<HTMLElement>();
         Some(element as &VirtualMethods)
     }
 
@@ -180,8 +181,8 @@ impl VirtualMethods for HTMLBodyElement {
                     &atom!(onlanguagechange) | &atom!(onmessage) | &atom!(onoffline) | &atom!(ononline) |
                     &atom!(onpagehide) | &atom!(onpageshow) | &atom!(onpopstate) | &atom!(onstorage) |
                     &atom!(onresize) | &atom!(onunload) | &atom!(onerror)
-                      => EventTargetCast::from_ref(window.r()), // forwarded event
-                    _ => EventTargetCast::from_ref(self),
+                      => window.upcast::<EventTarget>(), // forwarded event
+                    _ => self.upcast::<EventTarget>(),
                 };
                 evtarget.set_event_handler_uncompiled(cx, url, reflector,
                                                       &name[2..],
diff --git a/components/script/dom/htmlbuttonelement.rs b/components/script/dom/htmlbuttonelement.rs
index ce33b3648f9..8f9c2bf420e 100644
--- a/components/script/dom/htmlbuttonelement.rs
+++ b/components/script/dom/htmlbuttonelement.rs
@@ -6,14 +6,14 @@ use dom::activation::Activatable;
 use dom::attr::Attr;
 use dom::bindings::codegen::Bindings::HTMLButtonElementBinding;
 use dom::bindings::codegen::Bindings::HTMLButtonElementBinding::HTMLButtonElementMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLButtonElementCast, HTMLElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLFieldSetElementDerived, NodeCast};
+use dom::bindings::conversions::Castable;
 use dom::bindings::js::Root;
 use dom::document::Document;
 use dom::element::{AttributeMutation, Element, IN_ENABLED_STATE};
 use dom::event::Event;
 use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
+use dom::htmlfieldsetelement::HTMLFieldSetElement;
 use dom::htmlformelement::{FormControl, FormSubmitter};
 use dom::htmlformelement::{SubmittedFrom, HTMLFormElement};
 use dom::node::{Node, document_from_node, window_from_node};
@@ -82,7 +82,7 @@ impl HTMLButtonElementMethods for HTMLButtonElement {
 
     // https://html.spec.whatwg.org/multipage/#dom-button-type
     fn Type(&self) -> DOMString {
-        let elem = ElementCast::from_ref(self);
+        let elem = self.upcast::<Element>();
         let mut ty = elem.get_string_attribute(&atom!("type"));
         ty.make_ascii_lowercase();
         // https://html.spec.whatwg.org/multipage/#attr-button-type
@@ -135,7 +135,7 @@ impl HTMLButtonElementMethods for HTMLButtonElement {
 
 impl VirtualMethods for HTMLButtonElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = HTMLElementCast::from_ref(self);
+        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
         Some(htmlelement as &VirtualMethods)
     }
 
@@ -143,7 +143,7 @@ impl VirtualMethods for HTMLButtonElement {
         self.super_type().unwrap().attribute_mutated(attr, mutation);
         match attr.local_name() {
             &atom!(disabled) => {
-                let el = ElementCast::from_ref(self);
+                let el = self.upcast::<Element>();
                 match mutation {
                     AttributeMutation::Set(Some(_)) => {}
                     AttributeMutation::Set(None) => {
@@ -166,7 +166,7 @@ impl VirtualMethods for HTMLButtonElement {
             s.bind_to_tree(tree_in_doc);
         }
 
-        let el = ElementCast::from_ref(self);
+        let el = self.upcast::<Element>();
         el.check_ancestors_disabled_state_for_form_control();
     }
 
@@ -175,9 +175,9 @@ impl VirtualMethods for HTMLButtonElement {
             s.unbind_from_tree(tree_in_doc);
         }
 
-        let node = NodeCast::from_ref(self);
-        let el = ElementCast::from_ref(self);
-        if node.ancestors().any(|ancestor| ancestor.r().is_htmlfieldsetelement()) {
+        let node = self.upcast::<Node>();
+        let el = self.upcast::<Element>();
+        if node.ancestors().any(|ancestor| ancestor.r().is::<HTMLFieldSetElement>()) {
             el.check_ancestors_disabled_state_for_form_control();
         } else {
             el.check_disabled_attribute();
@@ -189,12 +189,12 @@ impl FormControl for HTMLButtonElement {}
 
 impl<'a> Activatable for &'a HTMLButtonElement {
     fn as_element(&self) -> &Element {
-        ElementCast::from_ref(*self)
+        self.upcast::<Element>()
     }
 
     fn is_instance_activatable(&self) -> bool {
         //https://html.spec.whatwg.org/multipage/#the-button-element
-        let el = ElementCast::from_ref(*self);
+        let el = self.upcast::<Element>();
         !(el.get_disabled_state())
     }
 
@@ -226,14 +226,14 @@ impl<'a> Activatable for &'a HTMLButtonElement {
     #[allow(unsafe_code)]
     fn implicit_submission(&self, ctrlKey: bool, shiftKey: bool, altKey: bool, metaKey: bool) {
         let doc = document_from_node(*self);
-        let node = NodeCast::from_ref(doc.r());
+        let node = doc.upcast::<Node>();
         let owner = self.form_owner();
-        let elem = ElementCast::from_ref(*self);
+        let elem = self.upcast::<Element>();
         if owner.is_none() || elem.click_in_progress() {
             return;
         }
         node.query_selector_iter("button[type=submit]".to_owned()).unwrap()
-            .filter_map(HTMLButtonElementCast::to_root)
+            .filter_map(Root::downcast::<HTMLButtonElement>)
             .find(|r| r.r().form_owner() == owner)
             .map(|s| s.r().synthetic_click_activation(ctrlKey, shiftKey, altKey, metaKey));
     }
diff --git a/components/script/dom/htmlcanvaselement.rs b/components/script/dom/htmlcanvaselement.rs
index 620c5749073..75d2a4151e0 100644
--- a/components/script/dom/htmlcanvaselement.rs
+++ b/components/script/dom/htmlcanvaselement.rs
@@ -8,14 +8,14 @@ use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::HTMLCanvasElementBinding;
 use dom::bindings::codegen::Bindings::HTMLCanvasElementBinding::HTMLCanvasElementMethods;
 use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLContextAttributes;
-use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast};
 use dom::bindings::codegen::UnionTypes::CanvasRenderingContext2DOrWebGLRenderingContext;
+use dom::bindings::conversions::Castable;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{HeapGCValue, JS, LayoutJS, Root};
 use dom::bindings::utils::{Reflectable};
 use dom::canvasrenderingcontext2d::{CanvasRenderingContext2D, LayoutCanvasRenderingContext2DHelpers};
 use dom::document::Document;
-use dom::element::AttributeMutation;
+use dom::element::{AttributeMutation, Element};
 use dom::htmlelement::HTMLElement;
 use dom::node::{Node, window_from_node};
 use dom::virtualmethods::VirtualMethods;
@@ -225,7 +225,7 @@ impl HTMLCanvasElementMethods for HTMLCanvasElement {
 
     // https://html.spec.whatwg.org/multipage/#dom-canvas-width
     fn SetWidth(&self, width: u32) {
-        let elem = ElementCast::from_ref(self);
+        let elem = self.upcast::<Element>();
         elem.set_uint_attribute(&atom!("width"), width)
     }
 
@@ -236,7 +236,7 @@ impl HTMLCanvasElementMethods for HTMLCanvasElement {
 
     // https://html.spec.whatwg.org/multipage/#dom-canvas-height
     fn SetHeight(&self, height: u32) {
-        let elem = ElementCast::from_ref(self);
+        let elem = self.upcast::<Element>();
         elem.set_uint_attribute(&atom!("height"), height)
     }
 
@@ -264,7 +264,7 @@ impl HTMLCanvasElementMethods for HTMLCanvasElement {
 
 impl VirtualMethods for HTMLCanvasElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let element: &HTMLElement = HTMLElementCast::from_ref(self);
+        let element: &HTMLElement = self.upcast::<HTMLElement>();
         Some(element as &VirtualMethods)
     }
 
diff --git a/components/script/dom/htmlcollection.rs b/components/script/dom/htmlcollection.rs
index 71d57d94005..7d4e217147b 100644
--- a/components/script/dom/htmlcollection.rs
+++ b/components/script/dom/htmlcollection.rs
@@ -4,7 +4,7 @@
 
 use dom::bindings::codegen::Bindings::HTMLCollectionBinding;
 use dom::bindings::codegen::Bindings::HTMLCollectionBinding::HTMLCollectionMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, NodeCast};
+use dom::bindings::conversions::Castable;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, Root};
 use dom::bindings::trace::JSTraceable;
@@ -154,7 +154,7 @@ impl HTMLCollection {
         struct ElementChildFilter;
         impl CollectionFilter for ElementChildFilter {
             fn filter(&self, elem: &Element, root: &Node) -> bool {
-                root.is_parent_of(NodeCast::from_ref(elem))
+                root.is_parent_of(elem.upcast::<Node>())
             }
         }
         HTMLCollection::create(window, root, box ElementChildFilter)
@@ -186,7 +186,7 @@ impl<'a> Iterator for HTMLCollectionElementsIter<'a> {
         let filter = self.filter;
         let root = self.root.r();
         self.node_iter.by_ref()
-                      .filter_map(ElementCast::to_root)
+                      .filter_map(Root::downcast::<Element>)
                       .filter(|element| filter.filter(element.r(), root))
                       .next()
     }
diff --git a/components/script/dom/htmldatalistelement.rs b/components/script/dom/htmldatalistelement.rs
index 66d625437b6..4b6b4cf4a12 100644
--- a/components/script/dom/htmldatalistelement.rs
+++ b/components/script/dom/htmldatalistelement.rs
@@ -4,12 +4,13 @@
 
 use dom::bindings::codegen::Bindings::HTMLDataListElementBinding;
 use dom::bindings::codegen::Bindings::HTMLDataListElementBinding::HTMLDataListElementMethods;
-use dom::bindings::codegen::InheritTypes::{HTMLOptionElementDerived, NodeCast};
+use dom::bindings::conversions::Castable;
 use dom::bindings::js::Root;
 use dom::document::Document;
 use dom::element::Element;
 use dom::htmlcollection::{CollectionFilter, HTMLCollection};
 use dom::htmlelement::HTMLElement;
+use dom::htmloptionelement::HTMLOptionElement;
 use dom::node::{Node, window_from_node};
 use util::str::DOMString;
 
@@ -44,10 +45,10 @@ impl HTMLDataListElementMethods for HTMLDataListElement {
         struct HTMLDataListOptionsFilter;
         impl CollectionFilter for HTMLDataListOptionsFilter {
             fn filter(&self, elem: &Element, _root: &Node) -> bool {
-                elem.is_htmloptionelement()
+                elem.is::<HTMLOptionElement>()
             }
         }
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         let filter = box HTMLDataListOptionsFilter;
         let window = window_from_node(node);
         HTMLCollection::create(window.r(), node, filter)
diff --git a/components/script/dom/htmlelement.rs b/components/script/dom/htmlelement.rs
index 8760c8fd759..f2b36bfd151 100644
--- a/components/script/dom/htmlelement.rs
+++ b/components/script/dom/htmlelement.rs
@@ -9,11 +9,8 @@ use dom::bindings::codegen::Bindings::HTMLElementBinding;
 use dom::bindings::codegen::Bindings::HTMLElementBinding::HTMLElementMethods;
 use dom::bindings::codegen::Bindings::HTMLInputElementBinding::HTMLInputElementMethods;
 use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, ElementTypeId};
-use dom::bindings::codegen::InheritTypes::{EventTargetCast, HTMLBodyElementDerived};
-use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, HTMLFrameSetElementDerived};
-use dom::bindings::codegen::InheritTypes::{HTMLHtmlElementDerived, HTMLInputElementCast};
-use dom::bindings::codegen::InheritTypes::{NodeCast, NodeTypeId};
+use dom::bindings::codegen::InheritTypes::{ElementTypeId, HTMLElementTypeId, NodeTypeId};
+use dom::bindings::conversions::Castable;
 use dom::bindings::error::{Error, ErrorResult};
 use dom::bindings::js::{JS, MutNullableHeap, Root};
 use dom::bindings::utils::Reflectable;
@@ -21,6 +18,10 @@ use dom::cssstyledeclaration::{CSSModificationAccess, CSSStyleDeclaration};
 use dom::document::Document;
 use dom::domstringmap::DOMStringMap;
 use dom::element::{AttributeMutation, Element, EventState};
+use dom::eventtarget::EventTarget;
+use dom::htmlbodyelement::HTMLBodyElement;
+use dom::htmlframesetelement::HTMLFrameSetElement;
+use dom::htmlhtmlelement::HTMLHtmlElement;
 use dom::htmlinputelement::HTMLInputElement;
 use dom::node::{Node, SEQUENTIALLY_FOCUSABLE};
 use dom::node::{document_from_node, window_from_node};
@@ -70,13 +71,13 @@ impl HTMLElement {
     }
 
     fn is_body_or_frameset(&self) -> bool {
-        let eventtarget = EventTargetCast::from_ref(self);
-        eventtarget.is_htmlbodyelement() || eventtarget.is_htmlframesetelement()
+        let eventtarget = self.upcast::<EventTarget>();
+        eventtarget.is::<HTMLBodyElement>() || eventtarget.is::<HTMLFrameSetElement>()
     }
 
     fn update_sequentially_focusable_status(&self) {
-        let element = ElementCast::from_ref(self);
-        let node = NodeCast::from_ref(self);
+        let element = self.upcast::<Element>();
+        let node = self.upcast::<Node>();
         if element.has_attribute(&atom!("tabindex")) {
             node.set_flag(SEQUENTIALLY_FOCUSABLE, true);
         } else {
@@ -117,7 +118,7 @@ impl HTMLElementMethods for HTMLElement {
     fn Style(&self) -> Root<CSSStyleDeclaration> {
         self.style_decl.or_init(|| {
             let global = window_from_node(self);
-            CSSStyleDeclaration::new(global.r(), ElementCast::from_ref(self), None, CSSModificationAccess::ReadWrite)
+            CSSStyleDeclaration::new(global.r(), self.upcast::<Element>(), None, CSSModificationAccess::ReadWrite)
         })
     }
 
@@ -150,7 +151,7 @@ impl HTMLElementMethods for HTMLElement {
             let win = window_from_node(self);
             win.r().GetOnload()
         } else {
-            let target = EventTargetCast::from_ref(self);
+            let target = self.upcast::<EventTarget>();
             target.get_event_handler_common("load")
         }
     }
@@ -161,20 +162,20 @@ impl HTMLElementMethods for HTMLElement {
             let win = window_from_node(self);
             win.r().SetOnload(listener)
         } else {
-            let target = EventTargetCast::from_ref(self);
+            let target = self.upcast::<EventTarget>();
             target.set_event_handler_common("load", listener)
         }
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-click
     fn Click(&self) {
-        let maybe_input: Option<&HTMLInputElement> = HTMLInputElementCast::to_ref(self);
+        let maybe_input: Option<&HTMLInputElement> = self.downcast::<HTMLInputElement>();
         if let Some(i) = maybe_input {
             if i.Disabled() {
                 return;
             }
         }
-        let element = ElementCast::from_ref(self);
+        let element = self.upcast::<Element>();
         // https://www.w3.org/Bugs/Public/show_bug.cgi?id=27430 ?
         element.as_maybe_activatable().map(|a| a.synthetic_click_activation(false, false, false, false));
     }
@@ -183,7 +184,7 @@ impl HTMLElementMethods for HTMLElement {
     fn Focus(&self) {
         // TODO: Mark the element as locked for focus and run the focusing steps.
         // https://html.spec.whatwg.org/multipage/#focusing-steps
-        let element = ElementCast::from_ref(self);
+        let element = self.upcast::<Element>();
         let document = document_from_node(self);
         let document = document.r();
         document.begin_focus_transaction();
@@ -194,7 +195,7 @@ impl HTMLElementMethods for HTMLElement {
     // https://html.spec.whatwg.org/multipage/#dom-blur
     fn Blur(&self) {
         // TODO: Run the unfocusing steps.
-        let el = ElementCast::from_ref(self);
+        let el = self.upcast::<Element>();
         if !el.get_focus_state() {
             return;
         }
@@ -207,11 +208,11 @@ impl HTMLElementMethods for HTMLElement {
 
     // https://drafts.csswg.org/cssom-view/#extensions-to-the-htmlelement-interface
     fn GetOffsetParent(&self) -> Option<Root<Element>> {
-        if self.is_htmlbodyelement() || self.is_htmlhtmlelement() {
+        if self.is::<HTMLBodyElement>() || self.is::<HTMLHtmlElement>() {
             return None;
         }
 
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         let window = window_from_node(self);
         let (element, _) = window.offset_parent_query(node.to_trusted_node_address());
 
@@ -220,11 +221,11 @@ impl HTMLElementMethods for HTMLElement {
 
     // https://drafts.csswg.org/cssom-view/#extensions-to-the-htmlelement-interface
     fn OffsetTop(&self) -> i32 {
-        if self.is_htmlbodyelement() {
+        if self.is::<HTMLBodyElement>() {
             return 0;
         }
 
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         let window = window_from_node(self);
         let (_, rect) = window.offset_parent_query(node.to_trusted_node_address());
 
@@ -233,11 +234,11 @@ impl HTMLElementMethods for HTMLElement {
 
     // https://drafts.csswg.org/cssom-view/#extensions-to-the-htmlelement-interface
     fn OffsetLeft(&self) -> i32 {
-        if self.is_htmlbodyelement() {
+        if self.is::<HTMLBodyElement>() {
             return 0;
         }
 
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         let window = window_from_node(self);
         let (_, rect) = window.offset_parent_query(node.to_trusted_node_address());
 
@@ -246,7 +247,7 @@ impl HTMLElementMethods for HTMLElement {
 
     // https://drafts.csswg.org/cssom-view/#extensions-to-the-htmlelement-interface
     fn OffsetWidth(&self) -> i32 {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         let window = window_from_node(self);
         let (_, rect) = window.offset_parent_query(node.to_trusted_node_address());
 
@@ -255,7 +256,7 @@ impl HTMLElementMethods for HTMLElement {
 
     // https://drafts.csswg.org/cssom-view/#extensions-to-the-htmlelement-interface
     fn OffsetHeight(&self) -> i32 {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         let window = window_from_node(self);
         let (_, rect) = window.offset_parent_query(node.to_trusted_node_address());
 
@@ -285,12 +286,12 @@ impl HTMLElement {
                .nth(1).map_or(false, |ch| ch >= 'a' && ch <= 'z') {
             return Err(Error::Syntax);
         }
-        let element = ElementCast::from_ref(self);
+        let element = self.upcast::<Element>();
         element.set_custom_attribute(to_snake_case(name), value)
     }
 
     pub fn get_custom_attr(&self, local_name: DOMString) -> Option<DOMString> {
-        let element = ElementCast::from_ref(self);
+        let element = self.upcast::<Element>();
         let local_name = Atom::from_slice(&to_snake_case(local_name));
         element.get_attribute(&ns!(""), &local_name).map(|attr| {
             (**attr.r().value()).to_owned()
@@ -298,7 +299,7 @@ impl HTMLElement {
     }
 
     pub fn delete_custom_attr(&self, local_name: DOMString) {
-        let element = ElementCast::from_ref(self);
+        let element = self.upcast::<Element>();
         let local_name = Atom::from_slice(&to_snake_case(local_name));
         element.remove_attribute(&ns!(""), &local_name);
     }
@@ -306,7 +307,7 @@ impl HTMLElement {
 
 impl VirtualMethods for HTMLElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let element: &Element = ElementCast::from_ref(self);
+        let element: &Element = self.upcast::<Element>();
         Some(element as &VirtualMethods)
     }
 
@@ -318,7 +319,7 @@ impl VirtualMethods for HTMLElement {
                 let (cx, url, reflector) = (window.r().get_cx(),
                                             window.r().get_url(),
                                             window.r().reflector().get_jsobject());
-                let evtarget = EventTargetCast::from_ref(self);
+                let evtarget = self.upcast::<EventTarget>();
                 evtarget.set_event_handler_uncompiled(cx, url, reflector,
                                                       &name[2..],
                                                       (**attr.value()).to_owned());
diff --git a/components/script/dom/htmlfieldsetelement.rs b/components/script/dom/htmlfieldsetelement.rs
index 731c498c61a..b875e275c66 100644
--- a/components/script/dom/htmlfieldsetelement.rs
+++ b/components/script/dom/htmlfieldsetelement.rs
@@ -5,15 +5,15 @@
 use dom::attr::Attr;
 use dom::bindings::codegen::Bindings::HTMLFieldSetElementBinding;
 use dom::bindings::codegen::Bindings::HTMLFieldSetElementBinding::HTMLFieldSetElementMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, ElementTypeId, HTMLElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, HTMLLegendElementDerived};
-use dom::bindings::codegen::InheritTypes::{NodeCast, NodeTypeId};
+use dom::bindings::codegen::InheritTypes::{ElementTypeId, HTMLElementTypeId, NodeTypeId};
+use dom::bindings::conversions::Castable;
 use dom::bindings::js::{Root, RootedReference};
 use dom::document::Document;
 use dom::element::{AttributeMutation, Element, IN_ENABLED_STATE};
 use dom::htmlcollection::{CollectionFilter, HTMLCollection};
 use dom::htmlelement::HTMLElement;
 use dom::htmlformelement::{FormControl, HTMLFormElement};
+use dom::htmllegendelement::HTMLLegendElement;
 use dom::node::{Node, window_from_node};
 use dom::validitystate::ValidityState;
 use dom::virtualmethods::VirtualMethods;
@@ -56,7 +56,7 @@ impl HTMLFieldSetElementMethods for HTMLFieldSetElement {
                 TAG_NAMES.iter().any(|&tag_name| tag_name == &**elem.local_name())
             }
         }
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         let filter = box ElementsFilter;
         let window = window_from_node(node);
         HTMLCollection::create(window.r(), node, filter)
@@ -82,7 +82,7 @@ impl HTMLFieldSetElementMethods for HTMLFieldSetElement {
 
 impl VirtualMethods for HTMLFieldSetElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = HTMLElementCast::from_ref(self);
+        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
         Some(htmlelement as &VirtualMethods)
     }
 
@@ -98,15 +98,15 @@ impl VirtualMethods for HTMLFieldSetElement {
                     },
                     AttributeMutation::Removed => false,
                 };
-                let node = NodeCast::from_ref(self);
-                let el = ElementCast::from_ref(self);
+                let node = self.upcast::<Node>();
+                let el = self.upcast::<Element>();
                 el.set_disabled_state(disabled_state);
                 el.set_enabled_state(!disabled_state);
                 let mut found_legend = false;
                 let children = node.children().filter(|node| {
                     if found_legend {
                         true
-                    } else if node.is_htmllegendelement() {
+                    } else if node.is::<HTMLLegendElement>() {
                         found_legend = true;
                         false
                     } else {
@@ -136,13 +136,13 @@ impl VirtualMethods for HTMLFieldSetElement {
                 });
                 if disabled_state {
                     for field in fields {
-                        let el = ElementCast::to_ref(field.r()).unwrap();
+                        let el = field.downcast::<Element>().unwrap();
                         el.set_disabled_state(true);
                         el.set_enabled_state(false);
                     }
                 } else {
                     for field in fields {
-                        let el = ElementCast::to_ref(field.r()).unwrap();
+                        let el = field.downcast::<Element>().unwrap();
                         el.check_disabled_attribute();
                         el.check_ancestors_disabled_state_for_form_control();
                     }
diff --git a/components/script/dom/htmlfontelement.rs b/components/script/dom/htmlfontelement.rs
index 110c93a643a..ba6b586e9d3 100644
--- a/components/script/dom/htmlfontelement.rs
+++ b/components/script/dom/htmlfontelement.rs
@@ -7,10 +7,10 @@ use dom::attr::{Attr, AttrValue};
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::HTMLFontElementBinding;
 use dom::bindings::codegen::Bindings::HTMLFontElementBinding::HTMLFontElementMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast};
+use dom::bindings::conversions::Castable;
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::element::{AttributeMutation, RawLayoutElementHelpers};
+use dom::element::{AttributeMutation, Element, RawLayoutElementHelpers};
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use dom::virtualmethods::VirtualMethods;
@@ -63,7 +63,7 @@ impl HTMLFontElementMethods for HTMLFontElement {
 
     // https://html.spec.whatwg.org/multipage/#dom-font-size
     fn SetSize(&self, value: DOMString) {
-        let element = ElementCast::from_ref(self);
+        let element = self.upcast::<Element>();
         let length = parse_length(&value);
         element.set_attribute(&Atom::from_slice("size"), AttrValue::Length(value, length));
     }
@@ -71,7 +71,7 @@ impl HTMLFontElementMethods for HTMLFontElement {
 
 impl VirtualMethods for HTMLFontElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement = HTMLElementCast::from_ref(self);
+        let htmlelement = self.upcast::<HTMLElement>();
         Some(htmlelement as &VirtualMethods)
     }
 
@@ -122,7 +122,7 @@ impl HTMLFontElement {
     #[allow(unsafe_code)]
     pub fn get_size(&self) -> Option<specified::Length> {
         unsafe {
-            ElementCast::from_ref(self)
+            self.upcast::<Element>()
                 .get_attr_for_layout(&ns!(""), &atom!("size"))
                 .and_then(AttrValue::as_length)
                 .cloned()
diff --git a/components/script/dom/htmlformelement.rs b/components/script/dom/htmlformelement.rs
index 475252fa92e..0584cd85c59 100644
--- a/components/script/dom/htmlformelement.rs
+++ b/components/script/dom/htmlformelement.rs
@@ -9,21 +9,20 @@ use dom::bindings::codegen::Bindings::HTMLButtonElementBinding::HTMLButtonElemen
 use dom::bindings::codegen::Bindings::HTMLFormElementBinding;
 use dom::bindings::codegen::Bindings::HTMLFormElementBinding::HTMLFormElementMethods;
 use dom::bindings::codegen::Bindings::HTMLInputElementBinding::HTMLInputElementMethods;
-use dom::bindings::codegen::InheritTypes::{ElementBase, ElementCast};
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetCast};
-use dom::bindings::codegen::InheritTypes::{HTMLDataListElementCast, HTMLElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, HTMLFormElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLInputElementCast, HTMLTextAreaElementCast};
-use dom::bindings::codegen::InheritTypes::{NodeCast, NodeTypeId};
+use dom::bindings::codegen::InheritTypes::{ElementTypeId, HTMLElementTypeId, NodeTypeId};
+use dom::bindings::conversions::{Castable, DerivedFrom};
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{Root};
 use dom::bindings::utils::Reflectable;
 use dom::document::Document;
 use dom::element::Element;
 use dom::event::{Event, EventBubbles, EventCancelable};
+use dom::eventtarget::EventTarget;
 use dom::htmlbuttonelement::{HTMLButtonElement};
+use dom::htmldatalistelement::HTMLDataListElement;
 use dom::htmlelement::HTMLElement;
 use dom::htmlinputelement::HTMLInputElement;
+use dom::htmltextareaelement::HTMLTextAreaElement;
 use dom::node::{Node, document_from_node, window_from_node};
 use dom::virtualmethods::VirtualMethods;
 use hyper::header::ContentType;
@@ -164,7 +163,7 @@ impl HTMLFormElement {
                                "submit".to_owned(),
                                EventBubbles::Bubbles,
                                EventCancelable::Cancelable);
-        let target = EventTargetCast::from_ref(self);
+        let target = self.upcast::<EventTarget>();
         event.r().fire(target);
         if event.r().DefaultPrevented() {
             return;
@@ -219,24 +218,24 @@ impl HTMLFormElement {
     }
 
     fn get_unclean_dataset(&self, submitter: Option<FormSubmitter>) -> Vec<FormDatum> {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         // TODO: This is an incorrect way of getting controls owned
         //       by the form, but good enough until html5ever lands
         node.traverse_preorder().filter_map(|child| {
-            match ElementCast::to_ref(child.r()) {
+            match child.downcast::<Element>() {
                 Some(el) if !el.get_disabled_state() => (),
                 _ => return None,
             }
 
             if child.r().ancestors()
-                        .any(|a| HTMLDataListElementCast::to_root(a).is_some()) {
+                        .any(|a| Root::downcast::<HTMLDataListElement>(a).is_some()) {
                 return None;
             }
             match child.r().type_id() {
                 NodeTypeId::Element(ElementTypeId::HTMLElement(element)) => {
                     match element {
                         HTMLElementTypeId::HTMLInputElement => {
-                            let input = HTMLInputElementCast::to_ref(child.r()).unwrap();
+                            let input = child.downcast::<HTMLInputElement>().unwrap();
                             input.get_form_datum(submitter)
                         }
                         HTMLElementTypeId::HTMLButtonElement |
@@ -317,20 +316,20 @@ impl HTMLFormElement {
                                "reset".to_owned(),
                                EventBubbles::Bubbles,
                                EventCancelable::Cancelable);
-        let target = EventTargetCast::from_ref(self);
+        let target = self.upcast::<EventTarget>();
         event.r().fire(target);
         if event.r().DefaultPrevented() {
             return;
         }
 
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
 
         // TODO: This is an incorrect way of getting controls owned
         //       by the form, but good enough until html5ever lands
         for child in node.traverse_preorder() {
             match child.r().type_id() {
                 NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLInputElement)) => {
-                    let input = HTMLInputElementCast::to_ref(child.r()).unwrap();
+                    let input = child.downcast::<HTMLInputElement>().unwrap();
                     input.reset()
                 }
                 // TODO HTMLKeygenElement unimplemented
@@ -343,7 +342,7 @@ impl HTMLFormElement {
                     {}
                 }
                 NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTextAreaElement)) => {
-                    let textarea = HTMLTextAreaElementCast::to_ref(child.r()).unwrap();
+                    let textarea = child.downcast::<HTMLTextAreaElement>().unwrap();
                     textarea.reset()
                 }
                 NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLOutputElement)) => {
@@ -465,7 +464,7 @@ impl<'a> FormSubmitter<'a> {
     }
 }
 
-pub trait FormControl: ElementBase + Reflectable {
+pub trait FormControl: DerivedFrom<Element> + Reflectable {
     // FIXME: This is wrong (https://github.com/servo/servo/issues/3553)
     //        but we need html5ever to do it correctly
     fn form_owner(&self) -> Option<Root<HTMLFormElement>> {
@@ -477,7 +476,7 @@ pub trait FormControl: ElementBase + Reflectable {
             let owner = doc.r().GetElementById(owner);
             match owner {
                 Some(ref o) => {
-                    let maybe_form = HTMLFormElementCast::to_ref(o.r());
+                    let maybe_form = o.downcast::<HTMLFormElement>();
                     if maybe_form.is_some() {
                         return maybe_form.map(Root::from_ref);
                     }
@@ -485,9 +484,9 @@ pub trait FormControl: ElementBase + Reflectable {
                 _ => ()
             }
         }
-        let node = NodeCast::from_ref(elem);
+        let node = elem.upcast::<Node>();
         for ancestor in node.ancestors() {
-            if let Some(ancestor) = HTMLFormElementCast::to_ref(ancestor.r()) {
+            if let Some(ancestor) = ancestor.downcast::<HTMLFormElement>() {
                 return Some(Root::from_ref(ancestor))
             }
         }
@@ -510,13 +509,13 @@ pub trait FormControl: ElementBase + Reflectable {
     }
 
     fn to_element(&self) -> &Element {
-        ElementCast::from_ref(self)
+        self.upcast::<Element>()
     }
 }
 
 impl VirtualMethods for HTMLFormElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        Some(HTMLElementCast::from_ref(self) as &VirtualMethods)
+        Some(self.upcast::<HTMLElement>() as &VirtualMethods)
     }
 
     fn parse_plain_attribute(&self, name: &Atom, value: DOMString) -> AttrValue {
diff --git a/components/script/dom/htmlheadelement.rs b/components/script/dom/htmlheadelement.rs
index 1129d273927..7af45e813e4 100644
--- a/components/script/dom/htmlheadelement.rs
+++ b/components/script/dom/htmlheadelement.rs
@@ -3,7 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLHeadElementBinding;
-use dom::bindings::codegen::InheritTypes::HTMLElementCast;
+use dom::bindings::conversions::Castable;
 use dom::bindings::js::Root;
 use dom::document::Document;
 use dom::htmlelement::HTMLElement;
@@ -37,7 +37,7 @@ impl HTMLHeadElement {
 
 impl VirtualMethods for HTMLHeadElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = HTMLElementCast::from_ref(self);
+        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
         Some(htmlelement as &VirtualMethods)
     }
     fn bind_to_tree(&self, _tree_in_doc: bool) {
diff --git a/components/script/dom/htmliframeelement.rs b/components/script/dom/htmliframeelement.rs
index 4f2149e346b..cbe95bc6e24 100644
--- a/components/script/dom/htmliframeelement.rs
+++ b/components/script/dom/htmliframeelement.rs
@@ -6,16 +6,16 @@ use dom::attr::{Attr, AttrHelpersForLayout, AttrValue};
 use dom::bindings::codegen::Bindings::HTMLIFrameElementBinding;
 use dom::bindings::codegen::Bindings::HTMLIFrameElementBinding::HTMLIFrameElementMethods;
 use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, EventCast, EventTargetCast};
-use dom::bindings::codegen::InheritTypes::{HTMLElementCast, NodeCast};
-use dom::bindings::conversions::ToJSValConvertible;
+use dom::bindings::conversions::{Castable, ToJSValConvertible};
 use dom::bindings::error::{Error, ErrorResult, Fallible};
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{Root, LayoutJS};
 use dom::bindings::utils::Reflectable;
 use dom::customevent::CustomEvent;
 use dom::document::Document;
-use dom::element::{self, AttributeMutation};
+use dom::element::{self, AttributeMutation, Element};
+use dom::event::Event;
+use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::{Node, window_from_node};
 use dom::urlhelper::UrlHelper;
@@ -67,7 +67,7 @@ impl HTMLIFrameElement {
     }
 
     pub fn get_url(&self) -> Option<Url> {
-        let element = ElementCast::from_ref(self);
+        let element = self.upcast::<Element>();
         element.get_attribute(&ns!(""), &atom!("src")).and_then(|src| {
             let url = src.r().value();
             if url.is_empty() {
@@ -148,8 +148,8 @@ impl HTMLIFrameElement {
                                                 true,
                                                 true,
                                                 detail.handle());
-            let target = EventTargetCast::from_ref(self);
-            let event = EventCast::from_ref(custom_event.r());
+            let target = self.upcast::<EventTarget>();
+            let event = custom_event.upcast::<Event>();
             event.fire(target);
         }
     }
@@ -161,7 +161,7 @@ impl HTMLIFrameElement {
     #[allow(unsafe_code)]
     pub fn get_width(&self) -> LengthOrPercentageOrAuto {
         unsafe {
-            element::get_attr_for_layout(ElementCast::from_ref(&*self),
+            element::get_attr_for_layout(self.upcast::<Element>(),
                                          &ns!(""),
                                          &atom!("width")).map(|attribute| {
                 str::parse_length(&**attribute.value_for_layout())
@@ -172,7 +172,7 @@ impl HTMLIFrameElement {
     #[allow(unsafe_code)]
     pub fn get_height(&self) -> LengthOrPercentageOrAuto {
         unsafe {
-            element::get_attr_for_layout(ElementCast::from_ref(&*self),
+            element::get_attr_for_layout(self.upcast::<Element>(),
                                          &ns!(""),
                                          &atom!("height")).map(|attribute| {
                 str::parse_length(&**attribute.value_for_layout())
@@ -227,7 +227,7 @@ impl HTMLIFrameElementLayoutMethods for LayoutJS<HTMLIFrameElement> {
 
 pub fn Navigate(iframe: &HTMLIFrameElement, direction: NavigationDirection) -> Fallible<()> {
     if iframe.Mozbrowser() {
-        let node = NodeCast::from_ref(iframe);
+        let node = iframe.upcast::<Node>();
         if node.is_in_doc() {
             let window = window_from_node(iframe);
             let window = window.r();
@@ -249,25 +249,25 @@ pub fn Navigate(iframe: &HTMLIFrameElement, direction: NavigationDirection) -> F
 impl HTMLIFrameElementMethods for HTMLIFrameElement {
     // https://html.spec.whatwg.org/multipage/#dom-iframe-src
     fn Src(&self) -> DOMString {
-        let element = ElementCast::from_ref(self);
+        let element = self.upcast::<Element>();
         element.get_string_attribute(&atom!("src"))
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-iframe-src
     fn SetSrc(&self, src: DOMString) {
-        let element = ElementCast::from_ref(self);
+        let element = self.upcast::<Element>();
         element.set_url_attribute(&atom!("src"), src)
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-iframe-sandbox
     fn Sandbox(&self) -> DOMString {
-        let element = ElementCast::from_ref(self);
+        let element = self.upcast::<Element>();
         element.get_string_attribute(&atom!("sandbox"))
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-iframe-sandbox
     fn SetSandbox(&self, sandbox: DOMString) {
-        let element = ElementCast::from_ref(self);
+        let element = self.upcast::<Element>();
         element.set_tokenlist_attribute(&atom!("sandbox"), sandbox);
     }
 
@@ -311,7 +311,7 @@ impl HTMLIFrameElementMethods for HTMLIFrameElement {
     // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#attr-mozbrowser
     fn Mozbrowser(&self) -> bool {
         if mozbrowser_enabled() {
-            let element = ElementCast::from_ref(self);
+            let element = self.upcast::<Element>();
             element.has_attribute(&Atom::from_slice("mozbrowser"))
         } else {
             false
@@ -321,7 +321,7 @@ impl HTMLIFrameElementMethods for HTMLIFrameElement {
     // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#attr-mozbrowser
     fn SetMozbrowser(&self, value: bool) -> ErrorResult {
         if mozbrowser_enabled() {
-            let element = ElementCast::from_ref(self);
+            let element = self.upcast::<Element>();
             element.set_bool_attribute(&Atom::from_slice("mozbrowser"), value);
         }
         Ok(())
@@ -360,7 +360,7 @@ impl HTMLIFrameElementMethods for HTMLIFrameElement {
 
 impl VirtualMethods for HTMLIFrameElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = HTMLElementCast::from_ref(self);
+        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
         Some(htmlelement as &VirtualMethods)
     }
 
@@ -386,7 +386,7 @@ impl VirtualMethods for HTMLIFrameElement {
             },
             &atom!(src) => {
                 if let AttributeMutation::Set(_) = mutation {
-                    if NodeCast::from_ref(self).is_in_doc() {
+                    if self.upcast::<Node>().is_in_doc() {
                         self.process_the_iframe_attributes();
                     }
                 }
diff --git a/components/script/dom/htmlimageelement.rs b/components/script/dom/htmlimageelement.rs
index 5ea8d2866be..865a9d05774 100644
--- a/components/script/dom/htmlimageelement.rs
+++ b/components/script/dom/htmlimageelement.rs
@@ -8,15 +8,15 @@ use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::HTMLImageElementBinding;
 use dom::bindings::codegen::Bindings::HTMLImageElementBinding::HTMLImageElementMethods;
 use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, EventTargetCast};
-use dom::bindings::codegen::InheritTypes::{HTMLElementCast, NodeCast};
+use dom::bindings::conversions::Castable;
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{LayoutJS, Root};
 use dom::bindings::refcounted::Trusted;
 use dom::document::Document;
-use dom::element::AttributeMutation;
+use dom::element::{AttributeMutation, Element};
 use dom::event::{Event, EventBubbles, EventCancelable};
+use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::{Node, NodeDamage, document_from_node, window_from_node};
 use dom::virtualmethods::VirtualMethods;
@@ -74,7 +74,7 @@ impl Runnable for ImageResponseHandlerRunnable {
         };
 
         // Mark the node dirty
-        let node = NodeCast::from_ref(element.r());
+        let node = element.upcast::<Node>();
         let document = document_from_node(node);
         document.r().content_changed(node, NodeDamage::OtherNodeDamage);
 
@@ -85,7 +85,7 @@ impl Runnable for ImageResponseHandlerRunnable {
                                EventBubbles::DoesNotBubble,
                                EventCancelable::NotCancelable);
         let event = event.r();
-        let target = EventTargetCast::from_ref(node);
+        let target = node.upcast::<EventTarget>();
         event.fire(target);
 
         // Trigger reflow
@@ -97,7 +97,7 @@ impl HTMLImageElement {
     /// Makes the local `image` member match the status of the `src` attribute and starts
     /// prefetching the image. This method must be called after `src` is changed.
     fn update_image(&self, value: Option<(DOMString, Url)>) {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         let document = node.owner_doc();
         let window = document.r().window();
         let image_cache = window.image_cache_task();
@@ -204,33 +204,33 @@ impl HTMLImageElementMethods for HTMLImageElement {
 
     // https://html.spec.whatwg.org/multipage/#dom-img-ismap
     fn SetIsMap(&self, is_map: bool) {
-        let element = ElementCast::from_ref(self);
+        let element = self.upcast::<Element>();
         element.set_string_attribute(&atom!("ismap"), is_map.to_string())
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-img-width
     fn Width(&self) -> u32 {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         let rect = node.get_bounding_content_box();
         rect.size.width.to_px() as u32
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-img-width
     fn SetWidth(&self, width: u32) {
-        let elem = ElementCast::from_ref(self);
+        let elem = self.upcast::<Element>();
         elem.set_uint_attribute(&atom!("width"), width)
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-img-height
     fn Height(&self) -> u32 {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         let rect = node.get_bounding_content_box();
         rect.size.height.to_px() as u32
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-img-height
     fn SetHeight(&self, height: u32) {
-        let elem = ElementCast::from_ref(self);
+        let elem = self.upcast::<Element>();
         elem.set_uint_attribute(&atom!("height"), height)
     }
 
@@ -299,7 +299,7 @@ impl HTMLImageElementMethods for HTMLImageElement {
 
 impl VirtualMethods for HTMLImageElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = HTMLElementCast::from_ref(self);
+        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
         Some(htmlelement as &VirtualMethods)
     }
 
diff --git a/components/script/dom/htmlinputelement.rs b/components/script/dom/htmlinputelement.rs
index b13a458f3d4..a2ad92517c0 100644
--- a/components/script/dom/htmlinputelement.rs
+++ b/components/script/dom/htmlinputelement.rs
@@ -11,9 +11,7 @@ use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
 use dom::bindings::codegen::Bindings::HTMLInputElementBinding;
 use dom::bindings::codegen::Bindings::HTMLInputElementBinding::HTMLInputElementMethods;
 use dom::bindings::codegen::Bindings::KeyboardEventBinding::KeyboardEventMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, EventTargetCast, HTMLElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLFieldSetElementDerived, HTMLInputElementCast};
-use dom::bindings::codegen::InheritTypes::{KeyboardEventCast, NodeCast};
+use dom::bindings::conversions::Castable;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, LayoutJS, Root, RootedReference};
 use dom::document::Document;
@@ -21,6 +19,7 @@ use dom::element::{AttributeMutation, Element, IN_ENABLED_STATE, RawLayoutElemen
 use dom::event::{Event, EventBubbles, EventCancelable};
 use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
+use dom::htmlfieldsetelement::HTMLFieldSetElement;
 use dom::htmlformelement::{FormControl, FormDatum, FormSubmitter, HTMLFormElement};
 use dom::htmlformelement::{ResetFrom, SubmittedFrom};
 use dom::keyboardevent::KeyboardEvent;
@@ -165,7 +164,7 @@ impl LayoutHTMLInputElementHelpers for LayoutJS<HTMLInputElement> {
 
         #[allow(unsafe_code)]
         unsafe fn get_raw_attr_value(input: LayoutJS<HTMLInputElement>) -> Option<String> {
-            let elem = ElementCast::from_layout_js(&input);
+            let elem = input.upcast::<Element>();
             (*elem.unsafe_get()).get_attr_val_for_layout(&ns!(""), &atom!("value"))
                                 .map(|s| s.to_owned())
         }
@@ -354,13 +353,13 @@ fn broadcast_radio_checked(broadcaster: &HTMLInputElement, group: Option<&Atom>)
     //TODO: if not in document, use root ancestor instead of document
     let owner = broadcaster.form_owner();
     let doc = document_from_node(broadcaster);
-    let doc_node = NodeCast::from_ref(doc.r());
+    let doc_node = doc.upcast::<Node>();
 
     // This function is a workaround for lifetime constraint difficulties.
     fn do_broadcast(doc_node: &Node, broadcaster: &HTMLInputElement,
                         owner: Option<&HTMLFormElement>, group: Option<&Atom>) {
-        let iter = doc_node.query_selector_iter("input[type=radio]".to_owned())
-                .unwrap().filter_map(HTMLInputElementCast::to_root)
+        let iter = doc_node.query_selector_iter("input[type=radio]".to_owned()).unwrap()
+                .filter_map(Root::downcast::<HTMLInputElement>)
                 .filter(|r| in_same_group(r.r(), owner, group) && broadcaster != r.r());
         for ref r in iter {
             if r.r().Checked() {
@@ -389,7 +388,7 @@ fn in_same_group(other: &HTMLInputElement, owner: Option<&HTMLFormElement>,
 impl HTMLInputElement {
     fn force_relayout(&self) {
         let doc = document_from_node(self);
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         doc.r().content_changed(node, NodeDamage::OtherNodeDamage)
     }
 
@@ -440,7 +439,7 @@ impl HTMLInputElement {
     // https://html.spec.whatwg.org/multipage/#radio-button-group
     fn get_radio_group_name(&self) -> Option<Atom> {
         //TODO: determine form owner
-        let elem = ElementCast::from_ref(self);
+        let elem = self.upcast::<Element>();
         elem.get_attribute(&ns!(""), &atom!("name"))
             .map(|name| name.value().as_atom().clone())
     }
@@ -469,7 +468,7 @@ impl HTMLInputElement {
     fn mutable(&self) -> bool {
         // https://html.spec.whatwg.org/multipage/#the-input-element:concept-fe-mutable
         // https://html.spec.whatwg.org/multipage/#the-readonly-attribute:concept-fe-mutable
-        let el = ElementCast::from_ref(self);
+        let el = self.upcast::<Element>();
         !(el.get_disabled_state() || self.ReadOnly())
     }
 
@@ -492,7 +491,7 @@ impl HTMLInputElement {
 
 impl VirtualMethods for HTMLInputElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = HTMLElementCast::from_ref(self);
+        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
         Some(htmlelement as &VirtualMethods)
     }
 
@@ -508,7 +507,7 @@ impl VirtualMethods for HTMLInputElement {
                     },
                     AttributeMutation::Removed => false,
                 };
-                let el = ElementCast::from_ref(self);
+                let el = self.upcast::<Element>();
                 el.set_disabled_state(disabled_state);
                 el.set_enabled_state(!disabled_state);
                 el.check_ancestors_disabled_state_for_form_control();
@@ -593,7 +592,7 @@ impl VirtualMethods for HTMLInputElement {
             s.bind_to_tree(tree_in_doc);
         }
 
-        let el = ElementCast::from_ref(self);
+        let el = self.upcast::<Element>();
         el.check_ancestors_disabled_state_for_form_control();
     }
 
@@ -602,9 +601,9 @@ impl VirtualMethods for HTMLInputElement {
             s.unbind_from_tree(tree_in_doc);
         }
 
-        let node = NodeCast::from_ref(self);
-        let el = ElementCast::from_ref(self);
-        if node.ancestors().any(|ancestor| ancestor.r().is_htmlfieldsetelement()) {
+        let node = self.upcast::<Node>();
+        let el = self.upcast::<Element>();
+        if node.ancestors().any(|ancestor| ancestor.is::<HTMLFieldSetElement>()) {
             el.check_ancestors_disabled_state_for_form_control();
         } else {
             el.check_disabled_attribute();
@@ -628,11 +627,11 @@ impl VirtualMethods for HTMLInputElement {
             //TODO: set the editing position for text inputs
 
             let doc = document_from_node(self);
-            doc.r().request_focus(ElementCast::from_ref(self));
+            doc.r().request_focus(self.upcast::<Element>());
         } else if &*event.Type() == "keydown" && !event.DefaultPrevented() &&
             (self.input_type.get() == InputType::InputText ||
              self.input_type.get() == InputType::InputPassword) {
-                let keyevent: Option<&KeyboardEvent> = KeyboardEventCast::to_ref(event);
+                let keyevent: Option<&KeyboardEvent> = event.downcast::<KeyboardEvent>();
                 keyevent.map(|keyevent| {
                     // This can't be inlined, as holding on to textinput.borrow_mut()
                     // during self.implicit_submission will cause a panic.
@@ -663,7 +662,7 @@ impl FormControl for HTMLInputElement {}
 
 impl Activatable for HTMLInputElement {
     fn as_element(&self) -> &Element {
-        ElementCast::from_ref(self)
+        self.upcast::<Element>()
     }
 
     fn is_instance_activatable(&self) -> bool {
@@ -708,11 +707,12 @@ impl Activatable for HTMLInputElement {
                     //TODO: if not in document, use root ancestor instead of document
                     let owner = self.form_owner();
                     let doc = document_from_node(self);
-                    let doc_node = NodeCast::from_ref(doc.r());
+                    let doc_node = doc.upcast::<Node>();
                     let group = self.get_radio_group_name();;
 
+                    // Safe since we only manipulate the DOM tree after finding an element
                     let checked_member = doc_node.query_selector_iter("input[type=radio]".to_owned()).unwrap()
-                            .filter_map(HTMLInputElementCast::to_root)
+                            .filter_map(Root::downcast::<HTMLInputElement>)
                             .find(|r| {
                                 in_same_group(r.r(), owner.r(), group.as_ref()) &&
                                 r.r().Checked()
@@ -813,14 +813,14 @@ impl Activatable for HTMLInputElement {
                                            "input".to_owned(),
                                            EventBubbles::Bubbles,
                                            EventCancelable::NotCancelable);
-                    let target = EventTargetCast::from_ref(self);
+                    let target = self.upcast::<EventTarget>();
                     event.r().fire(target);
 
                     let event = Event::new(GlobalRef::Window(win.r()),
                                            "change".to_owned(),
                                            EventBubbles::Bubbles,
                                            EventCancelable::NotCancelable);
-                    let target = EventTargetCast::from_ref(self);
+                    let target = self.upcast::<EventTarget>();
                     event.r().fire(target);
                 }
             },
@@ -832,20 +832,20 @@ impl Activatable for HTMLInputElement {
     #[allow(unsafe_code)]
     fn implicit_submission(&self, ctrlKey: bool, shiftKey: bool, altKey: bool, metaKey: bool) {
         let doc = document_from_node(self);
-        let node = NodeCast::from_ref(doc.r());
+        let node = doc.upcast::<Node>();
         let owner = self.form_owner();
         let form = match owner {
             None => return,
             Some(ref f) => f
         };
 
-        let elem = ElementCast::from_ref(self);
+        let elem = self.upcast::<Element>();
         if elem.click_in_progress() {
             return;
         }
         let submit_button;
         submit_button = node.query_selector_iter("input[type=submit]".to_owned()).unwrap()
-            .filter_map(HTMLInputElementCast::to_root)
+            .filter_map(Root::downcast::<HTMLInputElement>)
             .find(|r| r.r().form_owner() == owner);
         match submit_button {
             Some(ref button) => {
@@ -855,7 +855,7 @@ impl Activatable for HTMLInputElement {
             }
             None => {
                 let inputs = node.query_selector_iter("input".to_owned()).unwrap()
-                    .filter_map(HTMLInputElementCast::to_root)
+                    .filter_map(Root::downcast::<HTMLInputElement>)
                     .filter(|input| {
                         input.r().form_owner() == owner && match &*input.r().Type() {
                             "text" | "search" | "url" | "tel" |
diff --git a/components/script/dom/htmllinkelement.rs b/components/script/dom/htmllinkelement.rs
index c939cbafc9c..f317eec0001 100644
--- a/components/script/dom/htmllinkelement.rs
+++ b/components/script/dom/htmllinkelement.rs
@@ -8,8 +8,7 @@ use dom::attr::{Attr, AttrValue};
 use dom::bindings::codegen::Bindings::HTMLLinkElementBinding;
 use dom::bindings::codegen::Bindings::HTMLLinkElementBinding::HTMLLinkElementMethods;
 use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, EventTargetCast};
-use dom::bindings::codegen::InheritTypes::{HTMLElementCast, NodeCast};
+use dom::bindings::conversions::Castable;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, MutNullableHeap, Root};
 use dom::bindings::js::{RootedReference};
@@ -18,6 +17,7 @@ use dom::document::Document;
 use dom::domtokenlist::DOMTokenList;
 use dom::element::{AttributeMutation, Element};
 use dom::event::{Event, EventBubbles, EventCancelable};
+use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::{Node, window_from_node};
 use dom::virtualmethods::VirtualMethods;
@@ -89,16 +89,16 @@ fn is_favicon(value: &Option<String>) -> bool {
 
 impl VirtualMethods for HTMLLinkElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = HTMLElementCast::from_ref(self);
+        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
         Some(htmlelement as &VirtualMethods)
     }
 
     fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
         self.super_type().unwrap().attribute_mutated(attr, mutation);
-        if !NodeCast::from_ref(self).is_in_doc() || mutation == AttributeMutation::Removed {
+        if !self.upcast::<Node>().is_in_doc() || mutation == AttributeMutation::Removed {
             return;
         }
-        let rel = get_attr(ElementCast::from_ref(self), &atom!(rel));
+        let rel = get_attr(self.upcast::<Element>(), &atom!(rel));
         match attr.local_name() {
             &atom!(href) => {
                 if is_stylesheet(&rel) {
@@ -129,7 +129,7 @@ impl VirtualMethods for HTMLLinkElement {
         }
 
         if tree_in_doc {
-            let element = ElementCast::from_ref(self);
+            let element = self.upcast::<Element>();
 
             let rel = get_attr(element, &atom!("rel"));
             let href = get_attr(element, &atom!("href"));
@@ -154,7 +154,7 @@ impl HTMLLinkElement {
         let window = window.r();
         match UrlParser::new().base_url(&window.get_url()).parse(href) {
             Ok(url) => {
-                let element = ElementCast::from_ref(self);
+                let element = self.upcast::<Element>();
 
                 let mq_attribute = element.get_attribute(&ns!(""), &atom!("media"));
                 let value = mq_attribute.r().map(|a| a.value());
@@ -225,7 +225,7 @@ impl HTMLLinkElementMethods for HTMLLinkElement {
     // https://html.spec.whatwg.org/multipage/#dom-link-rellist
     fn RelList(&self) -> Root<DOMTokenList> {
         self.rel_list.or_init(|| {
-            DOMTokenList::new(ElementCast::from_ref(self), &atom!("rel"))
+            DOMTokenList::new(self.upcast::<Element>(), &atom!("rel"))
         })
     }
 
@@ -267,7 +267,7 @@ impl StylesheetLoadResponder for StylesheetLoadDispatcher {
         let event = Event::new(GlobalRef::Window(window.r()), "load".to_owned(),
                                EventBubbles::DoesNotBubble,
                                EventCancelable::NotCancelable);
-        let target = EventTargetCast::from_ref(elem.r());
+        let target = elem.upcast::<EventTarget>();
         event.r().fire(target);
     }
 }
diff --git a/components/script/dom/htmlmetaelement.rs b/components/script/dom/htmlmetaelement.rs
index a4898e586c7..e1194376f31 100644
--- a/components/script/dom/htmlmetaelement.rs
+++ b/components/script/dom/htmlmetaelement.rs
@@ -4,9 +4,10 @@
 
 use dom::bindings::codegen::Bindings::HTMLMetaElementBinding;
 use dom::bindings::codegen::Bindings::HTMLMetaElementBinding::HTMLMetaElementMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast, NodeCast};
+use dom::bindings::conversions::Castable;
 use dom::bindings::js::{Root, RootedReference};
 use dom::document::Document;
+use dom::element::Element;
 use dom::htmlelement::HTMLElement;
 use dom::node::{Node, window_from_node};
 use dom::virtualmethods::VirtualMethods;
@@ -38,7 +39,7 @@ impl HTMLMetaElement {
     }
 
     fn process_attributes(&self) {
-        let element = ElementCast::from_ref(self);
+        let element = self.upcast::<Element>();
         if let Some(name) = element.get_attribute(&ns!(""), &atom!("name")).r() {
             let name = name.value().to_ascii_lowercase();
             let name = name.trim_matches(HTML_SPACE_CHARACTERS);
@@ -51,12 +52,12 @@ impl HTMLMetaElement {
     }
 
     fn translate_viewport(&self) {
-        let element = ElementCast::from_ref(self);
+        let element = self.upcast::<Element>();
         if let Some(content) = element.get_attribute(&ns!(""), &atom!("content")).r() {
             let content = content.value();
             if !content.is_empty() {
                 if let Some(translated_rule) = ViewportRule::from_meta(&**content) {
-                    let node = NodeCast::from_ref(self);
+                    let node = self.upcast::<Node>();
                     let win = window_from_node(node);
                     let LayoutChan(ref layout_chan) = win.r().layout_chan();
 
@@ -83,7 +84,7 @@ impl HTMLMetaElementMethods for HTMLMetaElement {
 
 impl VirtualMethods for HTMLMetaElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = HTMLElementCast::from_ref(self);
+        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
         Some(htmlelement as &VirtualMethods)
     }
 
diff --git a/components/script/dom/htmlobjectelement.rs b/components/script/dom/htmlobjectelement.rs
index 8dd794f537d..3e11c832514 100644
--- a/components/script/dom/htmlobjectelement.rs
+++ b/components/script/dom/htmlobjectelement.rs
@@ -6,10 +6,10 @@ use dom::attr::Attr;
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::HTMLObjectElementBinding;
 use dom::bindings::codegen::Bindings::HTMLObjectElementBinding::HTMLObjectElementMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast};
+use dom::bindings::conversions::Castable;
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::element::AttributeMutation;
+use dom::element::{AttributeMutation, Element};
 use dom::htmlelement::HTMLElement;
 use dom::htmlformelement::{FormControl, HTMLFormElement};
 use dom::node::{Node, window_from_node};
@@ -53,7 +53,7 @@ impl<'a> ProcessDataURL for &'a HTMLObjectElement {
     // Makes the local `data` member match the status of the `data` attribute and starts
     /// prefetching the image. This method must be called after `data` is changed.
     fn process_data_url(&self) {
-        let elem = ElementCast::from_ref(*self);
+        let elem = self.upcast::<Element>();
 
         // TODO: support other values
         match (elem.get_attribute(&ns!(""), &atom!("type")),
@@ -92,7 +92,7 @@ impl HTMLObjectElementMethods for HTMLObjectElement {
 
 impl VirtualMethods for HTMLObjectElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = HTMLElementCast::from_ref(self);
+        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
         Some(htmlelement as &VirtualMethods)
     }
 
diff --git a/components/script/dom/htmloptgroupelement.rs b/components/script/dom/htmloptgroupelement.rs
index c2ec85e8da6..f1c011325bf 100644
--- a/components/script/dom/htmloptgroupelement.rs
+++ b/components/script/dom/htmloptgroupelement.rs
@@ -5,13 +5,13 @@
 use dom::attr::Attr;
 use dom::bindings::codegen::Bindings::HTMLOptGroupElementBinding;
 use dom::bindings::codegen::Bindings::HTMLOptGroupElementBinding::HTMLOptGroupElementMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast, HTMLOptionElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLOptionElementDerived, NodeCast};
+use dom::bindings::conversions::Castable;
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::element::{AttributeMutation, IN_ENABLED_STATE};
+use dom::element::{AttributeMutation, Element, IN_ENABLED_STATE};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node};
+use dom::htmloptionelement::HTMLOptionElement;
+use dom::node::Node;
 use dom::virtualmethods::VirtualMethods;
 use util::str::DOMString;
 
@@ -50,7 +50,7 @@ impl HTMLOptGroupElementMethods for HTMLOptGroupElement {
 
 impl VirtualMethods for HTMLOptGroupElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = HTMLElementCast::from_ref(self);
+        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
         Some(htmlelement as &VirtualMethods)
     }
 
@@ -66,22 +66,21 @@ impl VirtualMethods for HTMLOptGroupElement {
                     },
                     AttributeMutation::Removed => false,
                 };
-                let node = NodeCast::from_ref(self);
-                let el = ElementCast::from_ref(self);
+                let el = self.upcast::<Element>();
                 el.set_disabled_state(disabled_state);
                 el.set_enabled_state(!disabled_state);
-                let options = node.children().filter(|child| {
-                    child.is_htmloptionelement()
-                }).map(|child| Root::from_ref(HTMLOptionElementCast::to_ref(child.r()).unwrap()));
+                let options = el.upcast::<Node>().children().filter(|child| {
+                    child.is::<HTMLOptionElement>()
+                }).map(|child| Root::from_ref(child.downcast::<HTMLOptionElement>().unwrap()));
                 if disabled_state {
                     for option in options {
-                        let el = ElementCast::from_ref(option.r());
+                        let el = option.upcast::<Element>();
                         el.set_disabled_state(true);
                         el.set_enabled_state(false);
                     }
                 } else {
                     for option in options {
-                        let el = ElementCast::from_ref(option.r());
+                        let el = option.upcast::<Element>();
                         el.check_disabled_attribute();
                     }
                 }
diff --git a/components/script/dom/htmloptionelement.rs b/components/script/dom/htmloptionelement.rs
index b32cb7d8f11..d60ae457203 100644
--- a/components/script/dom/htmloptionelement.rs
+++ b/components/script/dom/htmloptionelement.rs
@@ -7,14 +7,15 @@ use dom::bindings::codegen::Bindings::CharacterDataBinding::CharacterDataMethods
 use dom::bindings::codegen::Bindings::HTMLOptionElementBinding;
 use dom::bindings::codegen::Bindings::HTMLOptionElementBinding::HTMLOptionElementMethods;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
-use dom::bindings::codegen::InheritTypes::{CharacterDataCast, ElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLScriptElementDerived};
-use dom::bindings::codegen::InheritTypes::{NodeCast, TextDerived};
+use dom::bindings::conversions::Castable;
 use dom::bindings::js::Root;
+use dom::characterdata::CharacterData;
 use dom::document::Document;
 use dom::element::{AttributeMutation, Element, IN_ENABLED_STATE};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node};
+use dom::htmlscriptelement::HTMLScriptElement;
+use dom::node::Node;
+use dom::text::Text;
 use dom::virtualmethods::VirtualMethods;
 use std::cell::Cell;
 use util::str::{DOMString, split_html_space_chars, str_join};
@@ -54,16 +55,16 @@ impl HTMLOptionElement {
 
 fn collect_text(element: &Element, value: &mut DOMString) {
     let svg_script = *element.namespace() == ns!(SVG) && element.local_name() == &atom!("script");
-    let html_script = element.is_htmlscriptelement();
+    let html_script = element.is::<HTMLScriptElement>();
     if svg_script || html_script {
         return;
     }
 
-    for child in NodeCast::from_ref(element).children() {
-        if child.r().is_text() {
-            let characterdata = CharacterDataCast::to_ref(child.r()).unwrap();
+    for child in element.upcast::<Node>().children() {
+        if child.is::<Text>() {
+            let characterdata = child.downcast::<CharacterData>().unwrap();
             value.push_str(&characterdata.Data());
-        } else if let Some(element_child) = ElementCast::to_ref(&*child) {
+        } else if let Some(element_child) = child.downcast::<Element>() {
             collect_text(element_child, value);
         }
     }
@@ -75,13 +76,13 @@ impl HTMLOptionElementMethods for HTMLOptionElement {
 
     // https://html.spec.whatwg.org/multipage/#dom-option-disabled
     fn SetDisabled(&self, disabled: bool) {
-        let elem = ElementCast::from_ref(self);
+        let elem = self.upcast::<Element>();
         elem.set_bool_attribute(&atom!("disabled"), disabled)
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-option-text
     fn Text(&self) -> DOMString {
-        let element = ElementCast::from_ref(self);
+        let element = self.upcast::<Element>();
         let mut content = String::new();
         collect_text(element, &mut content);
         str_join(split_html_space_chars(&content), " ")
@@ -89,13 +90,13 @@ impl HTMLOptionElementMethods for HTMLOptionElement {
 
     // https://html.spec.whatwg.org/multipage/#dom-option-text
     fn SetText(&self, value: DOMString) {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         node.SetTextContent(Some(value))
     }
 
     // https://html.spec.whatwg.org/multipage/#attr-option-value
     fn Value(&self) -> DOMString {
-        let element = ElementCast::from_ref(self);
+        let element = self.upcast::<Element>();
         let attr = &atom!("value");
         if element.has_attribute(attr) {
             element.get_string_attribute(attr)
@@ -109,7 +110,7 @@ impl HTMLOptionElementMethods for HTMLOptionElement {
 
     // https://html.spec.whatwg.org/multipage/#attr-option-label
     fn Label(&self) -> DOMString {
-        let element = ElementCast::from_ref(self);
+        let element = self.upcast::<Element>();
         let attr = &atom!("label");
         if element.has_attribute(attr) {
             element.get_string_attribute(attr)
@@ -143,7 +144,7 @@ impl HTMLOptionElementMethods for HTMLOptionElement {
 
 impl VirtualMethods for HTMLOptionElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = HTMLElementCast::from_ref(self);
+        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
         Some(htmlelement as &VirtualMethods)
     }
 
@@ -151,7 +152,7 @@ impl VirtualMethods for HTMLOptionElement {
         self.super_type().unwrap().attribute_mutated(attr, mutation);
         match attr.local_name() {
             &atom!(disabled) => {
-                let el = ElementCast::from_ref(self);
+                let el = self.upcast::<Element>();
                 match mutation {
                     AttributeMutation::Set(_) => {
                         el.set_disabled_state(true);
@@ -189,7 +190,7 @@ impl VirtualMethods for HTMLOptionElement {
             s.bind_to_tree(tree_in_doc);
         }
 
-        let el = ElementCast::from_ref(self);
+        let el = self.upcast::<Element>();
         el.check_parent_disabled_state_for_option();
     }
 
@@ -198,8 +199,8 @@ impl VirtualMethods for HTMLOptionElement {
             s.unbind_from_tree(tree_in_doc);
         }
 
-        let node = NodeCast::from_ref(self);
-        let el = ElementCast::from_ref(self);
+        let node = self.upcast::<Node>();
+        let el = self.upcast::<Element>();
         if node.GetParentNode().is_some() {
             el.check_parent_disabled_state_for_option();
         } else {
diff --git a/components/script/dom/htmlscriptelement.rs b/components/script/dom/htmlscriptelement.rs
index 994105f50b8..7ae38f951bb 100644
--- a/components/script/dom/htmlscriptelement.rs
+++ b/components/script/dom/htmlscriptelement.rs
@@ -10,16 +10,16 @@ use dom::bindings::codegen::Bindings::DocumentBinding::DocumentMethods;
 use dom::bindings::codegen::Bindings::HTMLScriptElementBinding;
 use dom::bindings::codegen::Bindings::HTMLScriptElementBinding::HTMLScriptElementMethods;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, EventTargetCast, HTMLElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLScriptElementCast, NodeCast};
+use dom::bindings::conversions::Castable;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::RootedReference;
 use dom::bindings::js::{JS, Root};
 use dom::bindings::refcounted::Trusted;
 use dom::bindings::trace::JSTraceable;
 use dom::document::Document;
-use dom::element::{AttributeMutation, ElementCreator};
+use dom::element::{AttributeMutation, Element, ElementCreator};
 use dom::event::{Event, EventBubbles, EventCancelable};
+use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::{ChildrenMutation, CloneChildrenFlag, Node};
 use dom::node::{document_from_node, window_from_node};
@@ -180,7 +180,7 @@ impl HTMLScriptElement {
         self.parser_inserted.set(false);
 
         // Step 3.
-        let element = ElementCast::from_ref(self);
+        let element = self.upcast::<Element>();
         if was_parser_inserted && element.has_attribute(&atom!("async")) {
             self.non_blocking.set(true);
         }
@@ -190,7 +190,7 @@ impl HTMLScriptElement {
             return NextParserState::Continue;
         }
         // Step 5.
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         if !node.is_in_doc() {
             return NextParserState::Continue;
         }
@@ -454,7 +454,7 @@ impl HTMLScriptElement {
     }
 
     pub fn is_javascript(&self) -> bool {
-        let element = ElementCast::from_ref(self);
+        let element = self.upcast::<Element>();
         let type_attr = element.get_attribute(&ns!(""), &atom!("type"));
         let is_js = match type_attr.as_ref().map(|s| s.value()) {
             Some(ref s) if s.is_empty() => {
@@ -508,14 +508,14 @@ impl HTMLScriptElement {
                                bubbles,
                                cancelable);
         let event = event.r();
-        let target = EventTargetCast::from_ref(self);
+        let target = self.upcast::<EventTarget>();
         event.fire(target)
     }
 }
 
 impl VirtualMethods for HTMLScriptElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = HTMLElementCast::from_ref(self);
+        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
         Some(htmlelement as &VirtualMethods)
     }
 
@@ -524,7 +524,7 @@ impl VirtualMethods for HTMLScriptElement {
         match attr.local_name() {
             &atom!("src") => {
                 if let AttributeMutation::Set(_) = mutation {
-                    if !self.parser_inserted.get() && NodeCast::from_ref(self).is_in_doc() {
+                    if !self.parser_inserted.get() && self.upcast::<Node>().is_in_doc() {
                         self.prepare();
                     }
                 }
@@ -537,7 +537,7 @@ impl VirtualMethods for HTMLScriptElement {
         if let Some(ref s) = self.super_type() {
             s.children_changed(mutation);
         }
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         if !self.parser_inserted.get() && node.is_in_doc() {
             self.prepare();
         }
@@ -561,7 +561,7 @@ impl VirtualMethods for HTMLScriptElement {
 
         // https://html.spec.whatwg.org/multipage/#already-started
         if self.already_started.get() {
-            let copy_elem = HTMLScriptElementCast::to_ref(copy).unwrap();
+            let copy_elem = copy.downcast::<HTMLScriptElement>().unwrap();
             copy_elem.mark_already_started();
         }
     }
@@ -575,12 +575,12 @@ impl HTMLScriptElementMethods for HTMLScriptElement {
 
     // https://html.spec.whatwg.org/multipage/#dom-script-text
     fn Text(&self) -> DOMString {
-        Node::collect_text_contents(NodeCast::from_ref(self).children())
+        Node::collect_text_contents(self.upcast::<Node>().children())
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-script-text
     fn SetText(&self, value: DOMString) {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         node.SetTextContent(Some(value))
     }
 }
diff --git a/components/script/dom/htmlselectelement.rs b/components/script/dom/htmlselectelement.rs
index 0ace753513d..238d6a6f1de 100644
--- a/components/script/dom/htmlselectelement.rs
+++ b/components/script/dom/htmlselectelement.rs
@@ -5,13 +5,14 @@
 use dom::attr::{Attr, AttrValue};
 use dom::bindings::codegen::Bindings::HTMLSelectElementBinding;
 use dom::bindings::codegen::Bindings::HTMLSelectElementBinding::HTMLSelectElementMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast, HTMLFieldSetElementDerived, NodeCast};
 use dom::bindings::codegen::UnionTypes::HTMLElementOrLong;
 use dom::bindings::codegen::UnionTypes::HTMLOptionElementOrHTMLOptGroupElement;
+use dom::bindings::conversions::Castable;
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::element::{AttributeMutation, IN_ENABLED_STATE};
+use dom::element::{AttributeMutation, Element, IN_ENABLED_STATE};
 use dom::htmlelement::HTMLElement;
+use dom::htmlfieldsetelement::HTMLFieldSetElement;
 use dom::htmlformelement::{FormControl, HTMLFormElement};
 use dom::node::{Node, window_from_node};
 use dom::validitystate::ValidityState;
@@ -100,14 +101,14 @@ impl HTMLSelectElementMethods for HTMLSelectElement {
 
 impl VirtualMethods for HTMLSelectElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = HTMLElementCast::from_ref(self);
+        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
         Some(htmlelement as &VirtualMethods)
     }
 
     fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
         self.super_type().unwrap().attribute_mutated(attr, mutation);
         if attr.local_name() == &atom!(disabled) {
-            let el = ElementCast::from_ref(self);
+            let el = self.upcast::<Element>();
             match mutation {
                 AttributeMutation::Set(_) => {
                     el.set_disabled_state(true);
@@ -127,7 +128,7 @@ impl VirtualMethods for HTMLSelectElement {
             s.bind_to_tree(tree_in_doc);
         }
 
-        let el = ElementCast::from_ref(self);
+        let el = self.upcast::<Element>();
         el.check_ancestors_disabled_state_for_form_control();
     }
 
@@ -136,9 +137,9 @@ impl VirtualMethods for HTMLSelectElement {
             s.unbind_from_tree(tree_in_doc);
         }
 
-        let node = NodeCast::from_ref(self);
-        let el = ElementCast::from_ref(self);
-        if node.ancestors().any(|ancestor| ancestor.r().is_htmlfieldsetelement()) {
+        let node = self.upcast::<Node>();
+        let el = self.upcast::<Element>();
+        if node.ancestors().any(|ancestor| ancestor.r().is::<HTMLFieldSetElement>()) {
             el.check_ancestors_disabled_state_for_form_control();
         } else {
             el.check_disabled_attribute();
diff --git a/components/script/dom/htmlstyleelement.rs b/components/script/dom/htmlstyleelement.rs
index 70556589681..695e250b5c6 100644
--- a/components/script/dom/htmlstyleelement.rs
+++ b/components/script/dom/htmlstyleelement.rs
@@ -5,9 +5,10 @@
 use cssparser::Parser as CssParser;
 use dom::bindings::codegen::Bindings::HTMLStyleElementBinding;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast, NodeCast};
+use dom::bindings::conversions::Castable;
 use dom::bindings::js::Root;
 use dom::document::Document;
+use dom::element::Element;
 use dom::htmlelement::HTMLElement;
 use dom::node::{ChildrenMutation, Node, window_from_node};
 use dom::virtualmethods::VirtualMethods;
@@ -39,8 +40,8 @@ impl HTMLStyleElement {
     }
 
     pub fn parse_own_css(&self) {
-        let node = NodeCast::from_ref(self);
-        let element = ElementCast::from_ref(self);
+        let node = self.upcast::<Node>();
+        let element = self.upcast::<Element>();
         assert!(node.is_in_doc());
 
         let win = window_from_node(node);
@@ -64,7 +65,7 @@ impl HTMLStyleElement {
 
 impl VirtualMethods for HTMLStyleElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = HTMLElementCast::from_ref(self);
+        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
         Some(htmlelement as &VirtualMethods)
     }
 
@@ -72,7 +73,7 @@ impl VirtualMethods for HTMLStyleElement {
         if let Some(ref s) = self.super_type() {
             s.children_changed(mutation);
         }
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         if node.is_in_doc() {
             self.parse_own_css();
         }
diff --git a/components/script/dom/htmltablecellelement.rs b/components/script/dom/htmltablecellelement.rs
index 2d017e0cb2b..2cb325d4912 100644
--- a/components/script/dom/htmltablecellelement.rs
+++ b/components/script/dom/htmltablecellelement.rs
@@ -6,12 +6,13 @@ use cssparser::RGBA;
 use dom::attr::{Attr, AttrValue};
 use dom::bindings::codegen::Bindings::HTMLTableCellElementBinding::HTMLTableCellElementMethods;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
-use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLTableCellElementDerived};
-use dom::bindings::codegen::InheritTypes::{HTMLTableRowElementDerived, NodeCast};
+use dom::bindings::conversions::Castable;
 use dom::bindings::js::LayoutJS;
 use dom::document::Document;
 use dom::element::AttributeMutation;
 use dom::htmlelement::HTMLElement;
+use dom::htmltablerowelement::HTMLTableRowElement;
+use dom::node::Node;
 use dom::virtualmethods::VirtualMethods;
 use std::cell::Cell;
 use std::cmp::max;
@@ -56,14 +57,16 @@ impl HTMLTableCellElementMethods for HTMLTableCellElement {
 
     // https://html.spec.whatwg.org/multipage/#dom-tdth-cellindex
     fn CellIndex(&self) -> i32 {
-        let self_node = NodeCast::from_ref(self);
+        let self_node = self.upcast::<Node>();
 
         let parent_children = match self_node.GetParentNode() {
-            Some(ref parent_node) if parent_node.is_htmltablerowelement() => parent_node.children(),
+            Some(ref parent_node) if parent_node.is::<HTMLTableRowElement>() => {
+                parent_node.children()
+            },
             _ => return -1,
         };
 
-        parent_children.filter(|c| c.is_htmltablecellelement())
+        parent_children.filter(|c| c.is::<HTMLTableCellElement>())
                        .position(|c| c.r() == self_node)
                        .map(|p| p as i32).unwrap_or(-1)
     }
@@ -99,7 +102,7 @@ impl HTMLTableCellElementLayoutHelpers for LayoutJS<HTMLTableCellElement> {
 
 impl VirtualMethods for HTMLTableCellElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = HTMLElementCast::from_ref(self);
+        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
         Some(htmlelement as &VirtualMethods)
     }
 
diff --git a/components/script/dom/htmltableelement.rs b/components/script/dom/htmltableelement.rs
index 6c94e4e79b5..bf22ffa429c 100644
--- a/components/script/dom/htmltableelement.rs
+++ b/components/script/dom/htmltableelement.rs
@@ -7,12 +7,10 @@ use dom::attr::{Attr, AttrValue};
 use dom::bindings::codegen::Bindings::HTMLTableElementBinding;
 use dom::bindings::codegen::Bindings::HTMLTableElementBinding::HTMLTableElementMethods;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
-use dom::bindings::codegen::InheritTypes::ElementCast;
-use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLTableCaptionElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLTableSectionElementDerived, NodeCast};
+use dom::bindings::conversions::Castable;
 use dom::bindings::js::{Root, RootedReference};
 use dom::document::Document;
-use dom::element::AttributeMutation;
+use dom::element::{AttributeMutation, Element};
 use dom::htmlelement::HTMLElement;
 use dom::htmltablecaptionelement::HTMLTableCaptionElement;
 use dom::htmltablesectionelement::HTMLTableSectionElement;
@@ -54,24 +52,24 @@ impl HTMLTableElement {
 impl HTMLTableElementMethods for HTMLTableElement {
     // https://html.spec.whatwg.org/multipage/#dom-table-caption
     fn GetCaption(&self) -> Option<Root<HTMLTableCaptionElement>> {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         node.children()
             .filter_map(|c| {
-                HTMLTableCaptionElementCast::to_ref(c.r()).map(Root::from_ref)
+                c.downcast::<HTMLTableCaptionElement>().map(Root::from_ref)
             })
             .next()
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-table-caption
     fn SetCaption(&self, new_caption: Option<&HTMLTableCaptionElement>) {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
 
         if let Some(ref caption) = self.GetCaption() {
-            NodeCast::from_ref(caption.r()).remove_self();
+            caption.upcast::<Node>().remove_self();
         }
 
         if let Some(caption) = new_caption {
-            assert!(node.InsertBefore(NodeCast::from_ref(caption),
+            assert!(node.InsertBefore(caption.upcast::<Node>(),
                                       node.GetFirstChild().as_ref().map(|n| n.r())).is_ok());
         }
     }
@@ -88,13 +86,13 @@ impl HTMLTableElementMethods for HTMLTableElement {
                 caption
             }
         };
-        HTMLElementCast::from_root(caption)
+        Root::upcast::<HTMLElement>(caption)
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-table-deletecaption
     fn DeleteCaption(&self) {
         if let Some(caption) = self.GetCaption() {
-            NodeCast::from_ref(caption.r()).remove_self();
+            caption.upcast::<Node>().remove_self();
         }
     }
 
@@ -103,15 +101,15 @@ impl HTMLTableElementMethods for HTMLTableElement {
         let tbody = HTMLTableSectionElement::new("tbody".to_owned(),
                                                  None,
                                                  document_from_node(self).r());
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         let last_tbody =
             node.rev_children()
-                .filter_map(ElementCast::to_root)
-                .find(|n| n.is_htmltablesectionelement() && n.local_name() == &atom!("tbody"));
+                .filter_map(Root::downcast::<Element>)
+                .find(|n| n.is::<HTMLTableSectionElement>() && n.local_name() == &atom!("tbody"));
         let reference_element =
-            last_tbody.and_then(|t| NodeCast::from_root(t).GetNextSibling());
+            last_tbody.and_then(|t| Root::upcast::<Node>(t).GetNextSibling());
 
-        assert!(node.InsertBefore(NodeCast::from_ref(tbody.r()),
+        assert!(node.InsertBefore(tbody.upcast::<Node>(),
                                   reference_element.r()).is_ok());
         tbody
     }
@@ -144,7 +142,7 @@ impl HTMLTableElement {
 
 impl VirtualMethods for HTMLTableElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = HTMLElementCast::from_ref(self);
+        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
         Some(htmlelement as &VirtualMethods)
     }
 
diff --git a/components/script/dom/htmltablerowelement.rs b/components/script/dom/htmltablerowelement.rs
index 81ceea4743c..66f3e424414 100644
--- a/components/script/dom/htmltablerowelement.rs
+++ b/components/script/dom/htmltablerowelement.rs
@@ -6,8 +6,7 @@ use cssparser::RGBA;
 use dom::attr::Attr;
 use dom::bindings::codegen::Bindings::HTMLTableRowElementBinding::{self, HTMLTableRowElementMethods};
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
-use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLTableDataCellElementDerived};
-use dom::bindings::codegen::InheritTypes::{HTMLTableHeaderCellElementDerived, NodeCast};
+use dom::bindings::conversions::Castable;
 use dom::bindings::error::{ErrorResult, Fallible};
 use dom::bindings::js::{JS, MutNullableHeap, Root, RootedReference};
 use dom::document::Document;
@@ -15,6 +14,7 @@ use dom::element::{AttributeMutation, Element};
 use dom::htmlcollection::{CollectionFilter, HTMLCollection};
 use dom::htmlelement::HTMLElement;
 use dom::htmltabledatacellelement::HTMLTableDataCellElement;
+use dom::htmltableheadercellelement::HTMLTableHeaderCellElement;
 use dom::node::{Node, window_from_node};
 use dom::virtualmethods::VirtualMethods;
 use std::cell::Cell;
@@ -25,8 +25,8 @@ use util::str::{self, DOMString};
 struct CellsFilter;
 impl CollectionFilter for CellsFilter {
     fn filter(&self, elem: &Element, root: &Node) -> bool {
-        (elem.is_htmltableheadercellelement() || elem.is_htmltabledatacellelement())
-            && NodeCast::from_ref(elem).GetParentNode().r() == Some(root)
+        (elem.is::<HTMLTableHeaderCellElement>() || elem.is::<HTMLTableDataCellElement>())
+            && elem.upcast::<Node>().GetParentNode().r() == Some(root)
     }
 }
 
@@ -72,13 +72,13 @@ impl HTMLTableRowElementMethods for HTMLTableRowElement {
         self.cells.or_init(|| {
             let window = window_from_node(self);
             let filter = box CellsFilter;
-            HTMLCollection::create(window.r(), NodeCast::from_ref(self), filter)
+            HTMLCollection::create(window.r(), self.upcast::<Node>(), filter)
         })
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-tr-insertcell
     fn InsertCell(&self, index: i32) -> Fallible<Root<HTMLElement>> {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         node.insert_cell_or_row(
             index,
             || self.Cells(),
@@ -87,17 +87,17 @@ impl HTMLTableRowElementMethods for HTMLTableRowElement {
 
     // https://html.spec.whatwg.org/multipage/#dom-tr-deletecell
     fn DeleteCell(&self, index: i32) -> ErrorResult {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         node.delete_cell_or_row(
             index,
             || self.Cells(),
-            |n| n.is_htmltabledatacellelement())
+            |n| n.is::<HTMLTableDataCellElement>())
     }
 }
 
 impl VirtualMethods for HTMLTableRowElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = HTMLElementCast::from_ref(self);
+        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
         Some(htmlelement as &VirtualMethods)
     }
 
diff --git a/components/script/dom/htmltablesectionelement.rs b/components/script/dom/htmltablesectionelement.rs
index 54af056b98b..b5aa3d9f675 100644
--- a/components/script/dom/htmltablesectionelement.rs
+++ b/components/script/dom/htmltablesectionelement.rs
@@ -6,7 +6,7 @@ use cssparser::RGBA;
 use dom::attr::Attr;
 use dom::bindings::codegen::Bindings::HTMLTableSectionElementBinding::{self, HTMLTableSectionElementMethods};
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
-use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLTableRowElementDerived, NodeCast};
+use dom::bindings::conversions::Castable;
 use dom::bindings::error::{ErrorResult, Fallible};
 use dom::bindings::js::{Root, RootedReference};
 use dom::document::Document;
@@ -50,20 +50,20 @@ impl HTMLTableSectionElement {
 struct RowsFilter;
 impl CollectionFilter for RowsFilter {
     fn filter(&self, elem: &Element, root: &Node) -> bool {
-        elem.is_htmltablerowelement()
-            && NodeCast::from_ref(elem).GetParentNode().r() == Some(root)
+        elem.is::<HTMLTableRowElement>()
+            && elem.upcast::<Node>().GetParentNode().r() == Some(root)
     }
 }
 
 impl HTMLTableSectionElementMethods for HTMLTableSectionElement {
     // https://html.spec.whatwg.org/multipage/#dom-tbody-rows
     fn Rows(&self) -> Root<HTMLCollection> {
-        HTMLCollection::create(&window_from_node(self), NodeCast::from_ref(self), box RowsFilter)
+        HTMLCollection::create(&window_from_node(self), self.upcast::<Node>(), box RowsFilter)
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-tbody-insertrow
     fn InsertRow(&self, index: i32) -> Fallible<Root<HTMLElement>> {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         node.insert_cell_or_row(
             index,
             || self.Rows(),
@@ -72,17 +72,17 @@ impl HTMLTableSectionElementMethods for HTMLTableSectionElement {
 
     // https://html.spec.whatwg.org/multipage/#dom-tbody-deleterow
     fn DeleteRow(&self, index: i32) -> ErrorResult {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         node.delete_cell_or_row(
             index,
             || self.Rows(),
-            |n| n.is_htmltablerowelement())
+            |n| n.is::<HTMLTableRowElement>())
     }
 }
 
 impl VirtualMethods for HTMLTableSectionElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = HTMLElementCast::from_ref(self);
+        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
         Some(htmlelement as &VirtualMethods)
     }
 
diff --git a/components/script/dom/htmltemplateelement.rs b/components/script/dom/htmltemplateelement.rs
index a7c7be5944d..36090dfbe0a 100644
--- a/components/script/dom/htmltemplateelement.rs
+++ b/components/script/dom/htmltemplateelement.rs
@@ -6,7 +6,7 @@ use dom::bindings::codegen::Bindings::DocumentBinding::DocumentMethods;
 use dom::bindings::codegen::Bindings::HTMLTemplateElementBinding;
 use dom::bindings::codegen::Bindings::HTMLTemplateElementBinding::HTMLTemplateElementMethods;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
-use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLTemplateElementCast, NodeCast};
+use dom::bindings::conversions::Castable;
 use dom::bindings::js::{JS, MutNullableHeap, Root};
 use dom::document::Document;
 use dom::documentfragment::DocumentFragment;
@@ -55,7 +55,7 @@ impl HTMLTemplateElementMethods for HTMLTemplateElement {
 
 impl VirtualMethods for HTMLTemplateElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        Some(HTMLElementCast::from_ref(self) as &VirtualMethods)
+        Some(self.upcast::<HTMLElement>() as &VirtualMethods)
     }
 
     /// https://html.spec.whatwg.org/multipage/#template-adopting-steps
@@ -64,7 +64,7 @@ impl VirtualMethods for HTMLTemplateElement {
         // Step 1.
         let doc = document_from_node(self).appropriate_template_contents_owner_document();
         // Step 2.
-        Node::adopt(NodeCast::from_ref(&*self.Content()), &doc);
+        Node::adopt(self.Content().upcast::<Node>(), &doc);
     }
 
     /// https://html.spec.whatwg.org/multipage/#the-template-element:concept-node-clone-ext
@@ -75,11 +75,11 @@ impl VirtualMethods for HTMLTemplateElement {
             // Step 1.
             return;
         }
-        let copy = HTMLTemplateElementCast::to_ref(copy).unwrap();
+        let copy = copy.downcast::<HTMLTemplateElement>().unwrap();
         // Steps 2-3.
-        let copy_contents = NodeCast::from_root(copy.Content());
+        let copy_contents = Root::upcast::<Node>(copy.Content());
         let copy_contents_doc = copy_contents.owner_doc();
-        for child in NodeCast::from_root(self.Content()).children() {
+        for child in Root::upcast::<Node>(self.Content()).children() {
             let copy_child = Node::clone(
                 &child, Some(&copy_contents_doc), CloneChildrenFlag::CloneChildren);
             copy_contents.AppendChild(&copy_child).unwrap();
diff --git a/components/script/dom/htmltextareaelement.rs b/components/script/dom/htmltextareaelement.rs
index acedfec4444..a051d1d3245 100644
--- a/components/script/dom/htmltextareaelement.rs
+++ b/components/script/dom/htmltextareaelement.rs
@@ -8,16 +8,16 @@ use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
 use dom::bindings::codegen::Bindings::HTMLTextAreaElementBinding;
 use dom::bindings::codegen::Bindings::HTMLTextAreaElementBinding::HTMLTextAreaElementMethods;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, EventTargetCast};
-use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLFieldSetElementDerived};
-use dom::bindings::codegen::InheritTypes::{KeyboardEventCast, NodeCast};
+use dom::bindings::conversions::Castable;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{LayoutJS, Root};
 use dom::bindings::refcounted::Trusted;
 use dom::document::Document;
-use dom::element::{AttributeMutation, IN_ENABLED_STATE};
+use dom::element::{AttributeMutation, IN_ENABLED_STATE, Element};
 use dom::event::{Event, EventBubbles, EventCancelable};
+use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
+use dom::htmlfieldsetelement::HTMLFieldSetElement;
 use dom::htmlformelement::{FormControl, HTMLFormElement};
 use dom::keyboardevent::KeyboardEvent;
 use dom::node::{ChildrenMutation, Node, NodeDamage};
@@ -169,13 +169,13 @@ impl HTMLTextAreaElementMethods for HTMLTextAreaElement {
 
     // https://html.spec.whatwg.org/multipage/#dom-textarea-defaultvalue
     fn DefaultValue(&self) -> DOMString {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         node.GetTextContent().unwrap()
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-textarea-defaultvalue
     fn SetDefaultValue(&self, value: DOMString) {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         node.SetTextContent(Some(value));
 
         // if the element's dirty value flag is false, then the element's
@@ -218,7 +218,7 @@ impl HTMLTextAreaElement {
 impl HTMLTextAreaElement {
     fn force_relayout(&self) {
         let doc = document_from_node(self);
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         doc.r().content_changed(node, NodeDamage::OtherNodeDamage)
     }
 
@@ -230,14 +230,14 @@ impl HTMLTextAreaElement {
                                EventBubbles::DoesNotBubble,
                                EventCancelable::NotCancelable);
 
-        let target = EventTargetCast::from_ref(self);
+        let target = self.upcast::<EventTarget>();
         target.dispatch_event(event.r());
     }
 }
 
 impl VirtualMethods for HTMLTextAreaElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = HTMLElementCast::from_ref(self);
+        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
         Some(htmlelement as &VirtualMethods)
     }
 
@@ -245,7 +245,7 @@ impl VirtualMethods for HTMLTextAreaElement {
         self.super_type().unwrap().attribute_mutated(attr, mutation);
         match attr.local_name() {
             &atom!(disabled) => {
-                let el = ElementCast::from_ref(self);
+                let el = self.upcast::<Element>();
                 match mutation {
                     AttributeMutation::Set(_) => {
                         el.set_disabled_state(true);
@@ -279,7 +279,7 @@ impl VirtualMethods for HTMLTextAreaElement {
             s.bind_to_tree(tree_in_doc);
         }
 
-        let el = ElementCast::from_ref(self);
+        let el = self.upcast::<Element>();
         el.check_ancestors_disabled_state_for_form_control();
     }
 
@@ -296,9 +296,9 @@ impl VirtualMethods for HTMLTextAreaElement {
             s.unbind_from_tree(tree_in_doc);
         }
 
-        let node = NodeCast::from_ref(self);
-        let el = ElementCast::from_ref(self);
-        if node.ancestors().any(|ancestor| ancestor.r().is_htmlfieldsetelement()) {
+        let node = self.upcast::<Node>();
+        let el = self.upcast::<Element>();
+        if node.ancestors().any(|ancestor| ancestor.r().is::<HTMLFieldSetElement>()) {
             el.check_ancestors_disabled_state_for_form_control();
         } else {
             el.check_disabled_attribute();
@@ -324,9 +324,9 @@ impl VirtualMethods for HTMLTextAreaElement {
             //TODO: set the editing position for text inputs
 
             let doc = document_from_node(self);
-            doc.r().request_focus(ElementCast::from_ref(self));
+            doc.r().request_focus(self.upcast::<Element>());
         } else if &*event.Type() == "keydown" && !event.DefaultPrevented() {
-            let keyevent: Option<&KeyboardEvent> = KeyboardEventCast::to_ref(event);
+            let keyevent: Option<&KeyboardEvent> = event.downcast::<KeyboardEvent>();
             keyevent.map(|kevent| {
                 match self.textinput.borrow_mut().handle_keydown(kevent) {
                     KeyReaction::TriggerDefaultAction => (),
diff --git a/components/script/dom/htmltitleelement.rs b/components/script/dom/htmltitleelement.rs
index 0ad9467c260..8a5f90ff14e 100644
--- a/components/script/dom/htmltitleelement.rs
+++ b/components/script/dom/htmltitleelement.rs
@@ -5,9 +5,9 @@
 use dom::bindings::codegen::Bindings::HTMLTitleElementBinding;
 use dom::bindings::codegen::Bindings::HTMLTitleElementBinding::HTMLTitleElementMethods;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
-use dom::bindings::codegen::InheritTypes::{CharacterDataCast, HTMLElementCast};
-use dom::bindings::codegen::InheritTypes::{NodeCast, TextCast};
+use dom::bindings::conversions::Castable;
 use dom::bindings::js::Root;
+use dom::characterdata::CharacterData;
 use dom::document::Document;
 use dom::htmlelement::HTMLElement;
 use dom::node::{ChildrenMutation, Node};
@@ -39,12 +39,12 @@ impl HTMLTitleElement {
 impl HTMLTitleElementMethods for HTMLTitleElement {
     // https://html.spec.whatwg.org/multipage/#dom-title-text
     fn Text(&self) -> DOMString {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         let mut content = String::new();
         for child in node.children() {
-            let text: Option<&Text> = TextCast::to_ref(child.r());
+            let text: Option<&Text> = child.downcast::<Text>();
             match text {
-                Some(text) => content.push_str(&CharacterDataCast::from_ref(text).data()),
+                Some(text) => content.push_str(&text.upcast::<CharacterData>().data()),
                 None => (),
             }
         }
@@ -53,14 +53,14 @@ impl HTMLTitleElementMethods for HTMLTitleElement {
 
     // https://html.spec.whatwg.org/multipage/#dom-title-text
     fn SetText(&self, value: DOMString) {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         node.SetTextContent(Some(value))
     }
 }
 
 impl VirtualMethods for HTMLTitleElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = HTMLElementCast::from_ref(self);
+        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
         Some(htmlelement as &VirtualMethods)
     }
 
@@ -68,14 +68,14 @@ impl VirtualMethods for HTMLTitleElement {
         if let Some(ref s) = self.super_type() {
             s.children_changed(mutation);
         }
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         if node.is_in_doc() {
             node.owner_doc().title_changed();
         }
     }
 
     fn bind_to_tree(&self, is_in_doc: bool) {
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         if is_in_doc {
             let document = node.owner_doc();
             document.r().title_changed();
diff --git a/components/script/dom/keyboardevent.rs b/components/script/dom/keyboardevent.rs
index 405c3813ea2..e877ea95fbc 100644
--- a/components/script/dom/keyboardevent.rs
+++ b/components/script/dom/keyboardevent.rs
@@ -5,11 +5,12 @@
 use dom::bindings::codegen::Bindings::KeyboardEventBinding;
 use dom::bindings::codegen::Bindings::KeyboardEventBinding::{KeyboardEventConstants, KeyboardEventMethods};
 use dom::bindings::codegen::Bindings::UIEventBinding::UIEventMethods;
-use dom::bindings::codegen::InheritTypes::{EventCast, UIEventCast};
+use dom::bindings::conversions::Castable;
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{Root, RootedReference};
 use dom::bindings::utils::{Reflectable, reflect_dom_object};
+use dom::event::Event;
 use dom::uievent::UIEvent;
 use dom::window::Window;
 use msg::constellation_msg;
@@ -761,12 +762,12 @@ impl KeyboardEventMethods for KeyboardEvent {
                          _modifiersListArg: DOMString,
                          repeat: bool,
                          _locale: DOMString) {
-        let event = EventCast::from_ref(self);
+        let event = self.upcast::<Event>();
         if event.dispatching() {
             return;
         }
 
-        let uievent = UIEventCast::from_ref(self);
+        let uievent = self.upcast::<UIEvent>();
         uievent.InitUIEvent(typeArg, canBubbleArg, cancelableArg, viewArg, 0);
         *self.key_string.borrow_mut() = keyArg;
         self.location.set(locationArg);
diff --git a/components/script/dom/macros.rs b/components/script/dom/macros.rs
index 5d843ce5e26..e5193dcc8f1 100644
--- a/components/script/dom/macros.rs
+++ b/components/script/dom/macros.rs
@@ -6,9 +6,10 @@
 macro_rules! make_getter(
     ( $attr:ident, $htmlname:expr ) => (
         fn $attr(&self) -> DOMString {
-            use dom::bindings::codegen::InheritTypes::ElementCast;
+            use dom::bindings::conversions::Castable;
+            use dom::element::Element;
             use string_cache::Atom;
-            let element = ElementCast::from_ref(self);
+            let element = self.upcast::<Element>();
             element.get_string_attribute(&Atom::from_slice($htmlname))
         }
     );
@@ -21,9 +22,10 @@ macro_rules! make_getter(
 macro_rules! make_bool_getter(
     ( $attr:ident, $htmlname:expr ) => (
         fn $attr(&self) -> bool {
-            use dom::bindings::codegen::InheritTypes::ElementCast;
+            use dom::bindings::conversions::Castable;
+            use dom::element::Element;
             use string_cache::Atom;
-            let element = ElementCast::from_ref(self);
+            let element = self.upcast::<Element>();
             // FIXME(pcwalton): Do this at compile time, not runtime.
             element.has_attribute(&Atom::from_slice($htmlname))
         }
@@ -37,9 +39,10 @@ macro_rules! make_bool_getter(
 macro_rules! make_uint_getter(
     ($attr:ident, $htmlname:expr, $default:expr) => (
         fn $attr(&self) -> u32 {
-            use dom::bindings::codegen::InheritTypes::ElementCast;
+            use dom::bindings::conversions::Castable;
+            use dom::element::Element;
             use string_cache::Atom;
-            let element = ElementCast::from_ref(self);
+            let element = self.upcast::<Element>();
             // FIXME(pcwalton): Do this at compile time, not runtime.
             element.get_uint_attribute(&Atom::from_slice($htmlname), $default)
         }
@@ -56,9 +59,10 @@ macro_rules! make_uint_getter(
 macro_rules! make_url_getter(
     ( $attr:ident, $htmlname:expr ) => (
         fn $attr(&self) -> DOMString {
-            use dom::bindings::codegen::InheritTypes::ElementCast;
+            use dom::bindings::conversions::Castable;
+            use dom::element::Element;
             use string_cache::Atom;
-            let element = ElementCast::from_ref(self);
+            let element = self.upcast::<Element>();
             // FIXME(pcwalton): Do this at compile time, not runtime.
             element.get_url_attribute(&Atom::from_slice($htmlname))
         }
@@ -73,9 +77,10 @@ macro_rules! make_url_getter(
 macro_rules! make_url_or_base_getter(
     ( $attr:ident, $htmlname:expr ) => (
         fn $attr(&self) -> DOMString {
-            use dom::bindings::codegen::InheritTypes::ElementCast;
+            use dom::bindings::conversions::Castable;
+            use dom::element::Element;
             use string_cache::Atom;
-            let element = ElementCast::from_ref(self);
+            let element = self.upcast::<Element>();
             let url = element.get_url_attribute(&Atom::from_slice($htmlname));
             if url.is_empty() {
                 let window = window_from_node(self);
@@ -94,11 +99,12 @@ macro_rules! make_url_or_base_getter(
 macro_rules! make_enumerated_getter(
     ( $attr:ident, $htmlname:expr, $default:expr, $(($choices: pat))|+) => (
         fn $attr(&self) -> DOMString {
-            use dom::bindings::codegen::InheritTypes::ElementCast;
+            use dom::bindings::conversions::Castable;
+            use dom::element::Element;
             use std::ascii::AsciiExt;
             use std::borrow::ToOwned;
             use string_cache::Atom;
-            let element = ElementCast::from_ref(self);
+            let element = self.upcast::<Element>();
             let mut val = element.get_string_attribute(&Atom::from_slice($htmlname));
             val.make_ascii_lowercase();
             // https://html.spec.whatwg.org/multipage/#attr-fs-method
@@ -119,9 +125,10 @@ macro_rules! make_enumerated_getter(
 macro_rules! make_setter(
     ( $attr:ident, $htmlname:expr ) => (
         fn $attr(&self, value: DOMString) {
-            use dom::bindings::codegen::InheritTypes::ElementCast;
+            use dom::bindings::conversions::Castable;
+            use dom::element::Element;
             use string_cache::Atom;
-            let element = ElementCast::from_ref(self);
+            let element = self.upcast::<Element>();
             // FIXME(pcwalton): Do this at compile time, not at runtime.
             element.set_string_attribute(&Atom::from_slice($htmlname), value)
         }
@@ -132,9 +139,10 @@ macro_rules! make_setter(
 macro_rules! make_bool_setter(
     ( $attr:ident, $htmlname:expr ) => (
         fn $attr(&self, value: bool) {
-            use dom::bindings::codegen::InheritTypes::ElementCast;
+            use dom::bindings::conversions::Castable;
+            use dom::element::Element;
             use string_cache::Atom;
-            let element = ElementCast::from_ref(self);
+            let element = self.upcast::<Element>();
             // FIXME(pcwalton): Do this at compile time, not at runtime.
             element.set_bool_attribute(&Atom::from_slice($htmlname), value)
         }
@@ -145,7 +153,8 @@ macro_rules! make_bool_setter(
 macro_rules! make_uint_setter(
     ($attr:ident, $htmlname:expr, $default:expr) => (
         fn $attr(&self, value: u32) {
-            use dom::bindings::codegen::InheritTypes::ElementCast;
+            use dom::bindings::conversions::Castable;
+            use dom::element::Element;
             use dom::values::UNSIGNED_LONG_MAX;
             use string_cache::Atom;
             let value = if value > UNSIGNED_LONG_MAX {
@@ -153,7 +162,7 @@ macro_rules! make_uint_setter(
             } else {
                 value
             };
-            let element = ElementCast::from_ref(self);
+            let element = self.upcast::<Element>();
             // FIXME(pcwalton): Do this at compile time, not at runtime.
             element.set_uint_attribute(&Atom::from_slice($htmlname), value)
         }
@@ -167,7 +176,8 @@ macro_rules! make_uint_setter(
 macro_rules! make_limited_uint_setter(
     ($attr:ident, $htmlname:expr, $default:expr) => (
         fn $attr(&self, value: u32) -> $crate::dom::bindings::error::ErrorResult {
-            use dom::bindings::codegen::InheritTypes::ElementCast;
+            use dom::bindings::conversions::Castable;
+            use dom::element::Element;
             use dom::values::UNSIGNED_LONG_MAX;
             use string_cache::Atom;
             let value = if value == 0 {
@@ -177,7 +187,7 @@ macro_rules! make_limited_uint_setter(
             } else {
                 value
             };
-            let element = ElementCast::from_ref(self);
+            let element = self.upcast::<Element>();
             // FIXME(pcwalton): Do this at compile time, not runtime.
             element.set_uint_attribute(&Atom::from_slice($htmlname), value);
             Ok(())
@@ -195,9 +205,10 @@ macro_rules! make_limited_uint_setter(
 macro_rules! make_atomic_setter(
     ( $attr:ident, $htmlname:expr ) => (
         fn $attr(&self, value: DOMString) {
-            use dom::bindings::codegen::InheritTypes::ElementCast;
+            use dom::bindings::conversions::Castable;
+            use dom::element::Element;
             use string_cache::Atom;
-            let element = ElementCast::from_ref(self);
+            let element = self.upcast::<Element>();
             // FIXME(pcwalton): Do this at compile time, not at runtime.
             element.set_atomic_attribute(&Atom::from_slice($htmlname), value)
         }
@@ -239,12 +250,16 @@ macro_rules! no_jsmanaged_fields(
 macro_rules! define_event_handler(
     ($handler: ident, $event_type: ident, $getter: ident, $setter: ident) => (
         fn $getter(&self) -> Option<::std::rc::Rc<$handler>> {
-            let eventtarget = EventTargetCast::from_ref(self);
+            use dom::bindings::conversions::Castable;
+            use dom::eventtarget::EventTarget;
+            let eventtarget = self.upcast::<EventTarget>();
             eventtarget.get_event_handler_common(stringify!($event_type))
         }
 
         fn $setter(&self, listener: Option<::std::rc::Rc<$handler>>) {
-            let eventtarget = EventTargetCast::from_ref(self);
+            use dom::bindings::conversions::Castable;
+            use dom::eventtarget::EventTarget;
+            let eventtarget = self.upcast::<EventTarget>();
             eventtarget.set_event_handler_common(stringify!($event_type), listener)
         }
     )
diff --git a/components/script/dom/messageevent.rs b/components/script/dom/messageevent.rs
index 96a507723c8..88ff10e4a55 100644
--- a/components/script/dom/messageevent.rs
+++ b/components/script/dom/messageevent.rs
@@ -5,7 +5,7 @@
 use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
 use dom::bindings::codegen::Bindings::MessageEventBinding;
 use dom::bindings::codegen::Bindings::MessageEventBinding::MessageEventMethods;
-use dom::bindings::codegen::InheritTypes::EventCast;
+use dom::bindings::conversions::Castable;
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
@@ -51,7 +51,7 @@ impl MessageEvent {
                -> Root<MessageEvent> {
         let ev = MessageEvent::new_initialized(global, data, origin, lastEventId);
         {
-            let event = EventCast::from_ref(ev.r());
+            let event = ev.upcast::<Event>();
             event.InitEvent(type_, bubbles, cancelable);
         }
         ev
@@ -78,7 +78,7 @@ impl MessageEvent {
         let messageevent = MessageEvent::new(
             scope, "message".to_owned(), false, false, message,
             "".to_owned(), "".to_owned());
-        let event = EventCast::from_ref(messageevent.r());
+        let event = messageevent.upcast::<Event>();
         event.fire(target);
     }
 }
diff --git a/components/script/dom/mod.rs b/components/script/dom/mod.rs
index c8179c3f0e3..6ae697ab19d 100644
--- a/components/script/dom/mod.rs
+++ b/components/script/dom/mod.rs
@@ -151,8 +151,8 @@
 //! # use script::dom::node::Node;
 //! # use script::dom::htmlelement::HTMLElement;
 //! fn f(element: &Element) {
-//!     let base: &Node = NodeCast::from_ref(element);
-//!     let derived: Option<&HTMLElement> = HTMLElementCast::to_ref(element);
+//!     let base: &Node = element.upcast::<Node>();
+//!     let derived: Option<&HTMLElement> = element.downcast::<HTMLElement>();
 //! }
 //! ```
 //!
diff --git a/components/script/dom/mouseevent.rs b/components/script/dom/mouseevent.rs
index eb57489c1e4..63c4e5ba8bd 100644
--- a/components/script/dom/mouseevent.rs
+++ b/components/script/dom/mouseevent.rs
@@ -5,7 +5,7 @@
 use dom::bindings::codegen::Bindings::MouseEventBinding;
 use dom::bindings::codegen::Bindings::MouseEventBinding::MouseEventMethods;
 use dom::bindings::codegen::Bindings::UIEventBinding::UIEventMethods;
-use dom::bindings::codegen::InheritTypes::{EventCast, UIEventCast};
+use dom::bindings::conversions::Castable;
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, MutNullableHeap, Root, RootedReference};
@@ -189,12 +189,12 @@ impl MouseEventMethods for MouseEvent {
                       metaKeyArg: bool,
                       buttonArg: i16,
                       relatedTargetArg: Option<&EventTarget>) {
-        let event: &Event = EventCast::from_ref(self);
+        let event: &Event = self.upcast::<Event>();
         if event.dispatching() {
             return;
         }
 
-        let uievent: &UIEvent = UIEventCast::from_ref(self);
+        let uievent: &UIEvent = self.upcast::<UIEvent>();
         uievent.InitUIEvent(typeArg, canBubbleArg, cancelableArg, viewArg, detailArg);
         self.screen_x.set(screenXArg);
         self.screen_y.set(screenYArg);
diff --git a/components/script/dom/node.rs b/components/script/dom/node.rs
index b50d71ccd10..92389b127aa 100644
--- a/components/script/dom/node.rs
+++ b/components/script/dom/node.rs
@@ -19,17 +19,10 @@ use dom::bindings::codegen::Bindings::NamedNodeMapBinding::NamedNodeMapMethods;
 use dom::bindings::codegen::Bindings::NodeBinding::{NodeConstants, NodeMethods};
 use dom::bindings::codegen::Bindings::NodeListBinding::NodeListMethods;
 use dom::bindings::codegen::Bindings::ProcessingInstructionBinding::ProcessingInstructionMethods;
-use dom::bindings::codegen::InheritTypes::HTMLElementBase;
-use dom::bindings::codegen::InheritTypes::HTMLElementCast;
-use dom::bindings::codegen::InheritTypes::{CharacterDataCast, CharacterDataTypeId};
-use dom::bindings::codegen::InheritTypes::{DocumentCast, DocumentDerived, DocumentTypeCast};
-use dom::bindings::codegen::InheritTypes::{ElementCast, ElementDerived, ElementTypeId};
-use dom::bindings::codegen::InheritTypes::{EventTargetCast, EventTargetTypeId};
-use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId};
-use dom::bindings::codegen::InheritTypes::{NodeBase, NodeCast, NodeTypeId};
-use dom::bindings::codegen::InheritTypes::{ProcessingInstructionCast, TextCast, TextDerived};
+use dom::bindings::codegen::InheritTypes::{CharacterDataTypeId, ElementTypeId, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, NodeTypeId};
 use dom::bindings::codegen::UnionTypes::NodeOrString;
-use dom::bindings::conversions;
+use dom::bindings::conversions::{self, Castable, DerivedFrom};
 use dom::bindings::error::{Error, ErrorResult, Fallible};
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
@@ -362,9 +355,9 @@ impl<'a> Iterator for QuerySelectorIterator {
         // TODO(cgaebel): Is it worth it to build a bloom filter here
         // (instead of passing `None`)? Probably.
         self.iterator.by_ref().filter_map(|node| {
-            if let Some(element) = ElementCast::to_root(node) {
+            if let Some(element) = Root::downcast::<Element>(node) {
                 if matches(selectors, &element, None) {
-                    return Some(NodeCast::from_root(element))
+                    return Some(Root::upcast::<Node>(element))
                 }
             }
             None
@@ -424,7 +417,7 @@ impl Node {
         match self.type_id() {
             NodeTypeId::DocumentType => 0,
             NodeTypeId::CharacterData(_) => {
-                CharacterDataCast::to_ref(self).unwrap().Length()
+                self.downcast::<CharacterData>().unwrap().Length()
             },
             _ => self.children_count(),
         }
@@ -725,7 +718,7 @@ impl Node {
             Err(()) => Err(Error::Syntax),
             // Step 3.
             Ok(ref selectors) => {
-                Ok(self.traverse_preorder().filter_map(ElementCast::to_root).find(|element| {
+                Ok(self.traverse_preorder().filter_map(Root::downcast::<Element>).find(|element| {
                     matches(selectors, element, None)
                 }))
             }
@@ -795,7 +788,7 @@ impl Node {
 
     pub fn child_elements(&self) -> ChildElementIterator {
         fn to_temporary(node: Root<Node>) -> Option<Root<Element>> {
-            ElementCast::to_root(node)
+            Root::downcast::<Element>(node)
         }
         self.children()
             .filter_map(to_temporary as fn(_) -> _)
@@ -832,7 +825,7 @@ impl Node {
             systemId: "".to_owned(),
 
             attrs: {
-                let e: Option<&Element> = ElementCast::to_ref(self);
+                let e: Option<&Element> = self.downcast::<Element>();
                 match e {
                     Some(element) => element.summarize(),
                     None => vec!(),
@@ -843,7 +836,7 @@ impl Node {
                 self.owner_doc()
                     .r()
                     .GetDocumentElement()
-                    .map(|elem| NodeCast::from_ref(elem.r()) == self)
+                    .map(|elem| elem.upcast::<Node>() == self)
                     .unwrap_or(false),
 
             shortValue: self.GetNodeValue().unwrap_or("".to_owned()), //FIXME: truncate
@@ -853,11 +846,11 @@ impl Node {
 
     // https://dvcs.w3.org/hg/innerhtml/raw-file/tip/index.html#dfn-concept-parse-fragment
     pub fn parse_fragment(&self, markup: DOMString) -> Fallible<Root<DocumentFragment>> {
-        let context_node: &Node = NodeCast::from_ref(self);
+        let context_node: &Node = self.upcast::<Node>();
         let context_document = document_from_node(self);
         let fragment = DocumentFragment::new(context_document.r());
         if context_document.r().is_html_document() {
-            let fragment_node = NodeCast::from_ref(fragment.r());
+            let fragment_node = fragment.upcast::<Node>();
             parse_html_fragment(context_node, markup, fragment_node);
         } else {
             // FIXME: XML case
@@ -870,7 +863,7 @@ impl Node {
     pub fn insert_cell_or_row<F, G, I>(&self, index: i32, get_items: F, new_child: G) -> Fallible<Root<HTMLElement>>
         where F: Fn() -> Root<HTMLCollection>,
               G: Fn() -> Root<I>,
-              I: NodeBase + HTMLElementBase + Reflectable,
+              I: DerivedFrom<Node> + DerivedFrom<HTMLElement> + Reflectable,
     {
         if index < -1 {
             return Err(Error::IndexSize);
@@ -882,7 +875,7 @@ impl Node {
             None
         } else {
             match get_items().elements_iter()
-                             .map(NodeCast::from_root)
+                             .map(Root::upcast::<Node>)
                              .map(Some)
                              .chain(iter::once(None))
                              .nth(index as usize) {
@@ -892,11 +885,11 @@ impl Node {
         };
 
         {
-            let tr_node = NodeCast::from_ref(tr.r());
+            let tr_node = tr.upcast::<Node>();
             try!(self.InsertBefore(tr_node, after_node.r()));
         }
 
-        Ok(HTMLElementCast::from_root(tr))
+        Ok(Root::upcast::<HTMLElement>(tr))
     }
 
     /// Used by `HTMLTableSectionElement::DeleteRow` and `HTMLTableRowElement::DeleteCell`
@@ -907,9 +900,9 @@ impl Node {
         let element = match index {
             index if index < -1 => return Err(Error::IndexSize),
             -1 => {
-                let last_child = NodeCast::from_ref(self).GetLastChild();
+                let last_child = self.upcast::<Node>().GetLastChild();
                 match last_child.and_then(|node| node.inclusively_preceding_siblings()
-                                                     .filter_map(ElementCast::to_root)
+                                                     .filter_map(Root::downcast::<Element>)
                                                      .filter(|elem| is_delete_type(elem))
                                                      .next()) {
                     Some(element) => element,
@@ -922,7 +915,7 @@ impl Node {
             },
         };
 
-        NodeCast::from_ref(element.r()).remove_self();
+        element.upcast::<Node>().remove_self();
         Ok(())
     }
 }
@@ -994,7 +987,7 @@ impl LayoutNodeHelpers for LayoutJS<Node> {
     #[inline]
     #[allow(unsafe_code)]
     unsafe fn is_element_for_layout(&self) -> bool {
-        (*self.unsafe_get()).is_element()
+        (*self.unsafe_get()).is::<Element>()
     }
 
     #[inline]
@@ -1300,7 +1293,7 @@ pub enum CloneChildrenFlag {
 fn as_uintptr<T>(t: &T) -> uintptr_t { t as *const T as uintptr_t }
 
 impl Node {
-    pub fn reflect_node<N: Reflectable + NodeBase>
+    pub fn reflect_node<N: DerivedFrom<Node> + Reflectable>
             (node:      Box<N>,
              document:  &Document,
              wrap_fn:   extern "Rust" fn(*mut JSContext, GlobalRef, Box<N>) -> Root<N>)
@@ -1384,12 +1377,12 @@ impl Node {
         // Step 4-5.
         match node.type_id() {
             NodeTypeId::CharacterData(CharacterDataTypeId::Text) => {
-                if parent.is_document() {
+                if parent.is::<Document>() {
                     return Err(Error::HierarchyRequest);
                 }
             },
             NodeTypeId::DocumentType => {
-                if !parent.is_document() {
+                if !parent.is::<Document>() {
                     return Err(Error::HierarchyRequest);
                 }
             },
@@ -1407,7 +1400,7 @@ impl Node {
                 NodeTypeId::DocumentFragment => {
                     // Step 6.1.1(b)
                     if node.children()
-                           .any(|c| c.r().is_text())
+                           .any(|c| c.r().is::<Text>())
                     {
                         return Err(Error::HierarchyRequest);
                     }
@@ -1452,7 +1445,7 @@ impl Node {
                         Some(child) => {
                             if parent.children()
                                      .take_while(|c| c.r() != child)
-                                     .any(|c| c.r().is_element())
+                                     .any(|c| c.r().is::<Element>())
                             {
                                 return Err(Error::HierarchyRequest);
                             }
@@ -1626,23 +1619,23 @@ impl Node {
         // XXXabinader: clone() for each node as trait?
         let copy: Root<Node> = match node.type_id() {
             NodeTypeId::DocumentType => {
-                let doctype: &DocumentType = DocumentTypeCast::to_ref(node).unwrap();
+                let doctype: &DocumentType = node.downcast::<DocumentType>().unwrap();
                 let doctype = DocumentType::new(doctype.name().clone(),
                                                 Some(doctype.public_id().clone()),
                                                 Some(doctype.system_id().clone()), document.r());
-                NodeCast::from_root(doctype)
+                Root::upcast::<Node>(doctype)
             },
             NodeTypeId::DocumentFragment => {
                 let doc_fragment = DocumentFragment::new(document.r());
-                NodeCast::from_root(doc_fragment)
+                Root::upcast::<Node>(doc_fragment)
             },
             NodeTypeId::CharacterData(CharacterDataTypeId::Comment) => {
-                let cdata = CharacterDataCast::to_ref(node).unwrap();
+                let cdata = node.downcast::<CharacterData>().unwrap();
                 let comment = Comment::new(cdata.Data(), document.r());
-                NodeCast::from_root(comment)
+                Root::upcast::<Node>(comment)
             },
             NodeTypeId::Document => {
-                let document = DocumentCast::to_ref(node).unwrap();
+                let document = node.downcast::<Document>().unwrap();
                 let is_html_doc = match document.is_html_document() {
                     true => IsHTMLDocument::HTMLDocument,
                     false => IsHTMLDocument::NonHTMLDocument,
@@ -1652,10 +1645,10 @@ impl Node {
                 let document = Document::new(window, Some((*document.url()).clone()),
                                              is_html_doc, None,
                                              None, DocumentSource::NotFromParser, loader);
-                NodeCast::from_root(document)
+                Root::upcast::<Node>(document)
             },
             NodeTypeId::Element(..) => {
-                let element = ElementCast::to_ref(node).unwrap();
+                let element = node.downcast::<Element>().unwrap();
                 let name = QualName {
                     ns: element.namespace().clone(),
                     local: element.local_name().clone()
@@ -1663,23 +1656,23 @@ impl Node {
                 let element = Element::create(name,
                     element.prefix().as_ref().map(|p| Atom::from_slice(&p)),
                     document.r(), ElementCreator::ScriptCreated);
-                NodeCast::from_root(element)
+                Root::upcast::<Node>(element)
             },
             NodeTypeId::CharacterData(CharacterDataTypeId::Text) => {
-                let cdata = CharacterDataCast::to_ref(node).unwrap();
+                let cdata = node.downcast::<CharacterData>().unwrap();
                 let text = Text::new(cdata.Data(), document.r());
-                NodeCast::from_root(text)
+                Root::upcast::<Node>(text)
             },
             NodeTypeId::CharacterData(CharacterDataTypeId::ProcessingInstruction) => {
-                let pi = ProcessingInstructionCast::to_ref(node).unwrap();
+                let pi = node.downcast::<ProcessingInstruction>().unwrap();
                 let pi = ProcessingInstruction::new(pi.Target(),
-                                                    CharacterDataCast::from_ref(pi).Data(), document.r());
-                NodeCast::from_root(pi)
+                                                    pi.upcast::<CharacterData>().Data(), document.r());
+                Root::upcast::<Node>(pi)
             },
         };
 
         // Step 3.
-        let document = match DocumentCast::to_ref(copy.r()) {
+        let document = match copy.downcast::<Document>() {
             Some(doc) => Root::from_ref(doc),
             None => Root::from_ref(document.r()),
         };
@@ -1688,14 +1681,14 @@ impl Node {
         // Step 4 (some data already copied in step 2).
         match node.type_id() {
             NodeTypeId::Document => {
-                let node_doc = DocumentCast::to_ref(node).unwrap();
-                let copy_doc = DocumentCast::to_ref(copy.r()).unwrap();
+                let node_doc = node.downcast::<Document>().unwrap();
+                let copy_doc = copy.downcast::<Document>().unwrap();
                 copy_doc.set_encoding_name(node_doc.encoding_name().clone());
                 copy_doc.set_quirks_mode(node_doc.quirks_mode());
             },
             NodeTypeId::Element(..) => {
-                let node_elem = ElementCast::to_ref(node).unwrap();
-                let copy_elem = ElementCast::to_ref(copy.r()).unwrap();
+                let node_elem = node.downcast::<Element>().unwrap();
+                let copy_elem = copy.downcast::<Element>().unwrap();
 
                 for attr in node_elem.attrs().iter().map(JS::root) {
                     copy_elem.push_new_attribute(attr.local_name().clone(),
@@ -1727,9 +1720,9 @@ impl Node {
     pub fn collect_text_contents<T: Iterator<Item=Root<Node>>>(iterator: T) -> String {
         let mut content = String::new();
         for node in iterator {
-            let text = TextCast::to_ref(node.r());
+            let text = node.downcast::<Text>();
             match text {
-                Some(text) => content.push_str(&CharacterDataCast::from_ref(text).Data()),
+                Some(text) => content.push_str(&text.upcast::<CharacterData>().Data()),
                 None => (),
             }
         }
@@ -1759,7 +1752,7 @@ impl Node {
 
         match node.type_id() {
             NodeTypeId::Element(_) => {
-                let element = ElementCast::to_ref(node).unwrap();
+                let element = node.downcast::<Element>().unwrap();
                 // Step 1.
                 if *element.namespace() != ns!("") && *element.prefix() == prefix {
                     return element.namespace().clone()
@@ -1785,16 +1778,16 @@ impl Node {
                     // Step 3.
                     None => ns!(""),
                     // Step 4.
-                    Some(parent) => Node::locate_namespace(NodeCast::from_ref(parent.r()), prefix)
+                    Some(parent) => Node::locate_namespace(parent.upcast::<Node>(), prefix)
                 }
             },
             NodeTypeId::Document => {
-                match DocumentCast::to_ref(node).unwrap().GetDocumentElement().r() {
+                match node.downcast::<Document>().unwrap().GetDocumentElement().r() {
                     // Step 1.
                     None => ns!(""),
                     // Step 2.
                     Some(document_element) => {
-                        Node::locate_namespace(NodeCast::from_ref(document_element), prefix)
+                        Node::locate_namespace(document_element.upcast::<Node>(), prefix)
                     }
                 }
             },
@@ -1804,7 +1797,7 @@ impl Node {
                      // Step 1.
                      None => ns!(""),
                      // Step 2.
-                     Some(parent) => Node::locate_namespace(NodeCast::from_ref(parent.r()), prefix)
+                     Some(parent) => Node::locate_namespace(parent.upcast::<Node>(), prefix)
                  }
         }
     }
@@ -1835,18 +1828,18 @@ impl NodeMethods for Node {
     fn NodeName(&self) -> DOMString {
         match self.type_id() {
             NodeTypeId::Element(..) => {
-                let elem: &Element = ElementCast::to_ref(self).unwrap();
+                let elem: &Element = self.downcast::<Element>().unwrap();
                 elem.TagName()
             }
             NodeTypeId::CharacterData(CharacterDataTypeId::Text) => "#text".to_owned(),
             NodeTypeId::CharacterData(CharacterDataTypeId::ProcessingInstruction) => {
                 let processing_instruction: &ProcessingInstruction =
-                    ProcessingInstructionCast::to_ref(self).unwrap();
+                    self.downcast::<ProcessingInstruction>().unwrap();
                 processing_instruction.Target()
             }
             NodeTypeId::CharacterData(CharacterDataTypeId::Comment) => "#comment".to_owned(),
             NodeTypeId::DocumentType => {
-                let doctype: &DocumentType = DocumentTypeCast::to_ref(self).unwrap();
+                let doctype: &DocumentType = self.downcast::<DocumentType>().unwrap();
                 doctype.name().clone()
             },
             NodeTypeId::DocumentFragment => "#document-fragment".to_owned(),
@@ -1877,7 +1870,7 @@ impl NodeMethods for Node {
 
     // https://dom.spec.whatwg.org/#dom-node-parentelement
     fn GetParentElement(&self) -> Option<Root<Element>> {
-        self.GetParentNode().and_then(ElementCast::to_root)
+        self.GetParentNode().and_then(Root::downcast::<Element>)
     }
 
     // https://dom.spec.whatwg.org/#dom-node-haschildnodes
@@ -1918,7 +1911,7 @@ impl NodeMethods for Node {
     fn GetNodeValue(&self) -> Option<DOMString> {
         match self.type_id() {
             NodeTypeId::CharacterData(..) => {
-                let chardata: &CharacterData = CharacterDataCast::to_ref(self).unwrap();
+                let chardata: &CharacterData = self.downcast::<CharacterData>().unwrap();
                 Some(chardata.Data())
             }
             _ => {
@@ -1946,7 +1939,7 @@ impl NodeMethods for Node {
                 Some(content)
             }
             NodeTypeId::CharacterData(..) => {
-                let characterdata: &CharacterData = CharacterDataCast::to_ref(self).unwrap();
+                let characterdata: &CharacterData = self.downcast::<CharacterData>().unwrap();
                 Some(characterdata.Data())
             }
             NodeTypeId::DocumentType |
@@ -1967,14 +1960,14 @@ impl NodeMethods for Node {
                     None
                 } else {
                     let document = self.owner_doc();
-                    Some(NodeCast::from_root(document.r().CreateTextNode(value)))
+                    Some(Root::upcast::<Node>(document.r().CreateTextNode(value)))
                 };
 
                 // Step 3.
                 Node::replace_all(node.r(), self);
             }
             NodeTypeId::CharacterData(..) => {
-                let characterdata: &CharacterData = CharacterDataCast::to_ref(self).unwrap();
+                let characterdata: &CharacterData = self.downcast::<CharacterData>().unwrap();
                 characterdata.SetData(value);
 
                 // Notify the document that the content of this node is different
@@ -2019,21 +2012,21 @@ impl NodeMethods for Node {
 
         // Step 4-5.
         match node.type_id() {
-            NodeTypeId::CharacterData(CharacterDataTypeId::Text) if self.is_document() =>
+            NodeTypeId::CharacterData(CharacterDataTypeId::Text) if self.is::<Document>() =>
                 return Err(Error::HierarchyRequest),
-            NodeTypeId::DocumentType if !self.is_document() => return Err(Error::HierarchyRequest),
+            NodeTypeId::DocumentType if !self.is::<Document>() => return Err(Error::HierarchyRequest),
             NodeTypeId::Document => return Err(Error::HierarchyRequest),
             _ => ()
         }
 
         // Step 6.
-        if self.is_document() {
+        if self.is::<Document>() {
             match node.type_id() {
                 // Step 6.1
                 NodeTypeId::DocumentFragment => {
                     // Step 6.1.1(b)
                     if node.children()
-                           .any(|c| c.is_text())
+                           .any(|c| c.is::<Text>())
                     {
                         return Err(Error::HierarchyRequest);
                     }
@@ -2042,7 +2035,7 @@ impl NodeMethods for Node {
                         // Step 6.1.2
                         1 => {
                             if self.child_elements()
-                                   .any(|c| NodeCast::from_ref(c.r()) != child) {
+                                   .any(|c| c.upcast::<Node>() != child) {
                                 return Err(Error::HierarchyRequest);
                             }
                             if child.following_siblings()
@@ -2057,7 +2050,7 @@ impl NodeMethods for Node {
                 // Step 6.2
                 NodeTypeId::Element(..) => {
                     if self.child_elements()
-                           .any(|c| NodeCast::from_ref(c.r()) != child) {
+                           .any(|c| c.upcast::<Node>() != child) {
                         return Err(Error::HierarchyRequest);
                     }
                     if child.following_siblings()
@@ -2076,7 +2069,7 @@ impl NodeMethods for Node {
                     }
                     if self.children()
                            .take_while(|c| c.r() != child)
-                           .any(|c| c.is_element())
+                           .any(|c| c.is::<Element>())
                     {
                         return Err(Error::HierarchyRequest);
                     }
@@ -2142,16 +2135,16 @@ impl NodeMethods for Node {
     fn Normalize(&self) {
         let mut prev_text: Option<Root<Text>> = None;
         for child in self.children() {
-            match TextCast::to_ref(child.r()) {
+            match child.downcast::<Text>() {
                 Some(text) => {
-                    let characterdata: &CharacterData = CharacterDataCast::from_ref(text);
+                    let characterdata: &CharacterData = text.upcast::<CharacterData>();
                     if characterdata.Length() == 0 {
                         Node::remove(&*child, self, SuppressObserver::Unsuppressed);
                     } else {
                         match prev_text {
                             Some(ref text_node) => {
                                 let prev_characterdata =
-                                    CharacterDataCast::from_ref(text_node.r());
+                                    text_node.upcast::<CharacterData>();
                                 prev_characterdata.append_data(&**characterdata.data());
                                 Node::remove(&*child, self, SuppressObserver::Unsuppressed);
                             },
@@ -2179,34 +2172,34 @@ impl NodeMethods for Node {
     // https://dom.spec.whatwg.org/#dom-node-isequalnode
     fn IsEqualNode(&self, maybe_node: Option<&Node>) -> bool {
         fn is_equal_doctype(node: &Node, other: &Node) -> bool {
-            let doctype: &DocumentType = DocumentTypeCast::to_ref(node).unwrap();
-            let other_doctype: &DocumentType = DocumentTypeCast::to_ref(other).unwrap();
+            let doctype: &DocumentType = node.downcast::<DocumentType>().unwrap();
+            let other_doctype: &DocumentType = other.downcast::<DocumentType>().unwrap();
             (*doctype.name() == *other_doctype.name()) &&
             (*doctype.public_id() == *other_doctype.public_id()) &&
             (*doctype.system_id() == *other_doctype.system_id())
         }
         fn is_equal_element(node: &Node, other: &Node) -> bool {
-            let element: &Element = ElementCast::to_ref(node).unwrap();
-            let other_element: &Element = ElementCast::to_ref(other).unwrap();
+            let element: &Element = node.downcast::<Element>().unwrap();
+            let other_element: &Element = other.downcast::<Element>().unwrap();
             (*element.namespace() == *other_element.namespace()) &&
             (*element.prefix() == *other_element.prefix()) &&
             (*element.local_name() == *other_element.local_name()) &&
             (element.attrs().len() == other_element.attrs().len())
         }
         fn is_equal_processinginstruction(node: &Node, other: &Node) -> bool {
-            let pi: &ProcessingInstruction = ProcessingInstructionCast::to_ref(node).unwrap();
-            let other_pi: &ProcessingInstruction = ProcessingInstructionCast::to_ref(other).unwrap();
+            let pi: &ProcessingInstruction = node.downcast::<ProcessingInstruction>().unwrap();
+            let other_pi: &ProcessingInstruction = other.downcast::<ProcessingInstruction>().unwrap();
             (*pi.target() == *other_pi.target()) &&
-            (*CharacterDataCast::from_ref(pi).data() == *CharacterDataCast::from_ref(other_pi).data())
+            (*pi.upcast::<CharacterData>().data() == *other_pi.upcast::<CharacterData>().data())
         }
         fn is_equal_characterdata(node: &Node, other: &Node) -> bool {
-            let characterdata: &CharacterData = CharacterDataCast::to_ref(node).unwrap();
-            let other_characterdata: &CharacterData = CharacterDataCast::to_ref(other).unwrap();
+            let characterdata: &CharacterData = node.downcast::<CharacterData>().unwrap();
+            let other_characterdata: &CharacterData = other.downcast::<CharacterData>().unwrap();
             *characterdata.data() == *other_characterdata.data()
         }
         fn is_equal_element_attrs(node: &Node, other: &Node) -> bool {
-            let element: &Element = ElementCast::to_ref(node).unwrap();
-            let other_element: &Element = ElementCast::to_ref(other).unwrap();
+            let element: &Element = node.downcast::<Element>().unwrap();
+            let other_element: &Element = other.downcast::<Element>().unwrap();
             assert!(element.attrs().len() == other_element.attrs().len());
             // FIXME(https://github.com/rust-lang/rust/issues/23338)
             let attrs = element.attrs();
@@ -2334,9 +2327,9 @@ impl NodeMethods for Node {
 
         // Step 2.
         match self.type_id() {
-            NodeTypeId::Element(..) => ElementCast::to_ref(self).unwrap().lookup_prefix(namespace),
+            NodeTypeId::Element(..) => self.downcast::<Element>().unwrap().lookup_prefix(namespace),
             NodeTypeId::Document => {
-                DocumentCast::to_ref(self).unwrap().GetDocumentElement().and_then(|element| {
+                self.downcast::<Document>().unwrap().GetDocumentElement().and_then(|element| {
                     element.r().lookup_prefix(namespace)
                 })
             },
@@ -2382,19 +2375,19 @@ pub struct TrustedNodeAddress(pub *const c_void);
 #[allow(unsafe_code)]
 unsafe impl Send for TrustedNodeAddress {}
 
-pub fn document_from_node<T: NodeBase + Reflectable>(derived: &T) -> Root<Document> {
-    let node: &Node = NodeCast::from_ref(derived);
+pub fn document_from_node<T: DerivedFrom<Node> + Reflectable>(derived: &T) -> Root<Document> {
+    let node: &Node = derived.upcast::<Node>();
     node.owner_doc()
 }
 
-pub fn window_from_node<T: NodeBase + Reflectable>(derived: &T) -> Root<Window> {
+pub fn window_from_node<T: DerivedFrom<Node> + Reflectable>(derived: &T) -> Root<Window> {
     let document = document_from_node(derived);
     Root::from_ref(document.r().window())
 }
 
 impl VirtualMethods for Node {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let eventtarget: &EventTarget = EventTargetCast::from_ref(self);
+        let eventtarget: &EventTarget = self.upcast::<EventTarget>();
         Some(eventtarget as &VirtualMethods)
     }
 
diff --git a/components/script/dom/progressevent.rs b/components/script/dom/progressevent.rs
index 4a9d400f57a..864fd4285c4 100644
--- a/components/script/dom/progressevent.rs
+++ b/components/script/dom/progressevent.rs
@@ -5,7 +5,7 @@
 use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
 use dom::bindings::codegen::Bindings::ProgressEventBinding;
 use dom::bindings::codegen::Bindings::ProgressEventBinding::ProgressEventMethods;
-use dom::bindings::codegen::InheritTypes::EventCast;
+use dom::bindings::conversions::Castable;
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
@@ -37,7 +37,7 @@ impl ProgressEvent {
                                     global,
                                     ProgressEventBinding::Wrap);
         {
-            let event = EventCast::from_ref(ev.r());
+            let event = ev.upcast::<Event>();
             event.InitEvent(type_, can_bubble == EventBubbles::Bubbles, cancelable == EventCancelable::Cancelable);
         }
         ev
diff --git a/components/script/dom/range.rs b/components/script/dom/range.rs
index 52ab9d24d66..725bce6de50 100644
--- a/components/script/dom/range.rs
+++ b/components/script/dom/range.rs
@@ -10,15 +10,17 @@ use dom::bindings::codegen::Bindings::RangeBinding::RangeMethods;
 use dom::bindings::codegen::Bindings::RangeBinding::{self, RangeConstants};
 use dom::bindings::codegen::Bindings::TextBinding::TextMethods;
 use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
-use dom::bindings::codegen::InheritTypes::{CharacterDataCast, CharacterDataTypeId};
-use dom::bindings::codegen::InheritTypes::{NodeCast, NodeTypeId, TextCast, TextDerived};
+use dom::bindings::codegen::InheritTypes::{CharacterDataTypeId, NodeTypeId};
+use dom::bindings::conversions::Castable;
 use dom::bindings::error::{Error, ErrorResult, Fallible};
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, Root, RootedReference};
 use dom::bindings::utils::{Reflector, reflect_dom_object};
+use dom::characterdata::CharacterData;
 use dom::document::Document;
 use dom::documentfragment::DocumentFragment;
 use dom::node::Node;
+use dom::text::Text;
 use std::cell::RefCell;
 use std::cmp::{Ord, Ordering, PartialEq, PartialOrd};
 use std::rc::Rc;
@@ -41,7 +43,7 @@ impl Range {
     }
 
     pub fn new_with_doc(document: &Document) -> Root<Range> {
-        let root = NodeCast::from_ref(document);
+        let root = document.upcast::<Node>();
         Range::new(document, root, 0, root, 0)
     }
 
@@ -277,7 +279,7 @@ impl RangeMethods for Range {
         let start = &inner.start;
         let end = &inner.end;
         let start_node = start.node();
-        let owner_doc = NodeCast::from_ref(start_node.r()).owner_doc();
+        let owner_doc = start_node.upcast::<Node>().owner_doc();
         Range::new(owner_doc.r(), start_node.r(), start.offset,
                    end.node().r(), end.offset)
     }
@@ -360,14 +362,14 @@ impl RangeMethods for Range {
         }
 
         if end_node == start_node {
-            if let Some(text) = CharacterDataCast::to_ref(start_node.r()) {
+            if let Some(text) = start_node.downcast::<CharacterData>() {
                 // Step 4.1.
                 let clone = start_node.CloneNode(true);
                 // Step 4.2.
                 let text = text.SubstringData(start_offset, end_offset - start_offset);
-                CharacterDataCast::to_ref(clone.r()).unwrap().SetData(text.unwrap());
+                clone.downcast::<CharacterData>().unwrap().SetData(text.unwrap());
                 // Step 4.3.
-                try!(NodeCast::from_ref(fragment.r()).AppendChild(clone.r()));
+                try!(fragment.upcast::<Node>().AppendChild(clone.r()));
                 // Step 4.4
                 return Ok(fragment);
             }
@@ -379,20 +381,20 @@ impl RangeMethods for Range {
 
         if let Some(child) = first_contained_child {
             // Step 13.
-            if let Some(text) = CharacterDataCast::to_ref(child.r()) {
+            if let Some(text) = child.downcast::<CharacterData>() {
                 assert!(child == start_node);
                 // Step 13.1.
                 let clone = start_node.CloneNode(true); // CharacterData has no children.
                 // Step 13.2
                 let text = text.SubstringData(start_offset, start_node.len() - start_offset);
-                CharacterDataCast::to_ref(clone.r()).unwrap().SetData(text.unwrap());
+                clone.downcast::<CharacterData>().unwrap().SetData(text.unwrap());
                 // Step 13.3.
-                try!(NodeCast::from_ref(fragment.r()).AppendChild(clone.r()));
+                try!(fragment.upcast::<Node>().AppendChild(clone.r()));
             } else {
                 // Step 14.1.
                 let clone = child.CloneNode(false);
                 // Step 14.2.
-                try!(NodeCast::from_ref(fragment.r()).AppendChild(clone.r()));
+                try!(fragment.upcast::<Node>().AppendChild(clone.r()));
                 // Step 14.3.
                 let subrange = Range::new(clone.owner_doc().r(),
                                           start_node.r(),
@@ -402,7 +404,7 @@ impl RangeMethods for Range {
                 // Step 14.4.
                 let subfragment = try!(subrange.CloneContents());
                 // Step 14.5.
-                try!(clone.AppendChild(NodeCast::from_ref(subfragment.r())));
+                try!(clone.AppendChild(subfragment.upcast::<Node>()));
             }
         }
 
@@ -411,25 +413,25 @@ impl RangeMethods for Range {
             // Step 15.1.
             let clone = child.CloneNode(true);
             // Step 15.2.
-            try!(NodeCast::from_ref(fragment.r()).AppendChild(clone.r()));
+            try!(fragment.upcast::<Node>().AppendChild(clone.r()));
         }
 
         if let Some(child) = last_contained_child {
             // Step 16.
-            if let Some(text) = CharacterDataCast::to_ref(child.r()) {
+            if let Some(text) = child.downcast::<CharacterData>() {
                 assert!(child == end_node);
                 // Step 16.1.
                 let clone = end_node.CloneNode(true); // CharacterData has no children.
                 // Step 16.2.
                 let text = text.SubstringData(0, end_offset);
-                CharacterDataCast::to_ref(clone.r()).unwrap().SetData(text.unwrap());
+                clone.downcast::<CharacterData>().unwrap().SetData(text.unwrap());
                 // Step 16.3.
-                try!(NodeCast::from_ref(fragment.r()).AppendChild(clone.r()));
+                try!(fragment.upcast::<Node>().AppendChild(clone.r()));
             } else {
                 // Step 17.1.
                 let clone = child.CloneNode(false);
                 // Step 17.2.
-                try!(NodeCast::from_ref(fragment.r()).AppendChild(clone.r()));
+                try!(fragment.upcast::<Node>().AppendChild(clone.r()));
                 // Step 17.3.
                 let subrange = Range::new(clone.owner_doc().r(),
                                           child.r(),
@@ -439,7 +441,7 @@ impl RangeMethods for Range {
                 // Step 17.4.
                 let subfragment = try!(subrange.CloneContents());
                 // Step 17.5.
-                try!(clone.AppendChild(NodeCast::from_ref(subfragment.r())));
+                try!(clone.AppendChild(subfragment.upcast::<Node>()));
             }
         }
 
@@ -468,14 +470,14 @@ impl RangeMethods for Range {
         }
 
         if end_node == start_node {
-            if let Some(end_data) = CharacterDataCast::to_ref(end_node.r()) {
+            if let Some(end_data) = end_node.downcast::<CharacterData>() {
                 // Step 4.1.
                 let clone = end_node.CloneNode(true);
                 // Step 4.2.
                 let text = end_data.SubstringData(start_offset, end_offset - start_offset);
-                CharacterDataCast::to_ref(clone.r()).unwrap().SetData(text.unwrap());
+                clone.downcast::<CharacterData>().unwrap().SetData(text.unwrap());
                 // Step 4.3.
-                try!(NodeCast::from_ref(fragment.r()).AppendChild(clone.r()));
+                try!(fragment.upcast::<Node>().AppendChild(clone.r()));
                 // Step 4.4.
                 try!(end_data.ReplaceData(start_offset,
                                           end_offset - start_offset,
@@ -502,16 +504,16 @@ impl RangeMethods for Range {
         };
 
         if let Some(child) = first_contained_child {
-            if let Some(start_data) = CharacterDataCast::to_ref(child.r()) {
+            if let Some(start_data) = child.downcast::<CharacterData>() {
                 assert!(child == start_node);
                 // Step 15.1.
                 let clone = start_node.CloneNode(true);
                 // Step 15.2.
                 let text = start_data.SubstringData(start_offset,
                                                     start_node.len() - start_offset);
-                CharacterDataCast::to_ref(clone.r()).unwrap().SetData(text.unwrap());
+                clone.downcast::<CharacterData>().unwrap().SetData(text.unwrap());
                 // Step 15.3.
-                try!(NodeCast::from_ref(fragment.r()).AppendChild(clone.r()));
+                try!(fragment.upcast::<Node>().AppendChild(clone.r()));
                 // Step 15.4.
                 try!(start_data.ReplaceData(start_offset,
                                             start_node.len() - start_offset,
@@ -520,7 +522,7 @@ impl RangeMethods for Range {
                 // Step 16.1.
                 let clone = child.CloneNode(false);
                 // Step 16.2.
-                try!(NodeCast::from_ref(fragment.r()).AppendChild(clone.r()));
+                try!(fragment.upcast::<Node>().AppendChild(clone.r()));
                 // Step 16.3.
                 let subrange = Range::new(clone.owner_doc().r(),
                                           start_node.r(),
@@ -530,32 +532,32 @@ impl RangeMethods for Range {
                 // Step 16.4.
                 let subfragment = try!(subrange.ExtractContents());
                 // Step 16.5.
-                try!(clone.AppendChild(NodeCast::from_ref(subfragment.r())));
+                try!(clone.AppendChild(subfragment.upcast::<Node>()));
             }
         }
 
         // Step 17.
         for child in contained_children {
-            try!(NodeCast::from_ref(fragment.r()).AppendChild(child.r()));
+            try!(fragment.upcast::<Node>().AppendChild(child.r()));
         }
 
         if let Some(child) = last_contained_child {
-            if let Some(end_data) = CharacterDataCast::to_ref(child.r()) {
+            if let Some(end_data) = child.downcast::<CharacterData>() {
                 assert!(child == end_node);
                 // Step 18.1.
                 let clone = end_node.CloneNode(true);
                 // Step 18.2.
                 let text = end_data.SubstringData(0, end_offset);
-                CharacterDataCast::to_ref(clone.r()).unwrap().SetData(text.unwrap());
+                clone.downcast::<CharacterData>().unwrap().SetData(text.unwrap());
                 // Step 18.3.
-                try!(NodeCast::from_ref(fragment.r()).AppendChild(clone.r()));
+                try!(fragment.upcast::<Node>().AppendChild(clone.r()));
                 // Step 18.4.
                 try!(end_data.ReplaceData(0, end_offset, "".to_owned()));
             } else {
                 // Step 19.1.
                 let clone = child.CloneNode(false);
                 // Step 19.2.
-                try!(NodeCast::from_ref(fragment.r()).AppendChild(clone.r()));
+                try!(fragment.upcast::<Node>().AppendChild(clone.r()));
                 // Step 19.3.
                 let subrange = Range::new(clone.owner_doc().r(),
                                           child.r(),
@@ -565,7 +567,7 @@ impl RangeMethods for Range {
                 // Step 19.4.
                 let subfragment = try!(subrange.ExtractContents());
                 // Step 19.5.
-                try!(clone.AppendChild(NodeCast::from_ref(subfragment.r())));
+                try!(clone.AppendChild(subfragment.upcast::<Node>()));
             }
         }
 
@@ -624,10 +626,10 @@ impl RangeMethods for Range {
         // Step 7.
         let split_text;
         let reference_node =
-            match TextCast::to_ref(start_node.r()) {
+            match start_node.downcast::<Text>() {
                 Some(text) => {
                     split_text = try!(text.SplitText(start_offset));
-                    let new_reference = NodeCast::from_root(split_text);
+                    let new_reference = Root::upcast::<Node>(split_text);
                     assert!(new_reference.GetParentNode().r() == Some(parent.r()));
                     Some(new_reference)
                 },
@@ -672,8 +674,8 @@ impl RangeMethods for Range {
         let start = self.StartContainer();
         let end = self.EndContainer();
 
-        if start.inclusive_ancestors().any(|n| !n.is_inclusive_ancestor_of(end.r()) && !n.is_text()) ||
-           end.inclusive_ancestors().any(|n| !n.is_inclusive_ancestor_of(start.r()) && !n.is_text()) {
+        if start.inclusive_ancestors().any(|n| !n.is_inclusive_ancestor_of(end.r()) && !n.is::<Text>()) ||
+           end.inclusive_ancestors().any(|n| !n.is_inclusive_ancestor_of(start.r()) && !n.is::<Text>()) {
              return Err(Error::InvalidState);
         }
 
@@ -695,7 +697,7 @@ impl RangeMethods for Range {
         try!(self.InsertNode(new_parent));
 
         // Step 6.
-        let _ = try!(new_parent.AppendChild(NodeCast::from_ref(fragment.r())));
+        let _ = try!(new_parent.AppendChild(fragment.upcast::<Node>()));
 
         // Step 7.
         self.SelectNode(new_parent)
diff --git a/components/script/dom/servohtmlparser.rs b/components/script/dom/servohtmlparser.rs
index 2cf4bac0a4c..061cdd533c7 100644
--- a/components/script/dom/servohtmlparser.rs
+++ b/components/script/dom/servohtmlparser.rs
@@ -8,7 +8,6 @@
 use document_loader::LoadType;
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::ServoHTMLParserBinding;
-use dom::bindings::codegen::InheritTypes::NodeCast;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, Root};
 use dom::bindings::refcounted::Trusted;
@@ -49,7 +48,7 @@ impl Sink {
             NodeOrText::AppendNode(n) => n.root(),
             NodeOrText::AppendText(t) => {
                 let text = Text::new(t.into(), &self.document);
-                NodeCast::from_root(text)
+                Root::upcast::<Node>(text)
             }
         }
     }
diff --git a/components/script/dom/storage.rs b/components/script/dom/storage.rs
index 9429aecb200..926848e66c7 100644
--- a/components/script/dom/storage.rs
+++ b/components/script/dom/storage.rs
@@ -4,13 +4,14 @@
 
 use dom::bindings::codegen::Bindings::StorageBinding;
 use dom::bindings::codegen::Bindings::StorageBinding::StorageMethods;
-use dom::bindings::codegen::InheritTypes::{EventCast, EventTargetCast};
+use dom::bindings::conversions::Castable;
 use dom::bindings::error::{Error, ErrorResult};
 use dom::bindings::global::{GlobalField, GlobalRef};
 use dom::bindings::js::{Root, RootedReference};
 use dom::bindings::refcounted::Trusted;
 use dom::bindings::utils::{Reflector, reflect_dom_object};
-use dom::event::{EventBubbles, EventCancelable};
+use dom::event::{Event, EventBubbles, EventCancelable};
+use dom::eventtarget::EventTarget;
 use dom::storageevent::StorageEvent;
 use dom::urlhelper::UrlHelper;
 use ipc_channel::ipc;
@@ -192,7 +193,7 @@ impl MainThreadRunnable for StorageEventRunnable {
             ev_url.to_string(),
             Some(storage)
         );
-        let event = EventCast::from_ref(storage_event.r());
+        let event = storage_event.upcast::<Event>();
 
         let root_page = script_task.root_page();
         for it_page in root_page.iter() {
@@ -202,7 +203,7 @@ impl MainThreadRunnable for StorageEventRunnable {
             // TODO: Such a Document object is not necessarily fully active, but events fired on such
             // objects are ignored by the event loop until the Document becomes fully active again.
             if ev_window.pipeline() != it_window.pipeline() {
-                let target = EventTargetCast::from_ref(it_window);
+                let target = it_window.upcast::<EventTarget>();
                 event.fire(target);
             }
         }
diff --git a/components/script/dom/storageevent.rs b/components/script/dom/storageevent.rs
index d9f1f60e395..f64dd0b2af8 100644
--- a/components/script/dom/storageevent.rs
+++ b/components/script/dom/storageevent.rs
@@ -5,7 +5,7 @@
 use dom::bindings::codegen::Bindings::EventBinding::{EventMethods};
 use dom::bindings::codegen::Bindings::StorageEventBinding;
 use dom::bindings::codegen::Bindings::StorageEventBinding::{StorageEventMethods};
-use dom::bindings::codegen::InheritTypes::EventCast;
+use dom::bindings::conversions::Castable;
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, MutNullableHeap, Root, RootedReference};
@@ -55,7 +55,7 @@ impl StorageEvent {
                                     global,
                                     StorageEventBinding::Wrap);
         {
-            let event = EventCast::from_ref(ev.r());
+            let event = ev.upcast::<Event>();
             event.InitEvent(type_, bubbles == EventBubbles::Bubbles, cancelable == EventCancelable::Cancelable);
         }
         ev
diff --git a/components/script/dom/text.rs b/components/script/dom/text.rs
index fdc41895f39..6f6e713ef27 100644
--- a/components/script/dom/text.rs
+++ b/components/script/dom/text.rs
@@ -7,7 +7,7 @@ use dom::bindings::codegen::Bindings::DocumentBinding::DocumentMethods;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
 use dom::bindings::codegen::Bindings::TextBinding::{self, TextMethods};
 use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
-use dom::bindings::codegen::InheritTypes::{CharacterDataCast, NodeCast, TextDerived};
+use dom::bindings::conversions::Castable;
 use dom::bindings::error::{Error, Fallible};
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
@@ -44,7 +44,7 @@ impl Text {
 impl TextMethods for Text {
     // https://dom.spec.whatwg.org/#dom-text-splittextoffset
     fn SplitText(&self, offset: u32) -> Fallible<Root<Text>> {
-        let cdata = CharacterDataCast::from_ref(self);
+        let cdata = self.upcast::<CharacterData>();
         // Step 1.
         let length = cdata.Length();
         if offset > length {
@@ -56,14 +56,14 @@ impl TextMethods for Text {
         // Step 4.
         let new_data = cdata.SubstringData(offset, count).unwrap();
         // Step 5.
-        let node = NodeCast::from_ref(self);
+        let node = self.upcast::<Node>();
         let owner_doc = node.owner_doc();
         let new_node = owner_doc.r().CreateTextNode(new_data);
         // Step 6.
         let parent = node.GetParentNode();
         if let Some(ref parent) = parent {
             // Step 7.
-            parent.r().InsertBefore(NodeCast::from_ref(new_node.r()),
+            parent.r().InsertBefore(new_node.upcast::<Node>(),
                                     node.GetNextSibling().r())
                   .unwrap();
             // TODO: Ranges.
@@ -80,14 +80,14 @@ impl TextMethods for Text {
 
     // https://dom.spec.whatwg.org/#dom-text-wholetext
     fn WholeText(&self) -> DOMString {
-        let first = NodeCast::from_ref(self).inclusively_preceding_siblings()
-                                            .take_while(|node| node.r().is_text())
-                                            .last().unwrap();
+        let first = self.upcast::<Node>().inclusively_preceding_siblings()
+                                         .take_while(|node| node.r().is::<Text>())
+                                         .last().unwrap();
         let nodes = first.r().inclusively_following_siblings()
-                             .take_while(|node| node.r().is_text());
+                             .take_while(|node| node.r().is::<Text>());
         let mut text = DOMString::new();
         for ref node in nodes {
-            let cdata = CharacterDataCast::to_ref(node.r()).unwrap();
+            let cdata = node.downcast::<CharacterData>().unwrap();
             text.push_str(&cdata.data());
         }
         text
diff --git a/components/script/dom/uievent.rs b/components/script/dom/uievent.rs
index f01f8476356..45b3aa07a7c 100644
--- a/components/script/dom/uievent.rs
+++ b/components/script/dom/uievent.rs
@@ -5,7 +5,7 @@
 use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
 use dom::bindings::codegen::Bindings::UIEventBinding;
 use dom::bindings::codegen::Bindings::UIEventBinding::UIEventMethods;
-use dom::bindings::codegen::InheritTypes::EventCast;
+use dom::bindings::conversions::Castable;
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
@@ -86,7 +86,7 @@ impl UIEventMethods for UIEvent {
                    cancelable: bool,
                    view: Option<&Window>,
                    detail: i32) {
-        let event: &Event = EventCast::from_ref(self);
+        let event: &Event = self.upcast::<Event>();
         if event.dispatching() {
             return;
         }
diff --git a/components/script/dom/userscripts.rs b/components/script/dom/userscripts.rs
index 3520cbe5745..b7546ad4b27 100644
--- a/components/script/dom/userscripts.rs
+++ b/components/script/dom/userscripts.rs
@@ -4,9 +4,10 @@
 
 use dom::bindings::codegen::Bindings::DocumentBinding::DocumentMethods;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
-use dom::bindings::codegen::InheritTypes::NodeCast;
+use dom::bindings::conversions::Castable;
 use dom::bindings::js::{RootedReference};
 use dom::htmlheadelement::HTMLHeadElement;
+use dom::node::Node;
 use std::borrow::ToOwned;
 use std::fs::read_dir;
 use std::path::PathBuf;
@@ -16,7 +17,7 @@ use util::resource_files::resources_dir_path;
 
 pub fn load_script(head: &HTMLHeadElement) {
     if let Some(ref path_str) = opts::get().userscripts {
-        let node = NodeCast::from_ref(head);
+        let node = head.upcast::<Node>();
         let first_child = node.GetFirstChild();
         let doc = node.owner_doc();
         let doc = doc.r();
@@ -43,7 +44,7 @@ pub fn load_script(head: &HTMLHeadElement) {
             let new_script = doc.CreateElement("script".to_owned()).unwrap();
             let new_script = new_script.r();
             new_script.set_string_attribute(&atom!("src"), name);
-            let new_script_node = NodeCast::from_ref(new_script);
+            let new_script_node = new_script.upcast::<Node>();
             node.InsertBefore(new_script_node, first_child.r()).unwrap();
         }
     }
diff --git a/components/script/dom/virtualmethods.rs b/components/script/dom/virtualmethods.rs
index 5c990e8a1de..95a40df6f6c 100644
--- a/components/script/dom/virtualmethods.rs
+++ b/components/script/dom/virtualmethods.rs
@@ -3,43 +3,43 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::attr::{Attr, AttrValue};
-use dom::bindings::codegen::InheritTypes::ElementCast;
 use dom::bindings::codegen::InheritTypes::ElementTypeId;
-use dom::bindings::codegen::InheritTypes::HTMLAnchorElementCast;
-use dom::bindings::codegen::InheritTypes::HTMLAppletElementCast;
-use dom::bindings::codegen::InheritTypes::HTMLAreaElementCast;
-use dom::bindings::codegen::InheritTypes::HTMLBaseElementCast;
-use dom::bindings::codegen::InheritTypes::HTMLBodyElementCast;
-use dom::bindings::codegen::InheritTypes::HTMLButtonElementCast;
-use dom::bindings::codegen::InheritTypes::HTMLCanvasElementCast;
-use dom::bindings::codegen::InheritTypes::HTMLElementCast;
 use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::HTMLFieldSetElementCast;
-use dom::bindings::codegen::InheritTypes::HTMLFontElementCast;
-use dom::bindings::codegen::InheritTypes::HTMLFormElementCast;
-use dom::bindings::codegen::InheritTypes::HTMLHeadElementCast;
-use dom::bindings::codegen::InheritTypes::HTMLIFrameElementCast;
-use dom::bindings::codegen::InheritTypes::HTMLImageElementCast;
-use dom::bindings::codegen::InheritTypes::HTMLInputElementCast;
-use dom::bindings::codegen::InheritTypes::HTMLLinkElementCast;
-use dom::bindings::codegen::InheritTypes::HTMLMetaElementCast;
-use dom::bindings::codegen::InheritTypes::HTMLObjectElementCast;
-use dom::bindings::codegen::InheritTypes::HTMLOptGroupElementCast;
-use dom::bindings::codegen::InheritTypes::HTMLOptionElementCast;
-use dom::bindings::codegen::InheritTypes::HTMLScriptElementCast;
-use dom::bindings::codegen::InheritTypes::HTMLSelectElementCast;
-use dom::bindings::codegen::InheritTypes::HTMLStyleElementCast;
-use dom::bindings::codegen::InheritTypes::HTMLTableCellElementCast;
-use dom::bindings::codegen::InheritTypes::HTMLTableElementCast;
-use dom::bindings::codegen::InheritTypes::HTMLTableRowElementCast;
-use dom::bindings::codegen::InheritTypes::HTMLTableSectionElementCast;
-use dom::bindings::codegen::InheritTypes::HTMLTemplateElementCast;
-use dom::bindings::codegen::InheritTypes::HTMLTextAreaElementCast;
-use dom::bindings::codegen::InheritTypes::HTMLTitleElementCast;
 use dom::bindings::codegen::InheritTypes::NodeTypeId;
+use dom::bindings::conversions::Castable;
 use dom::document::Document;
-use dom::element::AttributeMutation;
+use dom::element::{AttributeMutation, Element};
 use dom::event::Event;
+use dom::htmlanchorelement::HTMLAnchorElement;
+use dom::htmlappletelement::HTMLAppletElement;
+use dom::htmlareaelement::HTMLAreaElement;
+use dom::htmlbaseelement::HTMLBaseElement;
+use dom::htmlbodyelement::HTMLBodyElement;
+use dom::htmlbuttonelement::HTMLButtonElement;
+use dom::htmlcanvaselement::HTMLCanvasElement;
+use dom::htmlelement::HTMLElement;
+use dom::htmlfieldsetelement::HTMLFieldSetElement;
+use dom::htmlfontelement::HTMLFontElement;
+use dom::htmlformelement::HTMLFormElement;
+use dom::htmlheadelement::HTMLHeadElement;
+use dom::htmliframeelement::HTMLIFrameElement;
+use dom::htmlimageelement::HTMLImageElement;
+use dom::htmlinputelement::HTMLInputElement;
+use dom::htmllinkelement::HTMLLinkElement;
+use dom::htmlmetaelement::HTMLMetaElement;
+use dom::htmlobjectelement::HTMLObjectElement;
+use dom::htmloptgroupelement::HTMLOptGroupElement;
+use dom::htmloptionelement::HTMLOptionElement;
+use dom::htmlscriptelement::HTMLScriptElement;
+use dom::htmlselectelement::HTMLSelectElement;
+use dom::htmlstyleelement::HTMLStyleElement;
+use dom::htmltablecellelement::HTMLTableCellElement;
+use dom::htmltableelement::HTMLTableElement;
+use dom::htmltablerowelement::HTMLTableRowElement;
+use dom::htmltablesectionelement::HTMLTableSectionElement;
+use dom::htmltemplateelement::HTMLTemplateElement;
+use dom::htmltextareaelement::HTMLTextAreaElement;
+use dom::htmltitleelement::HTMLTitleElement;
 use dom::node::{ChildrenMutation, CloneChildrenFlag, Node};
 use string_cache::Atom;
 use util::str::DOMString;
@@ -123,130 +123,130 @@ pub trait VirtualMethods {
 pub fn vtable_for(node: &Node) -> &VirtualMethods {
     match node.type_id() {
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLAnchorElement)) => {
-            let element = HTMLAnchorElementCast::to_ref(node).unwrap();
+            let element = node.downcast::<HTMLAnchorElement>().unwrap();
             element as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLAppletElement)) => {
-            HTMLAppletElementCast::to_ref(node).unwrap() as &VirtualMethods
+            node.downcast::<HTMLAppletElement>().unwrap() as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLAreaElement)) => {
-            let element = HTMLAreaElementCast::to_ref(node).unwrap();
+            let element = node.downcast::<HTMLAreaElement>().unwrap();
             element as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLBaseElement)) => {
-            let element = HTMLBaseElementCast::to_ref(node).unwrap();
+            let element = node.downcast::<HTMLBaseElement>().unwrap();
             element as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLBodyElement)) => {
-            let element = HTMLBodyElementCast::to_ref(node).unwrap();
+            let element = node.downcast::<HTMLBodyElement>().unwrap();
             element as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLButtonElement)) => {
-            let element = HTMLButtonElementCast::to_ref(node).unwrap();
+            let element = node.downcast::<HTMLButtonElement>().unwrap();
             element as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLCanvasElement)) => {
-            let element = HTMLCanvasElementCast::to_ref(node).unwrap();
+            let element = node.downcast::<HTMLCanvasElement>().unwrap();
             element as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLFieldSetElement)) => {
-            let element = HTMLFieldSetElementCast::to_ref(node).unwrap();
+            let element = node.downcast::<HTMLFieldSetElement>().unwrap();
             element as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLFontElement)) => {
-            let element = HTMLFontElementCast::to_ref(node).unwrap();
+            let element = node.downcast::<HTMLFontElement>().unwrap();
             element as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLFormElement)) => {
-            let element = HTMLFormElementCast::to_ref(node).unwrap();
+            let element = node.downcast::<HTMLFormElement>().unwrap();
             element as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLHeadElement)) => {
-            let element = HTMLHeadElementCast::to_ref(node).unwrap();
+            let element = node.downcast::<HTMLHeadElement>().unwrap();
             element as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLImageElement)) => {
-            let element = HTMLImageElementCast::to_ref(node).unwrap();
+            let element = node.downcast::<HTMLImageElement>().unwrap();
             element as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLIFrameElement)) => {
-            let element = HTMLIFrameElementCast::to_ref(node).unwrap();
+            let element = node.downcast::<HTMLIFrameElement>().unwrap();
             element as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLInputElement)) => {
-            let element = HTMLInputElementCast::to_ref(node).unwrap();
+            let element = node.downcast::<HTMLInputElement>().unwrap();
             element as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLLinkElement)) => {
-            let element = HTMLLinkElementCast::to_ref(node).unwrap();
+            let element = node.downcast::<HTMLLinkElement>().unwrap();
             element as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLMetaElement)) => {
-            let element = HTMLMetaElementCast::to_ref(node).unwrap();
+            let element = node.downcast::<HTMLMetaElement>().unwrap();
             element as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLObjectElement)) => {
-            let element = HTMLObjectElementCast::to_ref(node).unwrap();
+            let element = node.downcast::<HTMLObjectElement>().unwrap();
             element as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLOptGroupElement)) => {
-            let element = HTMLOptGroupElementCast::to_ref(node).unwrap();
+            let element = node.downcast::<HTMLOptGroupElement>().unwrap();
             element as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLOptionElement)) => {
-            let element = HTMLOptionElementCast::to_ref(node).unwrap();
+            let element = node.downcast::<HTMLOptionElement>().unwrap();
             element as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLScriptElement)) => {
-            let element = HTMLScriptElementCast::to_ref(node).unwrap();
+            let element = node.downcast::<HTMLScriptElement>().unwrap();
             element as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLSelectElement)) => {
-            let element = HTMLSelectElementCast::to_ref(node).unwrap();
+            let element = node.downcast::<HTMLSelectElement>().unwrap();
             element as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLStyleElement)) => {
-            let element = HTMLStyleElementCast::to_ref(node).unwrap();
+            let element = node.downcast::<HTMLStyleElement>().unwrap();
             element as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTableElement)) => {
             let element =
-                HTMLTableElementCast::to_ref(node).unwrap();
+                node.downcast::<HTMLTableElement>().unwrap();
             element as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTableCellElement(_))) => {
             let element =
-                HTMLTableCellElementCast::to_ref(node).unwrap();
+                node.downcast::<HTMLTableCellElement>().unwrap();
             element as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTableRowElement)) => {
             let element =
-                HTMLTableRowElementCast::to_ref(node).unwrap();
+                node.downcast::<HTMLTableRowElement>().unwrap();
             element as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTableSectionElement)) => {
             let element =
-                HTMLTableSectionElementCast::to_ref(node).unwrap();
+                node.downcast::<HTMLTableSectionElement>().unwrap();
             element as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTemplateElement)) => {
-            HTMLTemplateElementCast::to_ref(node).unwrap() as &VirtualMethods
+            node.downcast::<HTMLTemplateElement>().unwrap() as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTextAreaElement)) => {
-            let element = HTMLTextAreaElementCast::to_ref(node).unwrap();
+            let element = node.downcast::<HTMLTextAreaElement>().unwrap();
             element as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTitleElement)) => {
             let element =
-                HTMLTitleElementCast::to_ref(node).unwrap();
+                node.downcast::<HTMLTitleElement>().unwrap();
             element as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::Element) => {
-            let element = ElementCast::to_ref(node).unwrap();
+            let element = node.downcast::<Element>().unwrap();
             element as &VirtualMethods
         }
         NodeTypeId::Element(_) => {
-            let element = HTMLElementCast::to_ref(node).unwrap();
+            let element = node.downcast::<HTMLElement>().unwrap();
             element as &VirtualMethods
         }
         _ => {
diff --git a/components/script/dom/webglcontextevent.rs b/components/script/dom/webglcontextevent.rs
index 1bba8849eb4..6a2e709f765 100644
--- a/components/script/dom/webglcontextevent.rs
+++ b/components/script/dom/webglcontextevent.rs
@@ -6,10 +6,10 @@ use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
 use dom::bindings::codegen::Bindings::WebGLContextEventBinding;
 use dom::bindings::codegen::Bindings::WebGLContextEventBinding::WebGLContextEventInit;
 use dom::bindings::codegen::Bindings::WebGLContextEventBinding::WebGLContextEventMethods;
-use dom::bindings::codegen::InheritTypes::EventCast;
+use dom::bindings::conversions::Castable;
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
-use dom::bindings::js::{Root, RootedReference};
+use dom::bindings::js::Root;
 use dom::bindings::utils::reflect_dom_object;
 use dom::event::{Event, EventBubbles, EventCancelable};
 use util::str::DOMString;
@@ -46,7 +46,7 @@ impl WebGLContextEvent {
                         WebGLContextEventBinding::Wrap);
 
         {
-            let parent = EventCast::from_ref(event.r());
+            let parent = event.upcast::<Event>();
             parent.InitEvent(type_, bubbles == EventBubbles::Bubbles, cancelable == EventCancelable::Cancelable);
         }
 
diff --git a/components/script/dom/webglrenderingcontext.rs b/components/script/dom/webglrenderingcontext.rs
index 0b968b4b42f..cc4f4579dd9 100644
--- a/components/script/dom/webglrenderingcontext.rs
+++ b/components/script/dom/webglrenderingcontext.rs
@@ -8,16 +8,16 @@ use canvas_traits::{WebGLFramebufferBindingRequest, WebGLShaderParameter};
 use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextConstants as constants;
 use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::{WebGLRenderingContextMethods};
 use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::{self, WebGLContextAttributes};
-use dom::bindings::codegen::InheritTypes::{EventCast, EventTargetCast, NodeCast};
 use dom::bindings::codegen::UnionTypes::ImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement;
-use dom::bindings::conversions::ToJSValConvertible;
+use dom::bindings::conversions::{Castable, ToJSValConvertible};
 use dom::bindings::global::{GlobalField, GlobalRef};
 use dom::bindings::js::{JS, LayoutJS, MutNullableHeap, Root};
 use dom::bindings::utils::{Reflector, reflect_dom_object};
-use dom::event::{EventBubbles, EventCancelable};
+use dom::event::{Event, EventBubbles, EventCancelable};
+use dom::eventtarget::EventTarget;
 use dom::htmlcanvaselement::HTMLCanvasElement;
 use dom::htmlcanvaselement::utils as canvas_utils;
-use dom::node::{NodeDamage, window_from_node};
+use dom::node::{Node, NodeDamage, window_from_node};
 use dom::webglbuffer::WebGLBuffer;
 use dom::webglcontextevent::WebGLContextEvent;
 use dom::webglframebuffer::WebGLFramebuffer;
@@ -121,11 +121,7 @@ impl WebGLRenderingContext {
                                                    EventBubbles::DoesNotBubble,
                                                    EventCancelable::Cancelable,
                                                    msg);
-
-                let event = EventCast::from_ref(event.r());
-                let target = EventTargetCast::from_ref(canvas);
-
-                event.fire(target);
+                event.upcast::<Event>().fire(canvas.upcast::<EventTarget>());
                 None
             }
         }
@@ -158,7 +154,7 @@ impl WebGLRenderingContext {
 
     fn mark_as_dirty(&self) {
         let canvas = self.canvas.root();
-        let node = NodeCast::from_ref(canvas.r());
+        let node = canvas.upcast::<Node>();
         node.dirty(NodeDamage::OtherNodeDamage);
     }
 }
diff --git a/components/script/dom/websocket.rs b/components/script/dom/websocket.rs
index 4b2797248fa..149f4ba32e3 100644
--- a/components/script/dom/websocket.rs
+++ b/components/script/dom/websocket.rs
@@ -6,9 +6,7 @@ use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
 use dom::bindings::codegen::Bindings::WebSocketBinding;
 use dom::bindings::codegen::Bindings::WebSocketBinding::{BinaryType, WebSocketMethods};
-use dom::bindings::codegen::InheritTypes::EventCast;
-use dom::bindings::codegen::InheritTypes::EventTargetCast;
-use dom::bindings::conversions::ToJSValConvertible;
+use dom::bindings::conversions::{Castable, ToJSValConvertible};
 use dom::bindings::error::{Error, Fallible};
 use dom::bindings::global::{GlobalField, GlobalRef};
 use dom::bindings::js::Root;
@@ -456,7 +454,7 @@ impl Runnable for ConnectionEstablishedTask {
         let event = Event::new(global.r(), "open".to_owned(),
                                EventBubbles::DoesNotBubble,
                                EventCancelable::NotCancelable);
-        event.fire(EventTargetCast::from_ref(ws.r()));
+        event.fire(ws.upcast::<EventTarget>());
     }
 }
 
@@ -498,7 +496,7 @@ impl Runnable for CloseTask {
                                    "error".to_owned(),
                                    EventBubbles::DoesNotBubble,
                                    EventCancelable::Cancelable);
-            let target = EventTargetCast::from_ref(ws);
+            let target = ws.upcast::<EventTarget>();
             event.r().fire(target);
         }
         let rsn = ws.reason.borrow();
@@ -513,8 +511,8 @@ impl Runnable for CloseTask {
                                           ws.clean_close.get(),
                                           ws.code.get(),
                                           rsn_clone);
-        let target = EventTargetCast::from_ref(ws);
-        let event = EventCast::from_ref(close_event.r());
+        let target = ws.upcast::<EventTarget>();
+        let event = close_event.upcast::<Event>();
         event.fire(target);
     }
 }
@@ -564,7 +562,7 @@ impl Runnable for MessageReceivedTask {
             },
         }
 
-        let target = EventTargetCast::from_ref(ws.r());
+        let target = ws.upcast::<EventTarget>();
         MessageEvent::dispatch_jsval(target, global.r(), message.handle());
     }
 }
diff --git a/components/script/dom/window.rs b/components/script/dom/window.rs
index b3968a9205d..9ca6713991d 100644
--- a/components/script/dom/window.rs
+++ b/components/script/dom/window.rs
@@ -11,7 +11,7 @@ use dom::bindings::codegen::Bindings::EventHandlerBinding::{EventHandlerNonNull,
 use dom::bindings::codegen::Bindings::FunctionBinding::Function;
 use dom::bindings::codegen::Bindings::WindowBinding::{ScrollBehavior, ScrollToOptions};
 use dom::bindings::codegen::Bindings::WindowBinding::{self, FrameRequestCallback, WindowMethods};
-use dom::bindings::codegen::InheritTypes::{ElementCast, EventTargetCast, NodeCast};
+use dom::bindings::conversions::Castable;
 use dom::bindings::error::{Error, Fallible, report_pending_exception};
 use dom::bindings::global::GlobalRef;
 use dom::bindings::global::global_object_for_js_object;
@@ -28,7 +28,7 @@ use dom::element::Element;
 use dom::eventtarget::EventTarget;
 use dom::location::Location;
 use dom::navigator::Navigator;
-use dom::node::{TrustedNodeAddress, from_untrusted_node_address, window_from_node};
+use dom::node::{Node, TrustedNodeAddress, from_untrusted_node_address, window_from_node};
 use dom::performance::Performance;
 use dom::screen::Screen;
 use dom::storage::Storage;
@@ -794,7 +794,7 @@ impl<'a, T: Reflectable> ScriptHelpers for &'a T {
 impl Window {
     pub fn clear_js_runtime(&self) {
         let document = self.Document();
-        NodeCast::from_ref(document.r()).teardown();
+        document.upcast::<Node>().teardown();
 
         // The above code may not catch all DOM objects
         // (e.g. DOM objects removed from the tree that haven't
@@ -835,7 +835,7 @@ impl Window {
         let body = self.Document().GetBody();
         let (x, y) = match body {
             Some(e) => {
-                let node = NodeCast::from_ref(e.r());
+                let node = e.upcast::<Node>();
                 let content_size = node.get_bounding_content_box();
 
                 let content_height = content_size.size.height.to_f64_px();
@@ -901,7 +901,7 @@ impl Window {
             Some(root) => root,
             None => return,
         };
-        let root = NodeCast::from_ref(root);
+        let root = root.upcast::<Node>();
 
         let window_size = match self.window_size.get() {
             Some(window_size) => window_size,
@@ -973,7 +973,7 @@ impl Window {
             None => return,
         };
 
-        let root = NodeCast::from_ref(root);
+        let root = root.upcast::<Node>();
         if query_type == ReflowQueryType::NoQuery && !root.get_has_dirty_descendants() {
             debug!("root has no dirty descendants; avoiding reflow (reason {:?})", reason);
             return
@@ -1055,7 +1055,7 @@ impl Window {
         let js_runtime = js_runtime.as_ref().unwrap();
         let element = response.node_address.and_then(|parent_node_address| {
             let node = from_untrusted_node_address(js_runtime.rt(), parent_node_address);
-            ElementCast::to_root(node)
+            Root::downcast::<Element>(node)
         });
         (element, response.rect)
     }
diff --git a/components/script/dom/worker.rs b/components/script/dom/worker.rs
index 226e9143277..6d890f1a14e 100644
--- a/components/script/dom/worker.rs
+++ b/components/script/dom/worker.rs
@@ -6,7 +6,7 @@ use devtools_traits::{DevtoolsPageInfo, ScriptToDevtoolsControlMsg};
 use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
 use dom::bindings::codegen::Bindings::WorkerBinding;
 use dom::bindings::codegen::Bindings::WorkerBinding::WorkerMethods;
-use dom::bindings::codegen::InheritTypes::{EventCast, EventTargetCast};
+use dom::bindings::conversions::Castable;
 use dom::bindings::error::{Error, ErrorResult, Fallible};
 use dom::bindings::global::{GlobalField, GlobalRef};
 use dom::bindings::js::Root;
@@ -115,7 +115,7 @@ impl Worker {
         let worker = address.root();
 
         let global = worker.r().global.root();
-        let target = EventTargetCast::from_ref(worker.r());
+        let target = worker.upcast::<EventTarget>();
         let _ar = JSAutoRequest::new(global.r().get_cx());
         let _ac = JSAutoCompartment::new(global.r().get_cx(), target.reflector().get_jsobject().get());
         let mut message = RootedValue::new(global.r().get_cx(), UndefinedValue());
@@ -126,7 +126,7 @@ impl Worker {
     pub fn dispatch_simple_error(address: TrustedWorkerAddress) {
         let worker = address.root();
         let global = worker.r().global.root();
-        let target = EventTargetCast::from_ref(worker.r());
+        let target = worker.upcast::<EventTarget>();
 
         let event = Event::new(global.r(),
                                "error".to_owned(),
@@ -140,11 +140,11 @@ impl Worker {
         let worker = address.root();
         let global = worker.r().global.root();
         let error = RootedValue::new(global.r().get_cx(), UndefinedValue());
-        let target = EventTargetCast::from_ref(worker.r());
+        let target = worker.upcast::<EventTarget>();
         let errorevent = ErrorEvent::new(global.r(), "error".to_owned(),
                                          EventBubbles::Bubbles, EventCancelable::Cancelable,
                                          message, filename, lineno, colno, error.handle());
-        let event = EventCast::from_ref(errorevent.r());
+        let event = errorevent.upcast::<Event>();
         event.fire(target);
     }
 }
diff --git a/components/script/dom/workerglobalscope.rs b/components/script/dom/workerglobalscope.rs
index bd01fce1658..40692b99e7e 100644
--- a/components/script/dom/workerglobalscope.rs
+++ b/components/script/dom/workerglobalscope.rs
@@ -5,13 +5,14 @@
 use devtools_traits::{DevtoolScriptControlMsg, ScriptToDevtoolsControlMsg};
 use dom::bindings::codegen::Bindings::FunctionBinding::Function;
 use dom::bindings::codegen::Bindings::WorkerGlobalScopeBinding::WorkerGlobalScopeMethods;
-use dom::bindings::codegen::InheritTypes::DedicatedWorkerGlobalScopeCast;
+use dom::bindings::conversions::Castable;
 use dom::bindings::error::{Error, ErrorResult, Fallible, report_pending_exception};
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, MutNullableHeap, Root};
 use dom::bindings::utils::Reflectable;
 use dom::console::Console;
 use dom::crypto::Crypto;
+use dom::dedicatedworkerglobalscope::DedicatedWorkerGlobalScope;
 use dom::eventtarget::EventTarget;
 use dom::window::{base64_atob, base64_btoa};
 use dom::workerlocation::WorkerLocation;
@@ -295,7 +296,7 @@ impl WorkerGlobalScope {
 
     pub fn script_chan(&self) -> Box<ScriptChan + Send> {
         let dedicated =
-            DedicatedWorkerGlobalScopeCast::to_ref(self);
+            self.downcast::<DedicatedWorkerGlobalScope>();
         match dedicated {
             Some(dedicated) => dedicated.script_chan(),
             None => panic!("need to implement a sender for SharedWorker"),
@@ -304,7 +305,7 @@ impl WorkerGlobalScope {
 
     pub fn pipeline(&self) -> PipelineId {
         let dedicated =
-            DedicatedWorkerGlobalScopeCast::to_ref(self);
+            self.downcast::<DedicatedWorkerGlobalScope>();
         match dedicated {
             Some(dedicated) => dedicated.pipeline(),
             None => panic!("need to add a pipeline for SharedWorker"),
@@ -313,7 +314,7 @@ impl WorkerGlobalScope {
 
     pub fn new_script_pair(&self) -> (Box<ScriptChan + Send>, Box<ScriptPort + Send>) {
         let dedicated =
-            DedicatedWorkerGlobalScopeCast::to_ref(self);
+            self.downcast::<DedicatedWorkerGlobalScope>();
         match dedicated {
             Some(dedicated) => dedicated.new_script_pair(),
             None => panic!("need to implement creating isolated event loops for SharedWorker"),
@@ -322,7 +323,7 @@ impl WorkerGlobalScope {
 
     pub fn process_event(&self, msg: CommonScriptMsg) {
         let dedicated =
-            DedicatedWorkerGlobalScopeCast::to_ref(self);
+            self.downcast::<DedicatedWorkerGlobalScope>();
         match dedicated {
             Some(dedicated) => dedicated.process_event(msg),
             None => panic!("need to implement processing single events for SharedWorker"),
diff --git a/components/script/dom/xmlhttprequest.rs b/components/script/dom/xmlhttprequest.rs
index 400b06ca95f..e84a4781bab 100644
--- a/components/script/dom/xmlhttprequest.rs
+++ b/components/script/dom/xmlhttprequest.rs
@@ -10,10 +10,9 @@ use dom::bindings::codegen::Bindings::XMLHttpRequestBinding;
 use dom::bindings::codegen::Bindings::XMLHttpRequestBinding::XMLHttpRequestMethods;
 use dom::bindings::codegen::Bindings::XMLHttpRequestBinding::XMLHttpRequestResponseType;
 use dom::bindings::codegen::Bindings::XMLHttpRequestBinding::XMLHttpRequestResponseType::{Json, Text, _empty};
-use dom::bindings::codegen::InheritTypes::{EventCast, EventTargetCast};
 use dom::bindings::codegen::UnionTypes::StringOrURLSearchParams;
 use dom::bindings::codegen::UnionTypes::StringOrURLSearchParams::{eString, eURLSearchParams};
-use dom::bindings::conversions::ToJSValConvertible;
+use dom::bindings::conversions::{Castable, ToJSValConvertible};
 use dom::bindings::error::{Error, ErrorResult, Fallible};
 use dom::bindings::global::{GlobalField, GlobalRef, GlobalRoot};
 use dom::bindings::js::Root;
@@ -23,6 +22,7 @@ use dom::bindings::str::ByteString;
 use dom::bindings::utils::{Reflectable, reflect_dom_object};
 use dom::document::Document;
 use dom::event::{Event, EventBubbles, EventCancelable};
+use dom::eventtarget::EventTarget;
 use dom::progressevent::ProgressEvent;
 use dom::xmlhttprequesteventtarget::XMLHttpRequestEventTarget;
 use dom::xmlhttprequestupload::XMLHttpRequestUpload;
@@ -493,7 +493,7 @@ impl XMLHttpRequestMethods for XMLHttpRequest {
 
         if !self.sync.get() {
             // Step 8
-            let event_target = EventTargetCast::from_ref(&*self.upload);
+            let event_target = self.upload.upcast::<EventTarget>();
             if event_target.has_handlers() {
                 self.upload_events.set(true);
             }
@@ -737,7 +737,7 @@ impl XMLHttpRequest {
                                "readystatechange".to_owned(),
                                EventBubbles::DoesNotBubble,
                                EventCancelable::Cancelable);
-        let target = EventTargetCast::from_ref(self);
+        let target = self.upcast::<EventTarget>();
         event.r().fire(target);
     }
 
@@ -921,11 +921,11 @@ impl XMLHttpRequest {
                                                total.is_some(), loaded,
                                                total.unwrap_or(0));
         let target = if upload {
-            EventTargetCast::from_ref(&*self.upload)
+            self.upload.upcast::<EventTarget>()
         } else {
-            EventTargetCast::from_ref(self)
+            self.upcast::<EventTarget>()
         };
-        let event = EventCast::from_ref(progressevent.r());
+        let event = progressevent.upcast::<Event>();
         event.fire(target);
     }
 
diff --git a/components/script/dom/xmlhttprequesteventtarget.rs b/components/script/dom/xmlhttprequesteventtarget.rs
index aa0604448cd..cdbc7a29df8 100644
--- a/components/script/dom/xmlhttprequesteventtarget.rs
+++ b/components/script/dom/xmlhttprequesteventtarget.rs
@@ -4,7 +4,6 @@
 
 use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
 use dom::bindings::codegen::Bindings::XMLHttpRequestEventTargetBinding::XMLHttpRequestEventTargetMethods;
-use dom::bindings::codegen::InheritTypes::EventTargetCast;
 use dom::eventtarget::EventTarget;
 
 #[dom_struct]
diff --git a/components/script/lib.rs b/components/script/lib.rs
index 14d74cb2f94..5ebaa787dfd 100644
--- a/components/script/lib.rs
+++ b/components/script/lib.rs
@@ -19,6 +19,7 @@
 #![feature(iter_arith)]
 #![feature(mpsc_select)]
 #![feature(nonzero)]
+#![feature(on_unimplemented)]
 #![feature(plugin)]
 #![feature(ref_slice)]
 #![feature(slice_patterns)]
diff --git a/components/script/parse/html.rs b/components/script/parse/html.rs
index 8ff0d23884a..36955322d6c 100644
--- a/components/script/parse/html.rs
+++ b/components/script/parse/html.rs
@@ -8,21 +8,22 @@ use document_loader::DocumentLoader;
 use dom::bindings::codegen::Bindings::DocumentBinding::DocumentMethods;
 use dom::bindings::codegen::Bindings::HTMLTemplateElementBinding::HTMLTemplateElementMethods;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
-use dom::bindings::codegen::InheritTypes::{CharacterDataCast, CharacterDataTypeId};
-use dom::bindings::codegen::InheritTypes::{DocumentTypeCast, ElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLFormElementDerived, HTMLScriptElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLTemplateElementCast, NodeCast};
-use dom::bindings::codegen::InheritTypes::{NodeTypeId, ProcessingInstructionCast};
+use dom::bindings::codegen::InheritTypes::{CharacterDataTypeId, NodeTypeId};
+use dom::bindings::conversions::Castable;
 use dom::bindings::js::{JS, Root};
 use dom::bindings::js::{RootedReference};
+use dom::characterdata::CharacterData;
 use dom::comment::Comment;
 use dom::document::Document;
 use dom::document::{DocumentSource, IsHTMLDocument};
 use dom::documenttype::DocumentType;
 use dom::element::{Element, ElementCreator};
+use dom::htmlformelement::HTMLFormElement;
 use dom::htmlscriptelement::HTMLScriptElement;
+use dom::htmltemplateelement::HTMLTemplateElement;
 use dom::node::Node;
 use dom::node::{document_from_node, window_from_node};
+use dom::processinginstruction::ProcessingInstruction;
 use dom::servohtmlparser;
 use dom::servohtmlparser::{FragmentContext, ServoHTMLParser};
 use encoding::types::Encoding;
@@ -45,15 +46,15 @@ impl<'a> TreeSink for servohtmlparser::Sink {
 
     fn get_document(&mut self) -> JS<Node> {
         let doc = self.document.root();
-        let node = NodeCast::from_ref(doc.r());
+        let node = doc.upcast::<Node>();
         JS::from_ref(node)
     }
 
     fn get_template_contents(&self, target: JS<Node>) -> JS<Node> {
         let target = target.root();
-        let template = HTMLTemplateElementCast::to_ref(&*target)
+        let template = target.downcast::<HTMLTemplateElement>()
             .expect("tried to get template contents of non-HTMLTemplateElement in HTML parsing");
-        JS::from_ref(NodeCast::from_ref(&*template.Content()))
+        JS::from_ref(template.Content().upcast::<Node>())
     }
 
     fn same_node(&self, x: JS<Node>, y: JS<Node>) -> bool {
@@ -62,7 +63,7 @@ impl<'a> TreeSink for servohtmlparser::Sink {
 
     fn elem_name(&self, target: JS<Node>) -> QualName {
         let node: Root<Node> = target.root();
-        let elem = ElementCast::to_ref(node.r())
+        let elem = node.downcast::<Element>()
             .expect("tried to get name of non-Element in HTML parsing");
         QualName {
             ns: elem.namespace().clone(),
@@ -80,14 +81,14 @@ impl<'a> TreeSink for servohtmlparser::Sink {
             elem.r().set_attribute_from_parser(attr.name, attr.value.into(), None);
         }
 
-        let node = NodeCast::from_ref(elem.r());
+        let node = elem.upcast::<Node>();
         JS::from_ref(node)
     }
 
     fn create_comment(&mut self, text: StrTendril) -> JS<Node> {
         let doc = self.document.root();
         let comment = Comment::new(text.into(), doc.r());
-        let node = NodeCast::from_root(comment);
+        let node = Root::upcast::<Node>(comment);
         JS::from_rooted(&node)
     }
 
@@ -126,17 +127,17 @@ impl<'a> TreeSink for servohtmlparser::Sink {
     fn append_doctype_to_document(&mut self, name: StrTendril, public_id: StrTendril,
                                   system_id: StrTendril) {
         let doc = self.document.root();
-        let doc_node = NodeCast::from_ref(doc.r());
+        let doc_node = doc.upcast::<Node>();
         let doctype = DocumentType::new(
             name.into(), Some(public_id.into()), Some(system_id.into()), doc.r());
-        let node: Root<Node> = NodeCast::from_root(doctype);
+        let node: Root<Node> = Root::upcast::<Node>(doctype);
 
         assert!(doc_node.AppendChild(node.r()).is_ok());
     }
 
     fn add_attrs_if_missing(&mut self, target: JS<Node>, attrs: Vec<Attribute>) {
         let node: Root<Node> = target.root();
-        let elem = ElementCast::to_ref(node.r())
+        let elem = node.downcast::<Element>()
             .expect("tried to set attrs on non-Element in HTML parsing");
         for attr in attrs {
             elem.set_attribute_from_parser(attr.name, attr.value.into(), None);
@@ -152,13 +153,13 @@ impl<'a> TreeSink for servohtmlparser::Sink {
 
     fn mark_script_already_started(&mut self, node: JS<Node>) {
         let node: Root<Node> = node.root();
-        let script: Option<&HTMLScriptElement> = HTMLScriptElementCast::to_ref(node.r());
+        let script: Option<&HTMLScriptElement> = node.downcast::<HTMLScriptElement>();
         script.map(|script| script.mark_already_started());
     }
 
     fn complete_script(&mut self, node: JS<Node>) -> NextParserState {
         let node: Root<Node> = node.root();
-        let script: Option<&HTMLScriptElement> = HTMLScriptElementCast::to_ref(node.r());
+        let script: Option<&HTMLScriptElement> = node.downcast::<HTMLScriptElement>();
         if let Some(script) = script {
             return script.prepare();
         }
@@ -183,7 +184,7 @@ impl<'a> Serializable for &'a Node {
         let node = *self;
         match (traversal_scope, node.type_id()) {
             (_, NodeTypeId::Element(..)) => {
-                let elem = ElementCast::to_ref(node).unwrap();
+                let elem = node.downcast::<Element>().unwrap();
                 let name = QualName::new(elem.namespace().clone(),
                                          elem.local_name().clone());
                 if traversal_scope == IncludeNode {
@@ -201,9 +202,9 @@ impl<'a> Serializable for &'a Node {
                     try!(serializer.start_elem(name.clone(), attr_refs));
                 }
 
-                let children = if let Some(tpl) = HTMLTemplateElementCast::to_ref(node) {
+                let children = if let Some(tpl) = node.downcast::<HTMLTemplateElement>() {
                     // https://github.com/w3c/DOM-Parsing/issues/1
-                    NodeCast::from_ref(&*tpl.Content()).children()
+                    tpl.Content().upcast::<Node>().children()
                 } else {
                     node.children()
                 };
@@ -228,23 +229,23 @@ impl<'a> Serializable for &'a Node {
             (ChildrenOnly, _) => Ok(()),
 
             (IncludeNode, NodeTypeId::DocumentType) => {
-                let doctype = DocumentTypeCast::to_ref(node).unwrap();
+                let doctype = node.downcast::<DocumentType>().unwrap();
                 serializer.write_doctype(&doctype.name())
             },
 
             (IncludeNode, NodeTypeId::CharacterData(CharacterDataTypeId::Text)) => {
-                let cdata = CharacterDataCast::to_ref(node).unwrap();
+                let cdata = node.downcast::<CharacterData>().unwrap();
                 serializer.write_text(&cdata.data())
             },
 
             (IncludeNode, NodeTypeId::CharacterData(CharacterDataTypeId::Comment)) => {
-                let cdata = CharacterDataCast::to_ref(node).unwrap();
+                let cdata = node.downcast::<CharacterData>().unwrap();
                 serializer.write_comment(&cdata.data())
             },
 
             (IncludeNode, NodeTypeId::CharacterData(CharacterDataTypeId::ProcessingInstruction)) => {
-                let pi = ProcessingInstructionCast::to_ref(node).unwrap();
-                let data = CharacterDataCast::from_ref(pi).data();
+                let pi = node.downcast::<ProcessingInstruction>().unwrap();
+                let data = pi.upcast::<CharacterData>().data();
                 serializer.write_processing_instruction(&pi.target(), &data)
             },
 
@@ -295,7 +296,7 @@ pub fn parse_html_fragment(context_node: &Node,
 
     // Step 11.
     let form = context_node.inclusive_ancestors()
-                           .find(|element| element.r().is_htmlformelement());
+                           .find(|element| element.r().is::<HTMLFormElement>());
     let fragment_context = FragmentContext {
         context_elem: context_node,
         form_elem: form.r(),
@@ -304,7 +305,7 @@ pub fn parse_html_fragment(context_node: &Node,
 
     // Step 14.
     let root_element = document.r().GetDocumentElement().expect("no document element");
-    let root_node = NodeCast::from_ref(root_element.r());
+    let root_node = root_element.upcast::<Node>();
     for child in root_node.children() {
         output.AppendChild(child.r()).unwrap();
     }
diff --git a/components/script/script_task.rs b/components/script/script_task.rs
index 0caed8f074f..c52bcd66f4c 100644
--- a/components/script/script_task.rs
+++ b/components/script/script_task.rs
@@ -23,9 +23,7 @@ use devtools_traits::{DevtoolScriptControlMsg, DevtoolsPageInfo};
 use document_loader::{DocumentLoader, LoadType, NotifierData};
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::DocumentBinding::{DocumentMethods, DocumentReadyState};
-use dom::bindings::codegen::InheritTypes::{ElementCast, EventCast, EventTargetCast, NodeCast};
-use dom::bindings::conversions::FromJSValConvertible;
-use dom::bindings::conversions::StringificationBehavior;
+use dom::bindings::conversions::{Castable, FromJSValConvertible, StringificationBehavior};
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, RootCollection, trace_roots};
 use dom::bindings::js::{Root, RootCollectionPtr, RootedReference};
@@ -35,8 +33,9 @@ use dom::bindings::utils::{DOM_CALLBACKS, WRAP_CALLBACKS};
 use dom::document::{Document, DocumentProgressHandler, IsHTMLDocument};
 use dom::document::{DocumentProgressTask, DocumentSource, MouseEventType};
 use dom::element::Element;
-use dom::event::{EventBubbles, EventCancelable};
-use dom::node::{NodeDamage, window_from_node};
+use dom::event::{Event, EventBubbles, EventCancelable};
+use dom::eventtarget::EventTarget;
+use dom::node::{Node, NodeDamage, window_from_node};
 use dom::servohtmlparser::{ParserContext, ServoHTMLParser};
 use dom::uievent::UIEvent;
 use dom::window::{ReflowReason, ScriptHelpers, Window};
@@ -1256,12 +1255,12 @@ impl ScriptTask {
                 let current_url = it_page.document().url().serialize();
                 urls.push(current_url.clone());
 
-                for child in NodeCast::from_ref(&*it_page.document()).traverse_preorder() {
-                    let target = EventTargetCast::from_ref(&*child);
+                for child in it_page.document().upcast::<Node>().traverse_preorder() {
+                    let target = child.upcast::<EventTarget>();
                     dom_tree_size += heap_size_of_self_and_children(target);
                 }
                 let window = it_page.window();
-                let target = EventTargetCast::from_ref(&*window);
+                let target = window.upcast::<EventTarget>();
                 dom_tree_size += heap_size_of_self_and_children(target);
 
                 reports.push(Report {
@@ -1324,7 +1323,7 @@ impl ScriptTask {
         let frame_element = doc.find_iframe(subpage_id);
 
         if let Some(ref frame_element) = frame_element {
-            let element = ElementCast::from_ref(frame_element.r());
+            let element = frame_element.upcast::<Element>();
             doc.r().begin_focus_transaction();
             doc.r().request_focus(element);
             doc.r().commit_focus_transaction(FocusType::Parent);
@@ -1626,7 +1625,7 @@ impl ScriptTask {
                                      DocumentSource::FromParser,
                                      loader);
 
-        let frame_element = frame_element.r().map(ElementCast::from_ref);
+        let frame_element = frame_element.r().map(Castable::upcast::<Element>);
         window.r().init_browsing_context(document.r(), frame_element);
 
         // Create the root frame
@@ -1673,7 +1672,7 @@ impl ScriptTask {
     }
 
     fn scroll_fragment_point(&self, pipeline_id: PipelineId, node: &Element) {
-        let node = NodeCast::from_ref(node);
+        let node = node.upcast::<Node>();
         let rect = node.get_bounding_content_box();
         let point = Point2D::new(rect.origin.x.to_f32_px(), rect.origin.y.to_f32_px());
         // FIXME(#2003, pcwalton): This is pretty bogus when multiple layers are involved.
@@ -1732,7 +1731,7 @@ impl ScriptTask {
                 // Notify Constellation about anchors that are no longer mouse over targets.
                 for target in &*prev_mouse_over_targets {
                     if !mouse_over_targets.contains(target) {
-                        if NodeCast::from_ref(target.root().r()).is_anchor_element() {
+                        if target.upcast::<Node>().is_anchor_element() {
                             let event = ConstellationMsg::NodeStatus(None);
                             let ConstellationChan(ref chan) = self.constellation_chan;
                             chan.send(event).unwrap();
@@ -1744,7 +1743,7 @@ impl ScriptTask {
                 // Notify Constellation about the topmost anchor mouse over target.
                 for target in &*mouse_over_targets {
                     let target = target.root();
-                    if NodeCast::from_ref(target.r()).is_anchor_element() {
+                    if target.upcast::<Node>().is_anchor_element() {
                         let status = target.r().get_attribute(&ns!(""), &atom!("href"))
                             .and_then(|href| {
                                 let value = href.value();
@@ -1845,9 +1844,9 @@ impl ScriptTask {
                                    "resize".to_owned(), EventBubbles::DoesNotBubble,
                                    EventCancelable::NotCancelable, Some(window.r()),
                                    0i32);
-        let event = EventCast::from_ref(uievent.r());
+        let event = uievent.upcast::<Event>();
 
-        let wintarget = EventTargetCast::from_ref(window.r());
+        let wintarget = window.upcast::<EventTarget>();
         event.fire(wintarget);
     }
 
@@ -1906,7 +1905,7 @@ impl ScriptTask {
         // Kick off the initial reflow of the page.
         debug!("kicking off initial reflow of {:?}", final_url);
         document.r().disarm_reflow_timeout();
-        document.r().content_changed(NodeCast::from_ref(document.r()),
+        document.r().content_changed(document.upcast::<Node>(),
                                      NodeDamage::OtherNodeDamage);
         let window = window_from_node(document.r());
         window.r().reflow(ReflowGoal::ForDisplay, ReflowQueryType::NoQuery, ReflowReason::FirstLoad);
diff --git a/components/script/webdriver_handlers.rs b/components/script/webdriver_handlers.rs
index c48240d5d9d..1812f16b802 100644
--- a/components/script/webdriver_handlers.rs
+++ b/components/script/webdriver_handlers.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::Bindings::ElementBinding::ElementMethods;
 use dom::bindings::codegen::Bindings::HTMLIFrameElementBinding::HTMLIFrameElementMethods;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
 use dom::bindings::codegen::Bindings::NodeListBinding::NodeListMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLIFrameElementCast, NodeCast};
-use dom::bindings::conversions::FromJSValConvertible;
-use dom::bindings::conversions::StringificationBehavior;
+use dom::bindings::conversions::{Castable, FromJSValConvertible, StringificationBehavior};
 use dom::bindings::js::Root;
+use dom::element::Element;
+use dom::htmliframeelement::HTMLIFrameElement;
 use dom::node::Node;
 use dom::window::ScriptHelpers;
 use ipc_channel::ipc::IpcSender;
@@ -27,7 +27,7 @@ use url::Url;
 fn find_node_by_unique_id(page: &Rc<Page>, pipeline: PipelineId, node_id: String) -> Option<Root<Node>> {
     let page = get_page(&*page, pipeline);
     let document = page.document();
-    let node = NodeCast::from_ref(document.r());
+    let node = document.upcast::<Node>();
 
     for candidate in node.traverse_preorder() {
         if candidate.r().get_unique_id() == node_id {
@@ -94,7 +94,7 @@ pub fn handle_get_frame_id(page: &Rc<Page>,
         WebDriverFrameId::Element(x) => {
             match find_node_by_unique_id(page, pipeline, x) {
                 Some(ref node) => {
-                    match HTMLIFrameElementCast::to_ref(node.r()) {
+                    match node.downcast::<HTMLIFrameElement>() {
                         Some(ref elem) => Ok(elem.GetContentWindow()),
                         None => Err(())
                     }
@@ -116,7 +116,7 @@ pub fn handle_find_element_css(page: &Rc<Page>, _pipeline: PipelineId, selector:
                                reply: IpcSender<Result<Option<String>, ()>>) {
     reply.send(match page.document().r().QuerySelector(selector.clone()) {
         Ok(node) => {
-            let result = node.map(|x| NodeCast::from_ref(x.r()).get_unique_id());
+            let result = node.map(|x| x.upcast::<Node>().get_unique_id());
             Ok(result)
         }
         Err(_) => Err(())
@@ -147,7 +147,7 @@ pub fn handle_get_active_element(page: &Rc<Page>,
                                  _pipeline: PipelineId,
                                  reply: IpcSender<Option<String>>) {
     reply.send(page.document().r().GetActiveElement().map(
-        |elem| NodeCast::from_ref(elem.r()).get_unique_id())).unwrap();
+        |elem| elem.upcast::<Node>().get_unique_id())).unwrap();
 }
 
 pub fn handle_get_title(page: &Rc<Page>, _pipeline: PipelineId, reply: IpcSender<String>) {
@@ -172,7 +172,7 @@ pub fn handle_get_name(page: &Rc<Page>,
                        reply: IpcSender<Result<String, ()>>) {
     reply.send(match find_node_by_unique_id(&*page, pipeline, node_id) {
         Some(node) => {
-            let element = ElementCast::to_ref(node.r()).unwrap();
+            let element = node.downcast::<Element>().unwrap();
             Ok(element.TagName())
         },
         None => Err(())

From 68014af78e8e3f5de4df0f6cc4d63b99c77478f5 Mon Sep 17 00:00:00 2001
From: Anthony Ramine <n.oxyde@gmail.com>
Date: Wed, 7 Oct 2015 14:55:02 +0200
Subject: [PATCH 4/5] Clean up the cast calls

---
 components/layout/wrapper.rs                  |  44 +++---
 components/script/dom/activation.rs           |   2 +-
 components/script/dom/attr.rs                 |   3 +-
 .../script/dom/canvasrenderingcontext2d.rs    |   4 +-
 components/script/dom/characterdata.rs        |   6 +-
 components/script/dom/create.rs               |   4 +-
 components/script/dom/cssstyledeclaration.rs  |   4 +-
 .../script/dom/dedicatedworkerglobalscope.rs  |   5 +-
 components/script/dom/document.rs             | 144 +++++++-----------
 components/script/dom/documentfragment.rs     |   8 +-
 components/script/dom/documenttype.rs         |   3 +-
 components/script/dom/domimplementation.rs    |  27 ++--
 components/script/dom/element.rs              | 112 +++++---------
 components/script/dom/eventdispatcher.rs      |  13 +-
 components/script/dom/filereader.rs           |   5 +-
 components/script/dom/formdata.rs             |   2 +-
 components/script/dom/htmlanchorelement.rs    |  11 +-
 components/script/dom/htmlareaelement.rs      |   6 +-
 components/script/dom/htmlbodyelement.rs      |   3 +-
 components/script/dom/htmlbuttonelement.rs    |  17 +--
 components/script/dom/htmlcanvaselement.rs    |   9 +-
 components/script/dom/htmlcollection.rs       |   6 +-
 components/script/dom/htmldatalistelement.rs  |   5 +-
 components/script/dom/htmlelement.rs          |  30 ++--
 components/script/dom/htmlfieldsetelement.rs  |   8 +-
 components/script/dom/htmlfontelement.rs      |   3 +-
 components/script/dom/htmlformelement.rs      |  27 +---
 components/script/dom/htmlheadelement.rs      |   3 +-
 components/script/dom/htmliframeelement.rs    |  27 ++--
 components/script/dom/htmlimageelement.rs     |  25 +--
 components/script/dom/htmlinputelement.rs     |  40 ++---
 components/script/dom/htmllinkelement.rs      |  14 +-
 components/script/dom/htmlmetaelement.rs      |   6 +-
 components/script/dom/htmlobjectelement.rs    |   3 +-
 components/script/dom/htmloptgroupelement.rs  |   3 +-
 components/script/dom/htmloptionelement.rs    |  17 +--
 components/script/dom/htmlscriptelement.rs    |  20 +--
 components/script/dom/htmlselectelement.rs    |   6 +-
 components/script/dom/htmlstyleelement.rs     |   6 +-
 components/script/dom/htmltablecellelement.rs |   3 +-
 components/script/dom/htmltableelement.rs     |  25 ++-
 components/script/dom/htmltablerowelement.rs  |   5 +-
 .../script/dom/htmltablesectionelement.rs     |   5 +-
 components/script/dom/htmltemplateelement.rs  |   4 +-
 components/script/dom/htmltextareaelement.rs  |  28 ++--
 components/script/dom/htmltitleelement.rs     |  15 +-
 components/script/dom/keyboardevent.rs        |   7 +-
 components/script/dom/messageevent.rs         |   3 +-
 components/script/dom/mod.rs                  |   4 +-
 components/script/dom/mouseevent.rs           |   7 +-
 components/script/dom/node.rs                 |  97 +++++-------
 components/script/dom/range.rs                |  36 ++---
 components/script/dom/servohtmlparser.rs      |   2 +-
 components/script/dom/storage.rs              |   5 +-
 components/script/dom/text.rs                 |   4 +-
 components/script/dom/uievent.rs              |   2 +-
 components/script/dom/userscripts.rs          |   3 +-
 components/script/dom/virtualmethods.rs       |  92 ++++-------
 .../script/dom/webglrenderingcontext.rs       |   7 +-
 components/script/dom/websocket.rs            |  12 +-
 components/script/dom/window.rs               |   9 +-
 components/script/dom/worker.rs               |  10 +-
 components/script/dom/xmlhttprequest.rs       |  10 +-
 components/script/parse/html.rs               |  24 +--
 components/script/script_task.rs              |  24 +--
 components/script/webdriver_handlers.rs       |   6 +-
 66 files changed, 412 insertions(+), 718 deletions(-)

diff --git a/components/layout/wrapper.rs b/components/layout/wrapper.rs
index 17b54883fa0..e23a53f6616 100644
--- a/components/layout/wrapper.rs
+++ b/components/layout/wrapper.rs
@@ -44,12 +44,12 @@ use script::dom::bindings::codegen::InheritTypes::{CharacterDataTypeId, ElementT
 use script::dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, NodeTypeId};
 use script::dom::bindings::conversions::Castable;
 use script::dom::bindings::js::LayoutJS;
-use script::dom::characterdata::{CharacterData, LayoutCharacterDataHelpers};
+use script::dom::characterdata::LayoutCharacterDataHelpers;
 use script::dom::element;
 use script::dom::element::{Element, LayoutElementHelpers, RawLayoutElementHelpers};
-use script::dom::htmlcanvaselement::{HTMLCanvasElement, LayoutHTMLCanvasElementHelpers};
+use script::dom::htmlcanvaselement::LayoutHTMLCanvasElementHelpers;
 use script::dom::htmliframeelement::HTMLIFrameElement;
-use script::dom::htmlimageelement::{HTMLImageElement, LayoutHTMLImageElementHelpers};
+use script::dom::htmlimageelement::LayoutHTMLImageElementHelpers;
 use script::dom::htmlinputelement::{HTMLInputElement, LayoutHTMLInputElementHelpers};
 use script::dom::htmltextareaelement::{HTMLTextAreaElement, LayoutHTMLTextAreaElementHelpers};
 use script::dom::node::{HAS_CHANGED, HAS_DIRTY_DESCENDANTS, HAS_DIRTY_SIBLINGS, IS_DIRTY};
@@ -358,7 +358,7 @@ impl<'le> LayoutElement<'le> {
 
     pub fn as_node(&self) -> LayoutNode<'le> {
         LayoutNode {
-            node: self.element.upcast::<Node>(),
+            node: self.element.upcast(),
             chain: PhantomData,
         }
     }
@@ -377,7 +377,7 @@ fn as_element<'le>(node: LayoutJS<Node>) -> Option<LayoutElement<'le>> {
 impl<'le> ::selectors::Element for LayoutElement<'le> {
     fn parent_element(&self) -> Option<LayoutElement<'le>> {
         unsafe {
-            self.element.upcast::<Node>().parent_node_ref().and_then(as_element)
+            self.element.upcast().parent_node_ref().and_then(as_element)
         }
     }
 
@@ -422,7 +422,7 @@ impl<'le> ::selectors::Element for LayoutElement<'le> {
         self.as_node().children().all(|node| match node.type_id() {
             NodeTypeId::Element(..) => false,
             NodeTypeId::CharacterData(CharacterDataTypeId::Text) => unsafe {
-                node.node.downcast::<CharacterData>().unwrap().data_for_layout().is_empty()
+                node.node.downcast().unwrap().data_for_layout().is_empty()
             },
             _ => true
         })
@@ -695,7 +695,7 @@ impl<'ln> ThreadSafeLayoutNode<'ln> {
     #[inline]
     pub fn as_element(&self) -> ThreadSafeLayoutElement<'ln> {
         unsafe {
-            let element = match self.get_jsmanaged().downcast::<Element>() {
+            let element = match self.get_jsmanaged().downcast() {
                 Some(e) => e.unsafe_get(),
                 None => panic!("not an element")
             };
@@ -786,12 +786,12 @@ impl<'ln> ThreadSafeLayoutNode<'ln> {
 
     pub fn is_ignorable_whitespace(&self) -> bool {
         unsafe {
-            let text: LayoutJS<Text> = match self.get_jsmanaged().downcast::<Text>() {
+            let text: LayoutJS<Text> = match self.get_jsmanaged().downcast() {
                 Some(text) => text,
                 None => return false
             };
 
-            if !is_whitespace(text.upcast::<CharacterData>().data_for_layout()) {
+            if !is_whitespace(text.upcast().data_for_layout()) {
                 return false
             }
 
@@ -814,8 +814,7 @@ impl<'ln> ThreadSafeLayoutNode<'ln> {
     pub fn get_unsigned_integer_attribute(self, attribute: UnsignedIntegerAttribute)
                                           -> Option<u32> {
         unsafe {
-            let elem: Option<LayoutJS<Element>> = self.get_jsmanaged().downcast::<Element>();
-            match elem {
+            match self.get_jsmanaged().downcast::<Element>() {
                 Some(element) => {
                     element.get_unsigned_integer_attribute_for_layout(attribute)
                 }
@@ -900,20 +899,17 @@ impl<'ln> ThreadSafeLayoutNode<'ln> {
         }
 
         let this = unsafe { self.get_jsmanaged() };
-        let text = this.downcast::<Text>();
-        if let Some(text) = text {
+        if let Some(text) = this.downcast::<Text>() {
             let data = unsafe {
-                text.upcast::<CharacterData>().data_for_layout().to_owned()
+                text.upcast().data_for_layout().to_owned()
             };
             return TextContent::Text(data);
         }
-        let input = this.downcast::<HTMLInputElement>();
-        if let Some(input) = input {
+        if let Some(input) = this.downcast::<HTMLInputElement>() {
             let data = unsafe { input.get_value_for_layout() };
             return TextContent::Text(data);
         }
-        let area = this.downcast::<HTMLTextAreaElement>();
-        if let Some(area) = area {
+        if let Some(area) = this.downcast::<HTMLTextAreaElement>() {
             let data = unsafe { area.get_value_for_layout() };
             return TextContent::Text(data);
         }
@@ -926,7 +922,7 @@ impl<'ln> ThreadSafeLayoutNode<'ln> {
         let this = unsafe {
             self.get_jsmanaged()
         };
-        let input = this.downcast::<HTMLInputElement>();
+        let input = this.downcast();
         if let Some(input) = input {
             let insertion_point = unsafe {
                 input.get_insertion_point_for_layout()
@@ -954,7 +950,7 @@ impl<'ln> ThreadSafeLayoutNode<'ln> {
     /// FIXME(pcwalton): Don't copy URLs.
     pub fn image_url(&self) -> Option<Url> {
         unsafe {
-            self.get_jsmanaged().downcast::<HTMLImageElement>()
+            self.get_jsmanaged().downcast()
                 .expect("not an image!")
                 .image_url()
         }
@@ -962,28 +958,28 @@ impl<'ln> ThreadSafeLayoutNode<'ln> {
 
     pub fn canvas_renderer_id(&self) -> Option<usize> {
         unsafe {
-            let canvas_element = self.get_jsmanaged().downcast::<HTMLCanvasElement>();
+            let canvas_element = self.get_jsmanaged().downcast();
             canvas_element.and_then(|elem| elem.get_renderer_id())
         }
     }
 
     pub fn canvas_ipc_renderer(&self) -> Option<IpcSender<CanvasMsg>> {
         unsafe {
-            let canvas_element = self.get_jsmanaged().downcast::<HTMLCanvasElement>();
+            let canvas_element = self.get_jsmanaged().downcast();
             canvas_element.and_then(|elem| elem.get_ipc_renderer())
         }
     }
 
     pub fn canvas_width(&self) -> u32 {
         unsafe {
-            let canvas_element = self.get_jsmanaged().downcast::<HTMLCanvasElement>();
+            let canvas_element = self.get_jsmanaged().downcast();
             canvas_element.unwrap().get_canvas_width()
         }
     }
 
     pub fn canvas_height(&self) -> u32 {
         unsafe {
-            let canvas_element = self.get_jsmanaged().downcast::<HTMLCanvasElement>();
+            let canvas_element = self.get_jsmanaged().downcast();
             canvas_element.unwrap().get_canvas_height()
         }
     }
diff --git a/components/script/dom/activation.rs b/components/script/dom/activation.rs
index ba140a04269..bd843f557bb 100644
--- a/components/script/dom/activation.rs
+++ b/components/script/dom/activation.rs
@@ -45,7 +45,7 @@ pub trait Activatable {
         // Step 4
         // https://html.spec.whatwg.org/multipage/#fire-a-synthetic-mouse-event
         let win = window_from_node(element);
-        let target = element.upcast::<EventTarget>();
+        let target = element.upcast();
         let mouse = MouseEvent::new(win.r(), "click".to_owned(),
                                     EventBubbles::DoesNotBubble, EventCancelable::NotCancelable, Some(win.r()), 1,
                                     0, 0, 0, 0, ctrlKey, shiftKey, altKey, metaKey,
diff --git a/components/script/dom/attr.rs b/components/script/dom/attr.rs
index ffb2ed2ddd9..84dc04086f8 100644
--- a/components/script/dom/attr.rs
+++ b/components/script/dom/attr.rs
@@ -12,7 +12,6 @@ use dom::bindings::js::{JS, MutNullableHeap};
 use dom::bindings::js::{LayoutJS, Root, RootedReference};
 use dom::bindings::utils::{Reflector, reflect_dom_object};
 use dom::element::{AttributeMutation, Element};
-use dom::node::Node;
 use dom::values::UNSIGNED_LONG_MAX;
 use dom::virtualmethods::vtable_for;
 use dom::window::Window;
@@ -288,7 +287,7 @@ impl Attr {
         assert!(Some(owner) == self.owner().r());
         mem::swap(&mut *self.value.borrow_mut(), &mut value);
         if self.namespace == ns!("") {
-            vtable_for(owner.upcast::<Node>()).attribute_mutated(
+            vtable_for(owner.upcast()).attribute_mutated(
                 self, AttributeMutation::Set(Some(&value)));
         }
     }
diff --git a/components/script/dom/canvasrenderingcontext2d.rs b/components/script/dom/canvasrenderingcontext2d.rs
index 3166ef4c583..cbeb9a49137 100644
--- a/components/script/dom/canvasrenderingcontext2d.rs
+++ b/components/script/dom/canvasrenderingcontext2d.rs
@@ -147,9 +147,7 @@ impl CanvasRenderingContext2D {
     }
 
     fn mark_as_dirty(&self) {
-        let canvas = self.canvas.root();
-        let node = canvas.upcast::<Node>();
-        node.dirty(NodeDamage::OtherNodeDamage);
+        self.canvas.root().upcast::<Node>().dirty(NodeDamage::OtherNodeDamage);
     }
 
     fn update_transform(&self) {
diff --git a/components/script/dom/characterdata.rs b/components/script/dom/characterdata.rs
index 6c76adc7c28..8bc61288a0e 100644
--- a/components/script/dom/characterdata.rs
+++ b/components/script/dom/characterdata.rs
@@ -134,14 +134,12 @@ impl CharacterDataMethods for CharacterData {
 
     // https://dom.spec.whatwg.org/#dom-nondocumenttypechildnode-previouselementsibling
     fn GetPreviousElementSibling(&self) -> Option<Root<Element>> {
-        self.upcast::<Node>().preceding_siblings()
-                             .filter_map(Root::downcast::<Element>).next()
+        self.upcast::<Node>().preceding_siblings().filter_map(Root::downcast).next()
     }
 
     // https://dom.spec.whatwg.org/#dom-nondocumenttypechildnode-nextelementsibling
     fn GetNextElementSibling(&self) -> Option<Root<Element>> {
-        self.upcast::<Node>().following_siblings()
-                             .filter_map(Root::downcast::<Element>).next()
+        self.upcast::<Node>().following_siblings().filter_map(Root::downcast).next()
     }
 }
 
diff --git a/components/script/dom/create.rs b/components/script/dom/create.rs
index 6416c86dc37..bb7deafb747 100644
--- a/components/script/dom/create.rs
+++ b/components/script/dom/create.rs
@@ -89,11 +89,11 @@ pub fn create_element(name: QualName, prefix: Option<Atom>,
     macro_rules! make(
         ($ctor:ident) => ({
             let obj = $ctor::new((*name.local).to_owned(), prefix, document);
-            Root::upcast::<Element>(obj)
+            Root::upcast(obj)
         });
         ($ctor:ident, $($arg:expr),+) => ({
             let obj = $ctor::new((*name.local).to_owned(), prefix, document, $($arg),+);
-            Root::upcast::<Element>(obj)
+            Root::upcast(obj)
         })
     );
 
diff --git a/components/script/dom/cssstyledeclaration.rs b/components/script/dom/cssstyledeclaration.rs
index 7ad150e0cc2..03292d09a85 100644
--- a/components/script/dom/cssstyledeclaration.rs
+++ b/components/script/dom/cssstyledeclaration.rs
@@ -242,7 +242,7 @@ impl CSSStyleDeclarationMethods for CSSStyleDeclaration {
         }
 
         let document = document_from_node(element);
-        let node = element.upcast::<Node>();
+        let node = element.upcast();
         document.r().content_changed(node, NodeDamage::NodeStyleDamaged);
         Ok(())
     }
@@ -276,7 +276,7 @@ impl CSSStyleDeclarationMethods for CSSStyleDeclaration {
         }
 
         let document = document_from_node(element);
-        let node = element.upcast::<Node>();
+        let node = element.upcast();
         document.r().content_changed(node, NodeDamage::NodeStyleDamaged);
         Ok(())
     }
diff --git a/components/script/dom/dedicatedworkerglobalscope.rs b/components/script/dom/dedicatedworkerglobalscope.rs
index 6ec19c4a3e4..413a47bb526 100644
--- a/components/script/dom/dedicatedworkerglobalscope.rs
+++ b/components/script/dom/dedicatedworkerglobalscope.rs
@@ -15,7 +15,6 @@ use dom::bindings::js::{Root, RootCollection};
 use dom::bindings::refcounted::LiveDOMReferences;
 use dom::bindings::structuredclone::StructuredCloneData;
 use dom::bindings::utils::Reflectable;
-use dom::eventtarget::EventTarget;
 use dom::messageevent::MessageEvent;
 use dom::worker::{SimpleWorkerErrorHandler, TrustedWorkerAddress, WorkerMessageHandler};
 use dom::workerglobalscope::WorkerGlobalScope;
@@ -289,7 +288,7 @@ impl DedicatedWorkerGlobalScope {
         match msg {
             WorkerScriptMsg::DOMMessage(data) => {
                 let scope = self.upcast::<WorkerGlobalScope>();
-                let target = self.upcast::<EventTarget>();
+                let target = self.upcast();
                 let _ar = JSAutoRequest::new(scope.get_cx());
                 let _ac = JSAutoCompartment::new(scope.get_cx(), scope.reflector().get_jsobject().get());
                 let mut message = RootedValue::new(scope.get_cx(), UndefinedValue());
@@ -323,7 +322,7 @@ impl DedicatedWorkerGlobalScope {
     fn handle_event(&self, event: MixedMessage) {
         match event {
             MixedMessage::FromDevtools(msg) => {
-                let global_ref = GlobalRef::Worker(self.upcast::<WorkerGlobalScope>());
+                let global_ref = GlobalRef::Worker(self.upcast());
                 match msg {
                     DevtoolScriptControlMsg::EvaluateJS(_pipe_id, string, sender) =>
                         devtools::handle_evaluate_js(&global_ref, string, sender),
diff --git a/components/script/dom/document.rs b/components/script/dom/document.rs
index 2078c872978..835351cdc0d 100644
--- a/components/script/dom/document.rs
+++ b/components/script/dom/document.rs
@@ -290,8 +290,7 @@ impl Document {
         let base = self.upcast::<Node>()
             .traverse_preorder()
             .filter_map(Root::downcast::<HTMLBaseElement>)
-            .filter(|element| element.upcast::<Element>().has_attribute(&atom!("href")))
-            .next();
+            .find(|element| element.upcast::<Element>().has_attribute(&atom!("href")));
         self.base_element.set(base.r());
     }
 
@@ -379,10 +378,7 @@ impl Document {
                               element: &Element,
                               id: Atom) {
         debug!("Adding named element to document {:p}: {:p} id={}", self, element, id);
-        assert!({
-            let node = element.upcast::<Node>();
-            node.is_in_doc()
-        });
+        assert!(element.upcast::<Node>().is_in_doc());
         assert!(!id.is_empty());
 
         let mut idmap = self.idmap.borrow_mut();
@@ -401,7 +397,7 @@ impl Document {
                 let mut head: usize = 0;
                 let root = root.upcast::<Node>();
                 for node in root.traverse_preorder() {
-                    if let Some(elem) = node.downcast::<Element>() {
+                    if let Some(elem) = node.downcast() {
                         if (*elements)[head].root().r() == elem {
                             head += 1;
                         }
@@ -420,7 +416,7 @@ impl Document {
     /// https://html.spec.whatwg.org/multipage/#the-indicated-part-of-the-document
     pub fn find_fragment_node(&self, fragid: &str) -> Option<Root<Element>> {
         self.GetElementById(fragid.to_owned()).or_else(|| {
-            let check_anchor = |&node: &&HTMLAnchorElement| {
+            let check_anchor = |node: &HTMLAnchorElement| {
                 let elem = node.upcast::<Element>();
                 elem.get_attribute(&ns!(""), &atom!("name")).map_or(false, |attr| {
                     &**attr.r().value() == fragid
@@ -428,9 +424,9 @@ impl Document {
             };
             let doc_node = self.upcast::<Node>();
             doc_node.traverse_preorder()
-                    .filter_map(Root::downcast::<HTMLAnchorElement>)
-                    .find(|node| check_anchor(&node.r()))
-                    .map(Root::upcast::<Element>)
+                    .filter_map(Root::downcast)
+                    .find(|node| check_anchor(&node))
+                    .map(Root::upcast)
         })
     }
 
@@ -606,7 +602,7 @@ impl Document {
         match mouse_event_type {
             MouseEventType::Click => el.authentic_click_activation(event),
             _ =>  {
-                let target = node.upcast::<EventTarget>();
+                let target = node.upcast();
                 event.fire(target);
             },
         }
@@ -664,7 +660,7 @@ impl Document {
                 if target_ref.get_hover_state() {
                     target_ref.set_hover_state(false);
 
-                    let target = target_ref.upcast::<EventTarget>();
+                    let target = target_ref.upcast();
 
                     self.fire_mouse_event(point, &target, "mouseout".to_owned());
                 }
@@ -678,7 +674,7 @@ impl Document {
             if !target.get_hover_state() {
                 target.set_hover_state(true);
 
-                let target = target.upcast::<EventTarget>();
+                let target = target.upcast();
 
                 self.fire_mouse_event(point, target, "mouseover".to_owned());
 
@@ -690,7 +686,7 @@ impl Document {
             let top_most_node =
                 node::from_untrusted_node_address(js_runtime, mouse_over_addresses[0]);
 
-            let target = top_most_node.upcast::<EventTarget>();
+            let target = top_most_node.upcast();
             self.fire_mouse_event(point, target, "mousemove".to_owned());
         }
 
@@ -713,9 +709,9 @@ impl Document {
         let body = self.GetBody();
 
         let target = match (&focused, &body) {
-            (&Some(ref focused), _) => focused.upcast::<EventTarget>(),
-            (&None, &Some(ref body)) => body.upcast::<EventTarget>(),
-            (&None, &None) => self.window.upcast::<EventTarget>(),
+            (&Some(ref focused), _) => focused.upcast(),
+            (&None, &Some(ref body)) => body.upcast(),
+            (&None, &None) => self.window.upcast(),
         };
 
         let ctrl = modifiers.contains(CONTROL);
@@ -768,7 +764,7 @@ impl Document {
         // https://www.w3.org/Bugs/Public/show_bug.cgi?id=27337
         match key {
             Key::Space if !prevented && state == KeyState::Released => {
-                let maybe_elem: Option<&Element> = target.downcast::<Element>();
+                let maybe_elem = target.downcast::<Element>();
                 if let Some(el) = maybe_elem {
                     if let Some(a) = el.as_maybe_activatable() {
                         a.synthetic_click_activation(ctrl, alt, shift, meta);
@@ -776,7 +772,7 @@ impl Document {
                 }
             }
             Key::Enter if !prevented && state == KeyState::Released => {
-                let maybe_elem: Option<&Element> = target.downcast::<Element>();
+                let maybe_elem = target.downcast::<Element>();
                 if let Some(el) = maybe_elem {
                     if let Some(a) = el.as_maybe_activatable() {
                         a.implicit_submission(ctrl, alt, shift, meta);
@@ -797,7 +793,7 @@ impl Document {
             match nodes.into_iter().next().unwrap() {
                 NodeOrString::eNode(node) => Ok(node),
                 NodeOrString::eString(string) => {
-                    Ok(Root::upcast::<Node>(self.CreateTextNode(string)))
+                    Ok(Root::upcast(self.CreateTextNode(string)))
                 },
             }
         } else {
@@ -940,7 +936,8 @@ impl Document {
 
     /// Find an iframe element in the document.
     pub fn find_iframe(&self, subpage_id: SubpageId) -> Option<Root<HTMLIFrameElement>> {
-        self.upcast::<Node>().traverse_preorder()
+        self.upcast::<Node>()
+            .traverse_preorder()
             .filter_map(Root::downcast::<HTMLIFrameElement>)
             .find(|node| node.r().subpage_id() == Some(subpage_id))
     }
@@ -1073,10 +1070,7 @@ impl Document {
     }
 
     fn get_html_element(&self) -> Option<Root<HTMLHtmlElement>> {
-        self.GetDocumentElement()
-            .r()
-            .and_then(Castable::downcast::<HTMLHtmlElement>)
-            .map(Root::from_ref)
+        self.GetDocumentElement().and_then(Root::downcast)
     }
 
     /// https://html.spec.whatwg.org/multipage/#appropriate-template-contents-owner-document
@@ -1131,7 +1125,7 @@ impl DocumentMethods for Document {
         match self.get_focused_element() {
             Some(element) => Some(element),     // Step 3. and 4.
             None => match self.GetBody() {      // Step 5.
-                Some(body) => Some(Root::upcast::<Element>(body)),
+                Some(body) => Some(Root::upcast(body)),
                 None => self.GetDocumentElement(),
             }
         }
@@ -1186,32 +1180,28 @@ impl DocumentMethods for Document {
 
     // https://dom.spec.whatwg.org/#dom-document-doctype
     fn GetDoctype(&self) -> Option<Root<DocumentType>> {
-        let node = self.upcast::<Node>();
-        node.children()
-            .filter_map(|c| c.downcast::<DocumentType>().map(Root::from_ref))
-            .next()
+        self.upcast::<Node>().children().filter_map(Root::downcast).next()
     }
 
     // https://dom.spec.whatwg.org/#dom-document-documentelement
     fn GetDocumentElement(&self) -> Option<Root<Element>> {
-        let node = self.upcast::<Node>();
-        node.child_elements().next()
+        self.upcast::<Node>().child_elements().next()
     }
 
     // https://dom.spec.whatwg.org/#dom-document-getelementsbytagname
     fn GetElementsByTagName(&self, tag_name: DOMString) -> Root<HTMLCollection> {
-        HTMLCollection::by_tag_name(&self.window, self.upcast::<Node>(), tag_name)
+        HTMLCollection::by_tag_name(&self.window, self.upcast(), tag_name)
     }
 
     // https://dom.spec.whatwg.org/#dom-document-getelementsbytagnamens
     fn GetElementsByTagNameNS(&self, maybe_ns: Option<DOMString>, tag_name: DOMString)
                               -> Root<HTMLCollection> {
-        HTMLCollection::by_tag_name_ns(&self.window, self.upcast::<Node>(), tag_name, maybe_ns)
+        HTMLCollection::by_tag_name_ns(&self.window, self.upcast(), tag_name, maybe_ns)
     }
 
     // https://dom.spec.whatwg.org/#dom-document-getelementsbyclassname
     fn GetElementsByClassName(&self, classes: DOMString) -> Root<HTMLCollection> {
-        HTMLCollection::by_class_name(&self.window, self.upcast::<Node>(), classes)
+        HTMLCollection::by_class_name(&self.window, self.upcast(), classes)
     }
 
     // https://dom.spec.whatwg.org/#dom-nonelementparentnode-getelementbyid
@@ -1335,19 +1325,20 @@ impl DocumentMethods for Document {
     fn CreateEvent(&self, mut interface: DOMString) -> Fallible<Root<Event>> {
         interface.make_ascii_lowercase();
         match &*interface {
-            "uievents" | "uievent" => Ok(Root::upcast::<Event>(
-                UIEvent::new_uninitialized(&self.window))),
-            "mouseevents" | "mouseevent" => Ok(Root::upcast::<Event>(
-                MouseEvent::new_uninitialized(&self.window))),
-            "customevent" => Ok(Root::upcast::<Event>(
-                CustomEvent::new_uninitialized(GlobalRef::Window(&self.window)))),
-            "htmlevents" | "events" | "event" => Ok(Event::new_uninitialized(
-                GlobalRef::Window(&self.window))),
-            "keyboardevent" | "keyevents" => Ok(Root::upcast::<Event>(
-                KeyboardEvent::new_uninitialized(&self.window))),
-            "messageevent" => Ok(Root::upcast::<Event>(
-                MessageEvent::new_uninitialized(GlobalRef::Window(&self.window)))),
-            _ => Err(Error::NotSupported)
+            "uievents" | "uievent" =>
+                Ok(Root::upcast(UIEvent::new_uninitialized(&self.window))),
+            "mouseevents" | "mouseevent" =>
+                Ok(Root::upcast(MouseEvent::new_uninitialized(&self.window))),
+            "customevent" =>
+                Ok(Root::upcast(CustomEvent::new_uninitialized(GlobalRef::Window(&self.window)))),
+            "htmlevents" | "events" | "event" =>
+                Ok(Event::new_uninitialized(GlobalRef::Window(&self.window))),
+            "keyboardevent" | "keyevents" =>
+                Ok(Root::upcast(KeyboardEvent::new_uninitialized(&self.window))),
+            "messageevent" =>
+                Ok(Root::upcast(MessageEvent::new_uninitialized(GlobalRef::Window(&self.window)))),
+            _ =>
+                Err(Error::NotSupported),
         }
     }
 
@@ -1389,7 +1380,7 @@ impl DocumentMethods for Document {
                 // Step 2.
                 root.upcast::<Node>()
                     .traverse_preorder()
-                    .find(|node| node.r().is::<HTMLTitleElement>())
+                    .find(|node| node.is::<HTMLTitleElement>())
             }
         });
 
@@ -1423,7 +1414,7 @@ impl DocumentMethods for Document {
                     let elem = Element::create(name, None, self,
                                                ElementCreator::ScriptCreated);
                     root.upcast::<Node>()
-                        .AppendChild(elem.upcast::<Node>())
+                        .AppendChild(elem.upcast())
                         .unwrap()
                 }
             }
@@ -1440,7 +1431,7 @@ impl DocumentMethods for Document {
                             let elem = Element::create(name, None, self,
                                                        ElementCreator::ScriptCreated);
                             head.upcast::<Node>()
-                                .AppendChild(elem.upcast::<Node>())
+                                .AppendChild(elem.upcast())
                                 .unwrap()
                         },
                         None => return,
@@ -1457,10 +1448,7 @@ impl DocumentMethods for Document {
     // https://html.spec.whatwg.org/multipage/#dom-document-head
     fn GetHead(&self) -> Option<Root<HTMLHeadElement>> {
         self.get_html_element().and_then(|root| {
-            let node = root.upcast::<Node>();
-            node.children()
-                .filter_map(|c| c.downcast::<HTMLHeadElement>().map(Root::from_ref))
-                .next()
+            root.upcast::<Node>().children().filter_map(Root::downcast).next()
         })
     }
 
@@ -1479,9 +1467,7 @@ impl DocumentMethods for Document {
                     NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLFrameSetElement)) => true,
                     _ => false
                 }
-            }).map(|node| {
-                Root::from_ref(node.downcast::<HTMLElement>().unwrap())
-            })
+            }).map(|node| Root::downcast(node).unwrap())
         })
     }
 
@@ -1510,9 +1496,7 @@ impl DocumentMethods for Document {
             // Step 3.
             (Some(ref root), &Some(ref child)) => {
                 let root = root.upcast::<Node>();
-                let child = child.upcast::<Node>();
-                let new_body = new_body.upcast::<Node>();
-                assert!(root.ReplaceChild(new_body, child).is_ok())
+                root.ReplaceChild(new_body.upcast(), child.upcast()).unwrap();
             },
 
             // Step 4.
@@ -1521,8 +1505,7 @@ impl DocumentMethods for Document {
             // Step 5.
             (Some(ref root), &None) => {
                 let root = root.upcast::<Node>();
-                let new_body = new_body.upcast::<Node>();
-                assert!(root.AppendChild(new_body).is_ok());
+                root.AppendChild(new_body.upcast()).unwrap();
             }
         }
         Ok(())
@@ -1547,18 +1530,16 @@ impl DocumentMethods for Document {
     // https://html.spec.whatwg.org/multipage/#dom-document-images
     fn Images(&self) -> Root<HTMLCollection> {
         self.images.or_init(|| {
-            let root = self.upcast::<Node>();
             let filter = box ImagesFilter;
-            HTMLCollection::create(&self.window, root, filter)
+            HTMLCollection::create(&self.window, self.upcast(), filter)
         })
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-document-embeds
     fn Embeds(&self) -> Root<HTMLCollection> {
         self.embeds.or_init(|| {
-            let root = self.upcast::<Node>();
             let filter = box EmbedsFilter;
-            HTMLCollection::create(&self.window, root, filter)
+            HTMLCollection::create(&self.window, self.upcast(), filter)
         })
     }
 
@@ -1570,36 +1551,32 @@ impl DocumentMethods for Document {
     // https://html.spec.whatwg.org/multipage/#dom-document-links
     fn Links(&self) -> Root<HTMLCollection> {
         self.links.or_init(|| {
-            let root = self.upcast::<Node>();
             let filter = box LinksFilter;
-            HTMLCollection::create(&self.window, root, filter)
+            HTMLCollection::create(&self.window, self.upcast(), filter)
         })
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-document-forms
     fn Forms(&self) -> Root<HTMLCollection> {
         self.forms.or_init(|| {
-            let root = self.upcast::<Node>();
             let filter = box FormsFilter;
-            HTMLCollection::create(&self.window, root, filter)
+            HTMLCollection::create(&self.window, self.upcast(), filter)
         })
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-document-scripts
     fn Scripts(&self) -> Root<HTMLCollection> {
         self.scripts.or_init(|| {
-            let root = self.upcast::<Node>();
             let filter = box ScriptsFilter;
-            HTMLCollection::create(&self.window, root, filter)
+            HTMLCollection::create(&self.window, self.upcast(), filter)
         })
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-document-anchors
     fn Anchors(&self) -> Root<HTMLCollection> {
         self.anchors.or_init(|| {
-            let root = self.upcast::<Node>();
             let filter = box AnchorsFilter;
-            HTMLCollection::create(&self.window, root, filter)
+            HTMLCollection::create(&self.window, self.upcast(), filter)
         })
     }
 
@@ -1607,9 +1584,8 @@ impl DocumentMethods for Document {
     fn Applets(&self) -> Root<HTMLCollection> {
         // FIXME: This should be return OBJECT elements containing applets.
         self.applets.or_init(|| {
-            let root = self.upcast::<Node>();
             let filter = box AppletsFilter;
-            HTMLCollection::create(&self.window, root, filter)
+            HTMLCollection::create(&self.window, self.upcast(), filter)
         })
     }
 
@@ -1620,7 +1596,7 @@ impl DocumentMethods for Document {
 
     // https://dom.spec.whatwg.org/#dom-parentnode-children
     fn Children(&self) -> Root<HTMLCollection> {
-        HTMLCollection::children(&self.window, self.upcast::<Node>())
+        HTMLCollection::children(&self.window, self.upcast())
     }
 
     // https://dom.spec.whatwg.org/#dom-parentnode-firstelementchild
@@ -1630,7 +1606,7 @@ impl DocumentMethods for Document {
 
     // https://dom.spec.whatwg.org/#dom-parentnode-lastelementchild
     fn GetLastElementChild(&self) -> Option<Root<Element>> {
-        self.upcast::<Node>().rev_children().filter_map(Root::downcast::<Element>).next()
+        self.upcast::<Node>().rev_children().filter_map(Root::downcast).next()
     }
 
     // https://dom.spec.whatwg.org/#dom-parentnode-childelementcount
@@ -1713,7 +1689,7 @@ impl DocumentMethods for Document {
         }
         impl CollectionFilter for NamedElementFilter {
             fn filter(&self, elem: &Element, _root: &Node) -> bool {
-                filter_by_name(&self.name, elem.upcast::<Node>())
+                filter_by_name(&self.name, elem.upcast())
             }
         }
         // https://html.spec.whatwg.org/multipage/#dom-document-nameditem-filter
@@ -1866,9 +1842,8 @@ impl DocumentProgressHandler {
                                EventBubbles::DoesNotBubble,
                                EventCancelable::NotCancelable);
         let wintarget = window.upcast::<EventTarget>();
-        let doctarget = document.upcast::<EventTarget>();
         event.r().set_trusted(true);
-        let _ = wintarget.dispatch_event_with_target(doctarget, event.r());
+        let _ = wintarget.dispatch_event_with_target(document.upcast(), &event);
 
         let browsing_context = window.browsing_context();
         let browsing_context = browsing_context.as_ref().unwrap();
@@ -1878,8 +1853,7 @@ impl DocumentProgressHandler {
             let event = Event::new(GlobalRef::Window(frame_window.r()), "load".to_owned(),
                                    EventBubbles::DoesNotBubble,
                                    EventCancelable::NotCancelable);
-            let target = frame_element.upcast::<EventTarget>();
-            event.r().fire(target);
+            event.fire(frame_element.upcast());
         };
 
         document.r().notify_constellation_load();
diff --git a/components/script/dom/documentfragment.rs b/components/script/dom/documentfragment.rs
index 3a5a1800e91..26a0259fab9 100644
--- a/components/script/dom/documentfragment.rs
+++ b/components/script/dom/documentfragment.rs
@@ -48,7 +48,7 @@ impl DocumentFragmentMethods for DocumentFragment {
     // https://dom.spec.whatwg.org/#dom-parentnode-children
     fn Children(&self) -> Root<HTMLCollection> {
         let window = window_from_node(self);
-        HTMLCollection::children(window.r(), self.upcast::<Node>())
+        HTMLCollection::children(&window, self.upcast())
     }
 
     // https://dom.spec.whatwg.org/#dom-nonelementparentnode-getelementbyid
@@ -90,13 +90,11 @@ impl DocumentFragmentMethods for DocumentFragment {
 
     // https://dom.spec.whatwg.org/#dom-parentnode-queryselector
     fn QuerySelector(&self, selectors: DOMString) -> Fallible<Option<Root<Element>>> {
-        let root = self.upcast::<Node>();
-        root.query_selector(selectors)
+        self.upcast::<Node>().query_selector(selectors)
     }
 
     // https://dom.spec.whatwg.org/#dom-parentnode-queryselectorall
     fn QuerySelectorAll(&self, selectors: DOMString) -> Fallible<Root<NodeList>> {
-        let root = self.upcast::<Node>();
-        root.query_selector_all(selectors)
+        self.upcast::<Node>().query_selector_all(selectors)
     }
 }
diff --git a/components/script/dom/documenttype.rs b/components/script/dom/documenttype.rs
index 590baf4a576..1d72d783e7e 100644
--- a/components/script/dom/documenttype.rs
+++ b/components/script/dom/documenttype.rs
@@ -98,7 +98,6 @@ impl DocumentTypeMethods for DocumentType {
 
     // https://dom.spec.whatwg.org/#dom-childnode-remove
     fn Remove(&self) {
-        let node = self.upcast::<Node>();
-        node.remove_self();
+        self.upcast::<Node>().remove_self();
     }
 }
diff --git a/components/script/dom/domimplementation.rs b/components/script/dom/domimplementation.rs
index af94a32b854..02c8ad4fa84 100644
--- a/components/script/dom/domimplementation.rs
+++ b/components/script/dom/domimplementation.rs
@@ -80,20 +80,13 @@ impl DOMImplementationMethods for DOMImplementation {
             let doc_node = doc.upcast::<Node>();
 
             // Step 4.
-            match maybe_doctype {
-                None => (),
-                Some(ref doctype) => {
-                    let doc_type = doctype.upcast::<Node>();
-                    assert!(doc_node.AppendChild(doc_type).is_ok())
-                }
+            if let Some(doc_type) = maybe_doctype {
+                doc_node.AppendChild(doc_type.upcast()).unwrap();
             }
 
             // Step 5.
-            match maybe_elem {
-                None => (),
-                Some(ref elem) => {
-                    assert!(doc_node.AppendChild(elem.upcast::<Node>()).is_ok())
-                }
+            if let Some(ref elem) = maybe_elem {
+                doc_node.AppendChild(elem.upcast()).unwrap();
             }
         }
 
@@ -117,7 +110,7 @@ impl DOMImplementationMethods for DOMImplementation {
             // Step 3.
             let doc_node = doc.upcast::<Node>();
             let doc_type = DocumentType::new("html".to_owned(), None, None, doc.r());
-            assert!(doc_node.AppendChild(doc_type.upcast::<Node>()).is_ok());
+            doc_node.AppendChild(doc_type.upcast()).unwrap();
         }
 
         {
@@ -125,13 +118,13 @@ impl DOMImplementationMethods for DOMImplementation {
             let doc_node = doc.upcast::<Node>();
             let doc_html = Root::upcast::<Node>(
                 HTMLHtmlElement::new("html".to_owned(), None, doc.r()));
-            assert!(doc_node.AppendChild(doc_html.r()).is_ok());
+            doc_node.AppendChild(&doc_html).expect("Appending failed");
 
             {
                 // Step 5.
                 let doc_head = Root::upcast::<Node>(
                     HTMLHeadElement::new("head".to_owned(), None, doc.r()));
-                assert!(doc_html.r().AppendChild(doc_head.r()).is_ok());
+                doc_html.AppendChild(&doc_head).unwrap();
 
                 // Step 6.
                 match title {
@@ -140,18 +133,18 @@ impl DOMImplementationMethods for DOMImplementation {
                         // Step 6.1.
                         let doc_title = Root::upcast::<Node>(
                             HTMLTitleElement::new("title".to_owned(), None, doc.r()));
-                        assert!(doc_head.r().AppendChild(doc_title.r()).is_ok());
+                        doc_head.AppendChild(&doc_title).unwrap();
 
                         // Step 6.2.
                         let title_text = Text::new(title_str, doc.r());
-                        assert!(doc_title.r().AppendChild(title_text.upcast::<Node>()).is_ok());
+                        doc_title.AppendChild(title_text.upcast()).unwrap();
                     }
                 }
             }
 
             // Step 7.
             let doc_body = HTMLBodyElement::new("body".to_owned(), None, doc.r());
-            assert!(doc_html.r().AppendChild(doc_body.upcast::<Node>()).is_ok());
+            doc_html.AppendChild(doc_body.upcast()).unwrap();
         }
 
         // Step 8.
diff --git a/components/script/dom/element.rs b/components/script/dom/element.rs
index 52f2bbc5423..f0d078fbaf1 100644
--- a/components/script/dom/element.rs
+++ b/components/script/dom/element.rs
@@ -35,7 +35,6 @@ use dom::domrect::DOMRect;
 use dom::domrectlist::DOMRectList;
 use dom::domtokenlist::DOMTokenList;
 use dom::event::Event;
-use dom::eventtarget::EventTarget;
 use dom::htmlanchorelement::HTMLAnchorElement;
 use dom::htmlbodyelement::HTMLBodyElement;
 use dom::htmlcollection::HTMLCollection;
@@ -544,8 +543,7 @@ impl LayoutElementHelpers for LayoutJS<Element> {
         if (*self.unsafe_get()).namespace != ns!(HTML) {
             return false
         }
-        let node = self.upcast::<Node>();
-        node.owner_doc_for_layout().is_html_document_for_layout()
+        self.upcast::<Node>().owner_doc_for_layout().is_html_document_for_layout()
     }
 
     #[allow(unsafe_code)]
@@ -623,8 +621,7 @@ pub enum StylePriority {
 
 impl Element {
     pub fn html_element_in_html_document(&self) -> bool {
-        let node = self.upcast::<Node>();
-        self.namespace == ns!(HTML) && node.is_in_html_doc()
+        self.namespace == ns!(HTML) && self.upcast::<Node>().is_in_html_doc()
     }
 
     pub fn local_name(&self) -> &Atom {
@@ -784,9 +781,8 @@ impl Element {
     }
 
     pub fn serialize(&self, traversal_scope: TraversalScope) -> Fallible<DOMString> {
-        let node = self.upcast::<Node>();
         let mut writer = vec![];
-        match serialize(&mut writer, &node,
+        match serialize(&mut writer, &self.upcast::<Node>(),
                         SerializeOpts {
                             traversal_scope: traversal_scope,
                             .. Default::default()
@@ -798,10 +794,7 @@ impl Element {
 
     // https://html.spec.whatwg.org/multipage/#root-element
     pub fn get_root_element(&self) -> Root<Element> {
-        let node = self.upcast::<Node>();
-        node.inclusive_ancestors()
-            .filter_map(Root::downcast::<Element>)
-            .last()
+        self.upcast::<Node>().inclusive_ancestors().filter_map(Root::downcast).last()
             .expect("We know inclusive_ancestors will return `self` which is an element")
     }
 
@@ -889,8 +882,7 @@ impl Element {
         let attr = Attr::new(&window, local_name, value, name, namespace, prefix, Some(self));
         self.attrs.borrow_mut().push(JS::from_rooted(&attr));
         if in_empty_ns {
-            vtable_for(self.upcast::<Node>()).attribute_mutated(
-                &attr, AttributeMutation::Set(None));
+            vtable_for(self.upcast()).attribute_mutated(&attr, AttributeMutation::Set(None));
         }
     }
 
@@ -974,8 +966,7 @@ impl Element {
     pub fn parse_attribute(&self, namespace: &Namespace, local_name: &Atom,
                        value: DOMString) -> AttrValue {
         if *namespace == ns!("") {
-            vtable_for(&self.upcast::<Node>())
-                .parse_plain_attribute(local_name, value)
+            vtable_for(self.upcast()).parse_plain_attribute(local_name, value)
         } else {
             AttrValue::String(value)
         }
@@ -1001,20 +992,15 @@ impl Element {
             let attr = (*self.attrs.borrow())[idx].root();
             self.attrs.borrow_mut().remove(idx);
             attr.set_owner(None);
-            let node = self.upcast::<Node>();
             if attr.namespace() == &ns!("") {
-                vtable_for(node).attribute_mutated(&attr, AttributeMutation::Removed);
+                vtable_for(self.upcast()).attribute_mutated(&attr, AttributeMutation::Removed);
             }
             attr
         })
     }
 
     pub fn has_class(&self, name: &Atom) -> bool {
-        let quirks_mode = {
-            let node = self.upcast::<Node>();
-            let owner_doc = node.owner_doc();
-            owner_doc.r().quirks_mode()
-        };
+        let quirks_mode = document_from_node(self).quirks_mode();
         let is_equal = |lhs: &Atom, rhs: &Atom| match quirks_mode {
             NoQuirks | LimitedQuirks => lhs == rhs,
             Quirks => lhs.eq_ignore_ascii_case(&rhs)
@@ -1175,14 +1161,7 @@ impl ElementMethods for Element {
 
     // https://dom.spec.whatwg.org/#dom-element-attributes
     fn Attributes(&self) -> Root<NamedNodeMap> {
-        self.attr_list.or_init(|| {
-            let doc = {
-                let node = self.upcast::<Node>();
-                node.owner_doc()
-            };
-            let window = doc.r().window();
-            NamedNodeMap::new(window, self)
-        })
+        self.attr_list.or_init(|| NamedNodeMap::new(&window_from_node(self), self))
     }
 
     // https://dom.spec.whatwg.org/#dom-element-getattribute
@@ -1277,27 +1256,26 @@ impl ElementMethods for Element {
     // https://dom.spec.whatwg.org/#dom-element-getelementsbytagname
     fn GetElementsByTagName(&self, localname: DOMString) -> Root<HTMLCollection> {
         let window = window_from_node(self);
-        HTMLCollection::by_tag_name(window.r(), self.upcast::<Node>(), localname)
+        HTMLCollection::by_tag_name(window.r(), self.upcast(), localname)
     }
 
     // https://dom.spec.whatwg.org/#dom-element-getelementsbytagnamens
     fn GetElementsByTagNameNS(&self, maybe_ns: Option<DOMString>,
                               localname: DOMString) -> Root<HTMLCollection> {
         let window = window_from_node(self);
-        HTMLCollection::by_tag_name_ns(window.r(), self.upcast::<Node>(), localname, maybe_ns)
+        HTMLCollection::by_tag_name_ns(window.r(), self.upcast(), localname, maybe_ns)
     }
 
     // https://dom.spec.whatwg.org/#dom-element-getelementsbyclassname
     fn GetElementsByClassName(&self, classes: DOMString) -> Root<HTMLCollection> {
         let window = window_from_node(self);
-        HTMLCollection::by_class_name(window.r(), self.upcast::<Node>(), classes)
+        HTMLCollection::by_class_name(window.r(), self.upcast(), classes)
     }
 
     // https://drafts.csswg.org/cssom-view/#dom-element-getclientrects
     fn GetClientRects(&self) -> Root<DOMRectList> {
         let win = window_from_node(self);
-        let node = self.upcast::<Node>();
-        let raw_rects = node.get_content_boxes();
+        let raw_rects = self.upcast::<Node>().get_content_boxes();
         let rects = raw_rects.iter().map(|rect| {
             DOMRect::new(GlobalRef::Window(win.r()),
                          rect.origin.x.to_f64_px(),
@@ -1311,8 +1289,7 @@ impl ElementMethods for Element {
     // https://drafts.csswg.org/cssom-view/#dom-element-getboundingclientrect
     fn GetBoundingClientRect(&self) -> Root<DOMRect> {
         let win = window_from_node(self);
-        let node = self.upcast::<Node>();
-        let rect = node.get_bounding_content_box();
+        let rect = self.upcast::<Node>().get_bounding_content_box();
         DOMRect::new(GlobalRef::Window(win.r()),
                      rect.origin.x.to_f64_px(),
                      rect.origin.y.to_f64_px(),
@@ -1322,26 +1299,22 @@ impl ElementMethods for Element {
 
     // https://drafts.csswg.org/cssom-view/#dom-element-clienttop
     fn ClientTop(&self) -> i32 {
-        let node = self.upcast::<Node>();
-        node.get_client_rect().origin.y
+        self.upcast::<Node>().get_client_rect().origin.y
     }
 
     // https://drafts.csswg.org/cssom-view/#dom-element-clientleft
     fn ClientLeft(&self) -> i32 {
-        let node = self.upcast::<Node>();
-        node.get_client_rect().origin.x
+        self.upcast::<Node>().get_client_rect().origin.x
     }
 
     // https://drafts.csswg.org/cssom-view/#dom-element-clientwidth
     fn ClientWidth(&self) -> i32 {
-        let node = self.upcast::<Node>();
-        node.get_client_rect().size.width
+        self.upcast::<Node>().get_client_rect().size.width
     }
 
     // https://drafts.csswg.org/cssom-view/#dom-element-clientheight
     fn ClientHeight(&self) -> i32 {
-        let node = self.upcast::<Node>();
-        node.get_client_rect().size.height
+        self.upcast::<Node>().get_client_rect().size.height
     }
 
     /// https://w3c.github.io/DOM-Parsing/#widl-Element-innerHTML
@@ -1358,11 +1331,11 @@ impl ElementMethods for Element {
         // Step 2.
         // https://github.com/w3c/DOM-Parsing/issues/1
         let target = if let Some(template) = self.downcast::<HTMLTemplateElement>() {
-            Root::upcast::<Node>(template.Content())
+            Root::upcast(template.Content())
         } else {
             Root::from_ref(context_node)
         };
-        Node::replace_all(Some(frag.upcast::<Node>()), &target);
+        Node::replace_all(Some(frag.upcast()), &target);
         Ok(())
     }
 
@@ -1393,7 +1366,7 @@ impl ElementMethods for Element {
                 let body_elem = Element::create(QualName::new(ns!(HTML), atom!(body)),
                                                 None, context_document.r(),
                                                 ElementCreator::ScriptCreated);
-                Root::upcast::<Node>(body_elem)
+                Root::upcast(body_elem)
             },
             _ => context_node.GetParentNode().unwrap()
         };
@@ -1401,27 +1374,24 @@ impl ElementMethods for Element {
         // Step 5.
         let frag = try!(parent.r().parse_fragment(value));
         // Step 6.
-        try!(context_parent.r().ReplaceChild(frag.upcast::<Node>(),
-                                             context_node));
+        try!(context_parent.ReplaceChild(frag.upcast(), context_node));
         Ok(())
     }
 
     // https://dom.spec.whatwg.org/#dom-nondocumenttypechildnode-previouselementsibling
     fn GetPreviousElementSibling(&self) -> Option<Root<Element>> {
-        self.upcast::<Node>().preceding_siblings()
-                             .filter_map(Root::downcast::<Element>).next()
+        self.upcast::<Node>().preceding_siblings().filter_map(Root::downcast).next()
     }
 
     // https://dom.spec.whatwg.org/#dom-nondocumenttypechildnode-nextelementsibling
     fn GetNextElementSibling(&self) -> Option<Root<Element>> {
-        self.upcast::<Node>().following_siblings()
-                             .filter_map(Root::downcast::<Element>).next()
+        self.upcast::<Node>().following_siblings().filter_map(Root::downcast).next()
     }
 
     // https://dom.spec.whatwg.org/#dom-parentnode-children
     fn Children(&self) -> Root<HTMLCollection> {
         let window = window_from_node(self);
-        HTMLCollection::children(window.r(), self.upcast::<Node>())
+        HTMLCollection::children(window.r(), self.upcast())
     }
 
     // https://dom.spec.whatwg.org/#dom-parentnode-firstelementchild
@@ -1478,8 +1448,7 @@ impl ElementMethods for Element {
 
     // https://dom.spec.whatwg.org/#dom-childnode-remove
     fn Remove(&self) {
-        let node = self.upcast::<Node>();
-        node.remove_self();
+        self.upcast::<Node>().remove_self();
     }
 
     // https://dom.spec.whatwg.org/#dom-element-matches
@@ -1513,8 +1482,7 @@ impl ElementMethods for Element {
 
 impl VirtualMethods for Element {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let node: &Node = self.upcast::<Node>();
-        Some(node as &VirtualMethods)
+        Some(self.upcast::<Node>() as &VirtualMethods)
     }
 
     fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
@@ -1620,15 +1588,15 @@ impl<'a> ::selectors::Element for Root<Element> {
     }
 
     fn last_child_element(&self) -> Option<Root<Element>> {
-        self.node.rev_children().filter_map(Root::downcast::<Element>).next()
+        self.node.rev_children().filter_map(Root::downcast).next()
     }
 
     fn prev_sibling_element(&self) -> Option<Root<Element>> {
-        self.node.preceding_siblings().filter_map(Root::downcast::<Element>).next()
+        self.node.preceding_siblings().filter_map(Root::downcast).next()
     }
 
     fn next_sibling_element(&self) -> Option<Root<Element>> {
-        self.node.following_siblings().filter_map(Root::downcast::<Element>).next()
+        self.node.following_siblings().filter_map(Root::downcast).next()
     }
 
     fn is_root(&self) -> bool {
@@ -1701,15 +1669,13 @@ impl<'a> ::selectors::Element for Root<Element> {
         Element::get_enabled_state(self)
     }
     fn get_checked_state(&self) -> bool {
-        let input_element: Option<&HTMLInputElement> = self.downcast::<HTMLInputElement>();
-        match input_element {
+        match self.downcast::<HTMLInputElement>() {
             Some(input) => input.Checked(),
             None => false,
         }
     }
     fn get_indeterminate_state(&self) -> bool {
-        let input_element: Option<&HTMLInputElement> = self.downcast::<HTMLInputElement>();
-        match input_element {
+        match self.downcast::<HTMLInputElement>() {
             Some(input) => input.get_indeterminate_state(),
             None => false,
         }
@@ -1729,8 +1695,7 @@ impl<'a> ::selectors::Element for Root<Element> {
         }
     }
     fn has_servo_nonzero_border(&self) -> bool {
-        let table_element: Option<&HTMLTableElement> = self.downcast::<HTMLTableElement>();
-        match table_element {
+        match self.downcast::<HTMLTableElement>() {
             None => false,
             Some(this) => {
                 match this.get_border() {
@@ -1774,8 +1739,7 @@ impl<'a> ::selectors::Element for Root<Element> {
 
 impl Element {
     pub fn as_maybe_activatable(&self) -> Option<&Activatable> {
-        let node = self.upcast::<Node>();
-        let element = match node.type_id() {
+        let element = match self.upcast::<Node>().type_id() {
             NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLInputElement)) => {
                 let element = self.downcast::<HTMLInputElement>().unwrap();
                 Some(element as &Activatable)
@@ -1798,13 +1762,11 @@ impl Element {
     }
 
     pub fn click_in_progress(&self) -> bool {
-        let node = self.upcast::<Node>();
-        node.get_flag(CLICK_IN_PROGRESS)
+        self.upcast::<Node>().get_flag(CLICK_IN_PROGRESS)
     }
 
     pub fn set_click_in_progress(&self, click: bool) {
-        let node = self.upcast::<Node>();
-        node.set_flag(CLICK_IN_PROGRESS, click)
+        self.upcast::<Node>().set_flag(CLICK_IN_PROGRESS, click)
     }
 
     // https://html.spec.whatwg.org/multipage/#nearest-activatable-element
@@ -1838,7 +1800,7 @@ impl Element {
         // the script can generate more click events from the handler)
         assert!(!self.click_in_progress());
 
-        let target = self.upcast::<EventTarget>();
+        let target = self.upcast();
         // Step 2 (requires canvas support)
         // Step 3
         self.set_click_in_progress(true);
diff --git a/components/script/dom/eventdispatcher.rs b/components/script/dom/eventdispatcher.rs
index 9df978fa589..2b0e1942843 100644
--- a/components/script/dom/eventdispatcher.rs
+++ b/components/script/dom/eventdispatcher.rs
@@ -150,8 +150,7 @@ pub fn dispatch_event(target: &EventTarget, pseudo_target: Option<&EventTarget>,
     let mut chain: RootedVec<JS<EventTarget>> = RootedVec::new();
     if let Some(target_node) = target.downcast::<Node>() {
         for ancestor in target_node.ancestors() {
-            let ancestor_target = ancestor.upcast::<EventTarget>();
-            chain.push(JS::from_ref(ancestor_target))
+            chain.push(JS::from_ref(ancestor.upcast()));
         }
     }
 
@@ -161,13 +160,9 @@ pub fn dispatch_event(target: &EventTarget, pseudo_target: Option<&EventTarget>,
     let target = event.GetTarget();
     match target {
         Some(ref target) => {
-            let node: Option<&Node> = target.downcast::<Node>();
-            match node {
-                Some(node) => {
-                    let vtable = vtable_for(&node);
-                    vtable.handle_event(event);
-                }
-                None => {}
+            if let Some(node) = target.downcast::<Node>() {
+                let vtable = vtable_for(&node);
+                vtable.handle_event(event);
             }
         }
         None => {}
diff --git a/components/script/dom/filereader.rs b/components/script/dom/filereader.rs
index 547234101d1..4e17f6dd62e 100644
--- a/components/script/dom/filereader.rs
+++ b/components/script/dom/filereader.rs
@@ -324,10 +324,7 @@ impl FileReader {
         let progressevent = ProgressEvent::new(global.r(),
             type_, EventBubbles::DoesNotBubble, EventCancelable::NotCancelable,
             total.is_some(), loaded, total.unwrap_or(0));
-
-        let target = self.upcast::<EventTarget>();
-        let event = progressevent.upcast::<Event>();
-        event.fire(target);
+        progressevent.upcast::<Event>().fire(self.upcast());
     }
 
     fn terminate_ongoing_reading(&self) {
diff --git a/components/script/dom/formdata.rs b/components/script/dom/formdata.rs
index a70387dabe1..a51e058b864 100644
--- a/components/script/dom/formdata.rs
+++ b/components/script/dom/formdata.rs
@@ -116,7 +116,7 @@ impl FormDataMethods for FormData {
 impl FormData {
     fn get_file_from_blob(&self, value: &Blob, filename: Option<DOMString>) -> Root<File> {
         let global = self.global.root();
-        let f: Option<&File> = value.downcast::<File>();
+        let f = value.downcast::<File>();
         let name = filename.unwrap_or(f.map(|inner| inner.name().clone()).unwrap_or("blob".to_owned()));
         File::new(global.r(), value, name)
     }
diff --git a/components/script/dom/htmlanchorelement.rs b/components/script/dom/htmlanchorelement.rs
index dd1c88e16e6..a269dd948fc 100644
--- a/components/script/dom/htmlanchorelement.rs
+++ b/components/script/dom/htmlanchorelement.rs
@@ -56,8 +56,7 @@ impl HTMLAnchorElement {
 
 impl VirtualMethods for HTMLAnchorElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
-        Some(htmlelement as &VirtualMethods)
+        Some(self.upcast::<HTMLElement>() as &VirtualMethods)
     }
 
     fn parse_plain_attribute(&self, name: &Atom, value: DOMString) -> AttrValue {
@@ -71,20 +70,18 @@ impl VirtualMethods for HTMLAnchorElement {
 impl HTMLAnchorElementMethods for HTMLAnchorElement {
     // https://html.spec.whatwg.org/multipage/#dom-a-text
     fn Text(&self) -> DOMString {
-        let node = self.upcast::<Node>();
-        node.GetTextContent().unwrap()
+        self.upcast::<Node>().GetTextContent().unwrap()
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-a-text
     fn SetText(&self, value: DOMString) {
-        let node = self.upcast::<Node>();
-        node.SetTextContent(Some(value))
+        self.upcast::<Node>().SetTextContent(Some(value))
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-a-rellist
     fn RelList(&self) -> Root<DOMTokenList> {
         self.rel_list.or_init(|| {
-            DOMTokenList::new(self.upcast::<Element>(), &atom!("rel"))
+            DOMTokenList::new(self.upcast(), &atom!("rel"))
         })
     }
 
diff --git a/components/script/dom/htmlareaelement.rs b/components/script/dom/htmlareaelement.rs
index 274d5ce89f0..c9023bdbb23 100644
--- a/components/script/dom/htmlareaelement.rs
+++ b/components/script/dom/htmlareaelement.rs
@@ -10,7 +10,6 @@ use dom::bindings::js::{JS, MutNullableHeap, Root};
 use dom::bindings::utils::Reflectable;
 use dom::document::Document;
 use dom::domtokenlist::DOMTokenList;
-use dom::element::Element;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use dom::virtualmethods::VirtualMethods;
@@ -43,8 +42,7 @@ impl HTMLAreaElement {
 
 impl VirtualMethods for HTMLAreaElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
-        Some(htmlelement as &VirtualMethods)
+        Some(self.upcast::<HTMLElement>() as &VirtualMethods)
     }
 
     fn parse_plain_attribute(&self, name: &Atom, value: DOMString) -> AttrValue {
@@ -59,7 +57,7 @@ impl HTMLAreaElementMethods for HTMLAreaElement {
     // https://html.spec.whatwg.org/multipage/#dom-area-rellist
     fn RelList(&self) -> Root<DOMTokenList> {
         self.rel_list.or_init(|| {
-            DOMTokenList::new(self.upcast::<Element>(), &atom!("rel"))
+            DOMTokenList::new(self.upcast(), &atom!("rel"))
         })
     }
 }
diff --git a/components/script/dom/htmlbodyelement.rs b/components/script/dom/htmlbodyelement.rs
index 6cef068716f..4b639d0ed42 100644
--- a/components/script/dom/htmlbodyelement.rs
+++ b/components/script/dom/htmlbodyelement.rs
@@ -124,8 +124,7 @@ impl HTMLBodyElement {
 
 impl VirtualMethods for HTMLBodyElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let element: &HTMLElement = self.upcast::<HTMLElement>();
-        Some(element as &VirtualMethods)
+        Some(self.upcast::<HTMLElement>() as &VirtualMethods)
     }
 
     fn bind_to_tree(&self, tree_in_doc: bool) {
diff --git a/components/script/dom/htmlbuttonelement.rs b/components/script/dom/htmlbuttonelement.rs
index 8f9c2bf420e..5146c7e4888 100644
--- a/components/script/dom/htmlbuttonelement.rs
+++ b/components/script/dom/htmlbuttonelement.rs
@@ -82,8 +82,7 @@ impl HTMLButtonElementMethods for HTMLButtonElement {
 
     // https://html.spec.whatwg.org/multipage/#dom-button-type
     fn Type(&self) -> DOMString {
-        let elem = self.upcast::<Element>();
-        let mut ty = elem.get_string_attribute(&atom!("type"));
+        let mut ty = self.upcast::<Element>().get_string_attribute(&atom!("type"));
         ty.make_ascii_lowercase();
         // https://html.spec.whatwg.org/multipage/#attr-button-type
         match &*ty {
@@ -135,8 +134,7 @@ impl HTMLButtonElementMethods for HTMLButtonElement {
 
 impl VirtualMethods for HTMLButtonElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
-        Some(htmlelement as &VirtualMethods)
+        Some(self.upcast::<HTMLElement>() as &VirtualMethods)
     }
 
     fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
@@ -166,8 +164,7 @@ impl VirtualMethods for HTMLButtonElement {
             s.bind_to_tree(tree_in_doc);
         }
 
-        let el = self.upcast::<Element>();
-        el.check_ancestors_disabled_state_for_form_control();
+        self.upcast::<Element>().check_ancestors_disabled_state_for_form_control();
     }
 
     fn unbind_from_tree(&self, tree_in_doc: bool) {
@@ -189,13 +186,12 @@ impl FormControl for HTMLButtonElement {}
 
 impl<'a> Activatable for &'a HTMLButtonElement {
     fn as_element(&self) -> &Element {
-        self.upcast::<Element>()
+        self.upcast()
     }
 
     fn is_instance_activatable(&self) -> bool {
         //https://html.spec.whatwg.org/multipage/#the-button-element
-        let el = self.upcast::<Element>();
-        !(el.get_disabled_state())
+        !self.upcast::<Element>().get_disabled_state()
     }
 
     // https://html.spec.whatwg.org/multipage/#run-pre-click-activation-steps
@@ -228,8 +224,7 @@ impl<'a> Activatable for &'a HTMLButtonElement {
         let doc = document_from_node(*self);
         let node = doc.upcast::<Node>();
         let owner = self.form_owner();
-        let elem = self.upcast::<Element>();
-        if owner.is_none() || elem.click_in_progress() {
+        if owner.is_none() || self.upcast::<Element>().click_in_progress() {
             return;
         }
         node.query_selector_iter("button[type=submit]".to_owned()).unwrap()
diff --git a/components/script/dom/htmlcanvaselement.rs b/components/script/dom/htmlcanvaselement.rs
index 75d2a4151e0..38f06faf4c7 100644
--- a/components/script/dom/htmlcanvaselement.rs
+++ b/components/script/dom/htmlcanvaselement.rs
@@ -225,8 +225,7 @@ impl HTMLCanvasElementMethods for HTMLCanvasElement {
 
     // https://html.spec.whatwg.org/multipage/#dom-canvas-width
     fn SetWidth(&self, width: u32) {
-        let elem = self.upcast::<Element>();
-        elem.set_uint_attribute(&atom!("width"), width)
+        self.upcast::<Element>().set_uint_attribute(&atom!("width"), width)
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-canvas-height
@@ -236,8 +235,7 @@ impl HTMLCanvasElementMethods for HTMLCanvasElement {
 
     // https://html.spec.whatwg.org/multipage/#dom-canvas-height
     fn SetHeight(&self, height: u32) {
-        let elem = self.upcast::<Element>();
-        elem.set_uint_attribute(&atom!("height"), height)
+        self.upcast::<Element>().set_uint_attribute(&atom!("height"), height)
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-canvas-getcontext
@@ -264,8 +262,7 @@ impl HTMLCanvasElementMethods for HTMLCanvasElement {
 
 impl VirtualMethods for HTMLCanvasElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let element: &HTMLElement = self.upcast::<HTMLElement>();
-        Some(element as &VirtualMethods)
+        Some(self.upcast::<HTMLElement>() as &VirtualMethods)
     }
 
     fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
diff --git a/components/script/dom/htmlcollection.rs b/components/script/dom/htmlcollection.rs
index 7d4e217147b..dda2bd9b3b8 100644
--- a/components/script/dom/htmlcollection.rs
+++ b/components/script/dom/htmlcollection.rs
@@ -154,7 +154,7 @@ impl HTMLCollection {
         struct ElementChildFilter;
         impl CollectionFilter for ElementChildFilter {
             fn filter(&self, elem: &Element, root: &Node) -> bool {
-                root.is_parent_of(elem.upcast::<Node>())
+                root.is_parent_of(elem.upcast())
             }
         }
         HTMLCollection::create(window, root, box ElementChildFilter)
@@ -186,8 +186,8 @@ impl<'a> Iterator for HTMLCollectionElementsIter<'a> {
         let filter = self.filter;
         let root = self.root.r();
         self.node_iter.by_ref()
-                      .filter_map(Root::downcast::<Element>)
-                      .filter(|element| filter.filter(element.r(), root))
+                      .filter_map(Root::downcast)
+                      .filter(|element| filter.filter(&element, root))
                       .next()
     }
 }
diff --git a/components/script/dom/htmldatalistelement.rs b/components/script/dom/htmldatalistelement.rs
index 4b6b4cf4a12..9b262ab686f 100644
--- a/components/script/dom/htmldatalistelement.rs
+++ b/components/script/dom/htmldatalistelement.rs
@@ -48,9 +48,8 @@ impl HTMLDataListElementMethods for HTMLDataListElement {
                 elem.is::<HTMLOptionElement>()
             }
         }
-        let node = self.upcast::<Node>();
         let filter = box HTMLDataListOptionsFilter;
-        let window = window_from_node(node);
-        HTMLCollection::create(window.r(), node, filter)
+        let window = window_from_node(self);
+        HTMLCollection::create(window.r(), self.upcast(), filter)
     }
 }
diff --git a/components/script/dom/htmlelement.rs b/components/script/dom/htmlelement.rs
index f2b36bfd151..34a7847187a 100644
--- a/components/script/dom/htmlelement.rs
+++ b/components/script/dom/htmlelement.rs
@@ -162,41 +162,37 @@ impl HTMLElementMethods for HTMLElement {
             let win = window_from_node(self);
             win.r().SetOnload(listener)
         } else {
-            let target = self.upcast::<EventTarget>();
-            target.set_event_handler_common("load", listener)
+            self.upcast::<EventTarget>().set_event_handler_common("load", listener)
         }
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-click
     fn Click(&self) {
-        let maybe_input: Option<&HTMLInputElement> = self.downcast::<HTMLInputElement>();
-        if let Some(i) = maybe_input {
+        if let Some(i) = self.downcast::<HTMLInputElement>() {
             if i.Disabled() {
                 return;
             }
         }
-        let element = self.upcast::<Element>();
         // https://www.w3.org/Bugs/Public/show_bug.cgi?id=27430 ?
-        element.as_maybe_activatable().map(|a| a.synthetic_click_activation(false, false, false, false));
+        self.upcast::<Element>()
+            .as_maybe_activatable()
+            .map(|a| a.synthetic_click_activation(false, false, false, false));
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-focus
     fn Focus(&self) {
         // TODO: Mark the element as locked for focus and run the focusing steps.
         // https://html.spec.whatwg.org/multipage/#focusing-steps
-        let element = self.upcast::<Element>();
         let document = document_from_node(self);
-        let document = document.r();
         document.begin_focus_transaction();
-        document.request_focus(element);
+        document.request_focus(self.upcast());
         document.commit_focus_transaction(FocusType::Element);
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-blur
     fn Blur(&self) {
         // TODO: Run the unfocusing steps.
-        let el = self.upcast::<Element>();
-        if !el.get_focus_state() {
+        if !self.upcast::<Element>().get_focus_state() {
             return;
         }
         // https://html.spec.whatwg.org/multipage/#unfocusing-steps
@@ -286,29 +282,25 @@ impl HTMLElement {
                .nth(1).map_or(false, |ch| ch >= 'a' && ch <= 'z') {
             return Err(Error::Syntax);
         }
-        let element = self.upcast::<Element>();
-        element.set_custom_attribute(to_snake_case(name), value)
+        self.upcast::<Element>().set_custom_attribute(to_snake_case(name), value)
     }
 
     pub fn get_custom_attr(&self, local_name: DOMString) -> Option<DOMString> {
-        let element = self.upcast::<Element>();
         let local_name = Atom::from_slice(&to_snake_case(local_name));
-        element.get_attribute(&ns!(""), &local_name).map(|attr| {
+        self.upcast::<Element>().get_attribute(&ns!(""), &local_name).map(|attr| {
             (**attr.r().value()).to_owned()
         })
     }
 
     pub fn delete_custom_attr(&self, local_name: DOMString) {
-        let element = self.upcast::<Element>();
         let local_name = Atom::from_slice(&to_snake_case(local_name));
-        element.remove_attribute(&ns!(""), &local_name);
+        self.upcast::<Element>().remove_attribute(&ns!(""), &local_name);
     }
 }
 
 impl VirtualMethods for HTMLElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let element: &Element = self.upcast::<Element>();
-        Some(element as &VirtualMethods)
+        Some(self.upcast::<Element>() as &VirtualMethods)
     }
 
     fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
diff --git a/components/script/dom/htmlfieldsetelement.rs b/components/script/dom/htmlfieldsetelement.rs
index b875e275c66..63c614d308f 100644
--- a/components/script/dom/htmlfieldsetelement.rs
+++ b/components/script/dom/htmlfieldsetelement.rs
@@ -56,10 +56,9 @@ impl HTMLFieldSetElementMethods for HTMLFieldSetElement {
                 TAG_NAMES.iter().any(|&tag_name| tag_name == &**elem.local_name())
             }
         }
-        let node = self.upcast::<Node>();
         let filter = box ElementsFilter;
-        let window = window_from_node(node);
-        HTMLCollection::create(window.r(), node, filter)
+        let window = window_from_node(self);
+        HTMLCollection::create(window.r(), self.upcast(), filter)
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-cva-validity
@@ -82,8 +81,7 @@ impl HTMLFieldSetElementMethods for HTMLFieldSetElement {
 
 impl VirtualMethods for HTMLFieldSetElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
-        Some(htmlelement as &VirtualMethods)
+        Some(self.upcast::<HTMLElement>() as &VirtualMethods)
     }
 
     fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
diff --git a/components/script/dom/htmlfontelement.rs b/components/script/dom/htmlfontelement.rs
index ba6b586e9d3..6c54bfbc773 100644
--- a/components/script/dom/htmlfontelement.rs
+++ b/components/script/dom/htmlfontelement.rs
@@ -71,8 +71,7 @@ impl HTMLFontElementMethods for HTMLFontElement {
 
 impl VirtualMethods for HTMLFontElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement = self.upcast::<HTMLElement>();
-        Some(htmlelement as &VirtualMethods)
+        Some(self.upcast::<HTMLElement>() as &VirtualMethods)
     }
 
     fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
diff --git a/components/script/dom/htmlformelement.rs b/components/script/dom/htmlformelement.rs
index 0584cd85c59..be4f092da72 100644
--- a/components/script/dom/htmlformelement.rs
+++ b/components/script/dom/htmlformelement.rs
@@ -17,7 +17,6 @@ use dom::bindings::utils::Reflectable;
 use dom::document::Document;
 use dom::element::Element;
 use dom::event::{Event, EventBubbles, EventCancelable};
-use dom::eventtarget::EventTarget;
 use dom::htmlbuttonelement::{HTMLButtonElement};
 use dom::htmldatalistelement::HTMLDataListElement;
 use dom::htmlelement::HTMLElement;
@@ -163,8 +162,7 @@ impl HTMLFormElement {
                                "submit".to_owned(),
                                EventBubbles::Bubbles,
                                EventCancelable::Cancelable);
-        let target = self.upcast::<EventTarget>();
-        event.r().fire(target);
+        event.fire(self.upcast());
         if event.r().DefaultPrevented() {
             return;
         }
@@ -316,21 +314,17 @@ impl HTMLFormElement {
                                "reset".to_owned(),
                                EventBubbles::Bubbles,
                                EventCancelable::Cancelable);
-        let target = self.upcast::<EventTarget>();
-        event.r().fire(target);
+        event.fire(self.upcast());
         if event.r().DefaultPrevented() {
             return;
         }
 
-        let node = self.upcast::<Node>();
-
         // TODO: This is an incorrect way of getting controls owned
         //       by the form, but good enough until html5ever lands
-        for child in node.traverse_preorder() {
+        for child in self.upcast::<Node>().traverse_preorder() {
             match child.r().type_id() {
                 NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLInputElement)) => {
-                    let input = child.downcast::<HTMLInputElement>().unwrap();
-                    input.reset()
+                    child.downcast::<HTMLInputElement>().unwrap().reset();
                 }
                 // TODO HTMLKeygenElement unimplemented
                 //NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLKeygenElement)) => {
@@ -342,8 +336,7 @@ impl HTMLFormElement {
                     {}
                 }
                 NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTextAreaElement)) => {
-                    let textarea = child.downcast::<HTMLTextAreaElement>().unwrap();
-                    textarea.reset()
+                    child.downcast::<HTMLTextAreaElement>().unwrap().reset();
                 }
                 NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLOutputElement)) => {
                     // Unimplemented
@@ -484,13 +477,7 @@ pub trait FormControl: DerivedFrom<Element> + Reflectable {
                 _ => ()
             }
         }
-        let node = elem.upcast::<Node>();
-        for ancestor in node.ancestors() {
-            if let Some(ancestor) = ancestor.downcast::<HTMLFormElement>() {
-                return Some(Root::from_ref(ancestor))
-            }
-        }
-        None
+        elem.upcast::<Node>().ancestors().filter_map(Root::downcast).next()
     }
 
     fn get_form_attribute<InputFn, OwnerFn>(&self,
@@ -509,7 +496,7 @@ pub trait FormControl: DerivedFrom<Element> + Reflectable {
     }
 
     fn to_element(&self) -> &Element {
-        self.upcast::<Element>()
+        self.upcast()
     }
 }
 
diff --git a/components/script/dom/htmlheadelement.rs b/components/script/dom/htmlheadelement.rs
index 7af45e813e4..a2231a17729 100644
--- a/components/script/dom/htmlheadelement.rs
+++ b/components/script/dom/htmlheadelement.rs
@@ -37,8 +37,7 @@ impl HTMLHeadElement {
 
 impl VirtualMethods for HTMLHeadElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
-        Some(htmlelement as &VirtualMethods)
+        Some(self.upcast::<HTMLElement>() as &VirtualMethods)
     }
     fn bind_to_tree(&self, _tree_in_doc: bool) {
         load_script(self);
diff --git a/components/script/dom/htmliframeelement.rs b/components/script/dom/htmliframeelement.rs
index cbe95bc6e24..da119309bef 100644
--- a/components/script/dom/htmliframeelement.rs
+++ b/components/script/dom/htmliframeelement.rs
@@ -15,7 +15,6 @@ use dom::customevent::CustomEvent;
 use dom::document::Document;
 use dom::element::{self, AttributeMutation, Element};
 use dom::event::Event;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::{Node, window_from_node};
 use dom::urlhelper::UrlHelper;
@@ -148,9 +147,7 @@ impl HTMLIFrameElement {
                                                 true,
                                                 true,
                                                 detail.handle());
-            let target = self.upcast::<EventTarget>();
-            let event = custom_event.upcast::<Event>();
-            event.fire(target);
+            custom_event.upcast::<Event>().fire(self.upcast());
         }
     }
 
@@ -161,7 +158,7 @@ impl HTMLIFrameElement {
     #[allow(unsafe_code)]
     pub fn get_width(&self) -> LengthOrPercentageOrAuto {
         unsafe {
-            element::get_attr_for_layout(self.upcast::<Element>(),
+            element::get_attr_for_layout(self.upcast(),
                                          &ns!(""),
                                          &atom!("width")).map(|attribute| {
                 str::parse_length(&**attribute.value_for_layout())
@@ -172,7 +169,7 @@ impl HTMLIFrameElement {
     #[allow(unsafe_code)]
     pub fn get_height(&self) -> LengthOrPercentageOrAuto {
         unsafe {
-            element::get_attr_for_layout(self.upcast::<Element>(),
+            element::get_attr_for_layout(self.upcast(),
                                          &ns!(""),
                                          &atom!("height")).map(|attribute| {
                 str::parse_length(&**attribute.value_for_layout())
@@ -227,8 +224,7 @@ impl HTMLIFrameElementLayoutMethods for LayoutJS<HTMLIFrameElement> {
 
 pub fn Navigate(iframe: &HTMLIFrameElement, direction: NavigationDirection) -> Fallible<()> {
     if iframe.Mozbrowser() {
-        let node = iframe.upcast::<Node>();
-        if node.is_in_doc() {
+        if iframe.upcast::<Node>().is_in_doc() {
             let window = window_from_node(iframe);
             let window = window.r();
 
@@ -249,26 +245,22 @@ pub fn Navigate(iframe: &HTMLIFrameElement, direction: NavigationDirection) -> F
 impl HTMLIFrameElementMethods for HTMLIFrameElement {
     // https://html.spec.whatwg.org/multipage/#dom-iframe-src
     fn Src(&self) -> DOMString {
-        let element = self.upcast::<Element>();
-        element.get_string_attribute(&atom!("src"))
+        self.upcast::<Element>().get_string_attribute(&atom!("src"))
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-iframe-src
     fn SetSrc(&self, src: DOMString) {
-        let element = self.upcast::<Element>();
-        element.set_url_attribute(&atom!("src"), src)
+        self.upcast::<Element>().set_url_attribute(&atom!("src"), src)
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-iframe-sandbox
     fn Sandbox(&self) -> DOMString {
-        let element = self.upcast::<Element>();
-        element.get_string_attribute(&atom!("sandbox"))
+        self.upcast::<Element>().get_string_attribute(&atom!("sandbox"))
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-iframe-sandbox
     fn SetSandbox(&self, sandbox: DOMString) {
-        let element = self.upcast::<Element>();
-        element.set_tokenlist_attribute(&atom!("sandbox"), sandbox);
+        self.upcast::<Element>().set_tokenlist_attribute(&atom!("sandbox"), sandbox);
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-iframe-contentwindow
@@ -360,8 +352,7 @@ impl HTMLIFrameElementMethods for HTMLIFrameElement {
 
 impl VirtualMethods for HTMLIFrameElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
-        Some(htmlelement as &VirtualMethods)
+        Some(self.upcast::<HTMLElement>() as &VirtualMethods)
     }
 
     fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
diff --git a/components/script/dom/htmlimageelement.rs b/components/script/dom/htmlimageelement.rs
index 865a9d05774..25b93621c02 100644
--- a/components/script/dom/htmlimageelement.rs
+++ b/components/script/dom/htmlimageelement.rs
@@ -16,7 +16,6 @@ use dom::bindings::refcounted::Trusted;
 use dom::document::Document;
 use dom::element::{AttributeMutation, Element};
 use dom::event::{Event, EventBubbles, EventCancelable};
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::{Node, NodeDamage, document_from_node, window_from_node};
 use dom::virtualmethods::VirtualMethods;
@@ -74,9 +73,8 @@ impl Runnable for ImageResponseHandlerRunnable {
         };
 
         // Mark the node dirty
-        let node = element.upcast::<Node>();
-        let document = document_from_node(node);
-        document.r().content_changed(node, NodeDamage::OtherNodeDamage);
+        let document = document_from_node(&*element);
+        document.content_changed(element.upcast(), NodeDamage::OtherNodeDamage);
 
         // Fire image.onload
         let window = window_from_node(document.r());
@@ -84,9 +82,7 @@ impl Runnable for ImageResponseHandlerRunnable {
                                "load".to_owned(),
                                EventBubbles::DoesNotBubble,
                                EventCancelable::NotCancelable);
-        let event = event.r();
-        let target = node.upcast::<EventTarget>();
-        event.fire(target);
+        event.fire(element.upcast());
 
         // Trigger reflow
         window.r().add_pending_reflow();
@@ -97,8 +93,7 @@ impl HTMLImageElement {
     /// Makes the local `image` member match the status of the `src` attribute and starts
     /// prefetching the image. This method must be called after `src` is changed.
     fn update_image(&self, value: Option<(DOMString, Url)>) {
-        let node = self.upcast::<Node>();
-        let document = node.owner_doc();
+        let document = document_from_node(self);
         let window = document.r().window();
         let image_cache = window.image_cache_task();
         match value {
@@ -204,8 +199,7 @@ impl HTMLImageElementMethods for HTMLImageElement {
 
     // https://html.spec.whatwg.org/multipage/#dom-img-ismap
     fn SetIsMap(&self, is_map: bool) {
-        let element = self.upcast::<Element>();
-        element.set_string_attribute(&atom!("ismap"), is_map.to_string())
+        self.upcast::<Element>().set_string_attribute(&atom!("ismap"), is_map.to_string())
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-img-width
@@ -217,8 +211,7 @@ impl HTMLImageElementMethods for HTMLImageElement {
 
     // https://html.spec.whatwg.org/multipage/#dom-img-width
     fn SetWidth(&self, width: u32) {
-        let elem = self.upcast::<Element>();
-        elem.set_uint_attribute(&atom!("width"), width)
+        self.upcast::<Element>().set_uint_attribute(&atom!("width"), width)
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-img-height
@@ -230,8 +223,7 @@ impl HTMLImageElementMethods for HTMLImageElement {
 
     // https://html.spec.whatwg.org/multipage/#dom-img-height
     fn SetHeight(&self, height: u32) {
-        let elem = self.upcast::<Element>();
-        elem.set_uint_attribute(&atom!("height"), height)
+        self.upcast::<Element>().set_uint_attribute(&atom!("height"), height)
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-img-naturalwidth
@@ -299,8 +291,7 @@ impl HTMLImageElementMethods for HTMLImageElement {
 
 impl VirtualMethods for HTMLImageElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
-        Some(htmlelement as &VirtualMethods)
+        Some(self.upcast::<HTMLElement>() as &VirtualMethods)
     }
 
     fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
diff --git a/components/script/dom/htmlinputelement.rs b/components/script/dom/htmlinputelement.rs
index a2ad92517c0..b82f96aed63 100644
--- a/components/script/dom/htmlinputelement.rs
+++ b/components/script/dom/htmlinputelement.rs
@@ -353,7 +353,6 @@ fn broadcast_radio_checked(broadcaster: &HTMLInputElement, group: Option<&Atom>)
     //TODO: if not in document, use root ancestor instead of document
     let owner = broadcaster.form_owner();
     let doc = document_from_node(broadcaster);
-    let doc_node = doc.upcast::<Node>();
 
     // This function is a workaround for lifetime constraint difficulties.
     fn do_broadcast(doc_node: &Node, broadcaster: &HTMLInputElement,
@@ -368,7 +367,7 @@ fn broadcast_radio_checked(broadcaster: &HTMLInputElement, group: Option<&Atom>)
         }
     }
 
-    do_broadcast(doc_node, broadcaster, owner.r(), group)
+    do_broadcast(doc.upcast(), broadcaster, owner.r(), group)
 }
 
 // https://html.spec.whatwg.org/multipage/#radio-button-group
@@ -388,8 +387,7 @@ fn in_same_group(other: &HTMLInputElement, owner: Option<&HTMLFormElement>,
 impl HTMLInputElement {
     fn force_relayout(&self) {
         let doc = document_from_node(self);
-        let node = self.upcast::<Node>();
-        doc.r().content_changed(node, NodeDamage::OtherNodeDamage)
+        doc.content_changed(self.upcast(), NodeDamage::OtherNodeDamage)
     }
 
     fn radio_group_updated(&self, group: Option<&Atom>) {
@@ -439,8 +437,8 @@ impl HTMLInputElement {
     // https://html.spec.whatwg.org/multipage/#radio-button-group
     fn get_radio_group_name(&self) -> Option<Atom> {
         //TODO: determine form owner
-        let elem = self.upcast::<Element>();
-        elem.get_attribute(&ns!(""), &atom!("name"))
+        self.upcast::<Element>()
+            .get_attribute(&ns!(""), &atom!("name"))
             .map(|name| name.value().as_atom().clone())
     }
 
@@ -468,8 +466,7 @@ impl HTMLInputElement {
     fn mutable(&self) -> bool {
         // https://html.spec.whatwg.org/multipage/#the-input-element:concept-fe-mutable
         // https://html.spec.whatwg.org/multipage/#the-readonly-attribute:concept-fe-mutable
-        let el = self.upcast::<Element>();
-        !(el.get_disabled_state() || self.ReadOnly())
+        !(self.upcast::<Element>().get_disabled_state() || self.ReadOnly())
     }
 
     // https://html.spec.whatwg.org/multipage/#the-input-element:concept-form-reset-control
@@ -491,8 +488,7 @@ impl HTMLInputElement {
 
 impl VirtualMethods for HTMLInputElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
-        Some(htmlelement as &VirtualMethods)
+        Some(self.upcast::<HTMLElement>() as &VirtualMethods)
     }
 
     fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
@@ -592,8 +588,7 @@ impl VirtualMethods for HTMLInputElement {
             s.bind_to_tree(tree_in_doc);
         }
 
-        let el = self.upcast::<Element>();
-        el.check_ancestors_disabled_state_for_form_control();
+        self.upcast::<Element>().check_ancestors_disabled_state_for_form_control();
     }
 
     fn unbind_from_tree(&self, tree_in_doc: bool) {
@@ -626,13 +621,11 @@ impl VirtualMethods for HTMLInputElement {
 
             //TODO: set the editing position for text inputs
 
-            let doc = document_from_node(self);
-            doc.r().request_focus(self.upcast::<Element>());
+            document_from_node(self).request_focus(self.upcast());
         } else if &*event.Type() == "keydown" && !event.DefaultPrevented() &&
             (self.input_type.get() == InputType::InputText ||
              self.input_type.get() == InputType::InputPassword) {
-                let keyevent: Option<&KeyboardEvent> = event.downcast::<KeyboardEvent>();
-                keyevent.map(|keyevent| {
+                if let Some(keyevent) = event.downcast::<KeyboardEvent>() {
                     // This can't be inlined, as holding on to textinput.borrow_mut()
                     // during self.implicit_submission will cause a panic.
                     let action = self.textinput.borrow_mut().handle_keydown(keyevent);
@@ -653,7 +646,7 @@ impl VirtualMethods for HTMLInputElement {
                         }
                         Nothing => (),
                     }
-                });
+                }
         }
     }
 }
@@ -662,7 +655,7 @@ impl FormControl for HTMLInputElement {}
 
 impl Activatable for HTMLInputElement {
     fn as_element(&self) -> &Element {
-        self.upcast::<Element>()
+        self.upcast()
     }
 
     fn is_instance_activatable(&self) -> bool {
@@ -809,19 +802,19 @@ impl Activatable for HTMLInputElement {
                 // https://html.spec.whatwg.org/multipage/#radio-button-state-(type=radio):activation-behavior
                 if self.mutable() {
                     let win = window_from_node(self);
+                    let target = self.upcast();
+
                     let event = Event::new(GlobalRef::Window(win.r()),
                                            "input".to_owned(),
                                            EventBubbles::Bubbles,
                                            EventCancelable::NotCancelable);
-                    let target = self.upcast::<EventTarget>();
-                    event.r().fire(target);
+                    event.fire(target);
 
                     let event = Event::new(GlobalRef::Window(win.r()),
                                            "change".to_owned(),
                                            EventBubbles::Bubbles,
                                            EventCancelable::NotCancelable);
-                    let target = self.upcast::<EventTarget>();
-                    event.r().fire(target);
+                    event.fire(target);
                 }
             },
             _ => ()
@@ -839,8 +832,7 @@ impl Activatable for HTMLInputElement {
             Some(ref f) => f
         };
 
-        let elem = self.upcast::<Element>();
-        if elem.click_in_progress() {
+        if self.upcast::<Element>().click_in_progress() {
             return;
         }
         let submit_button;
diff --git a/components/script/dom/htmllinkelement.rs b/components/script/dom/htmllinkelement.rs
index f317eec0001..fc7a1818c00 100644
--- a/components/script/dom/htmllinkelement.rs
+++ b/components/script/dom/htmllinkelement.rs
@@ -89,8 +89,7 @@ fn is_favicon(value: &Option<String>) -> bool {
 
 impl VirtualMethods for HTMLLinkElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
-        Some(htmlelement as &VirtualMethods)
+        Some(self.upcast::<HTMLElement>() as &VirtualMethods)
     }
 
     fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
@@ -98,7 +97,7 @@ impl VirtualMethods for HTMLLinkElement {
         if !self.upcast::<Node>().is_in_doc() || mutation == AttributeMutation::Removed {
             return;
         }
-        let rel = get_attr(self.upcast::<Element>(), &atom!(rel));
+        let rel = get_attr(self.upcast(), &atom!(rel));
         match attr.local_name() {
             &atom!(href) => {
                 if is_stylesheet(&rel) {
@@ -129,7 +128,7 @@ impl VirtualMethods for HTMLLinkElement {
         }
 
         if tree_in_doc {
-            let element = self.upcast::<Element>();
+            let element = self.upcast();
 
             let rel = get_attr(element, &atom!("rel"));
             let href = get_attr(element, &atom!("href"));
@@ -224,9 +223,7 @@ impl HTMLLinkElementMethods for HTMLLinkElement {
 
     // https://html.spec.whatwg.org/multipage/#dom-link-rellist
     fn RelList(&self) -> Root<DOMTokenList> {
-        self.rel_list.or_init(|| {
-            DOMTokenList::new(self.upcast::<Element>(), &atom!("rel"))
-        })
+        self.rel_list.or_init(|| DOMTokenList::new(self.upcast(), &atom!("rel")))
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-link-charset
@@ -267,7 +264,6 @@ impl StylesheetLoadResponder for StylesheetLoadDispatcher {
         let event = Event::new(GlobalRef::Window(window.r()), "load".to_owned(),
                                EventBubbles::DoesNotBubble,
                                EventCancelable::NotCancelable);
-        let target = elem.upcast::<EventTarget>();
-        event.r().fire(target);
+        event.fire(elem.upcast::<EventTarget>());
     }
 }
diff --git a/components/script/dom/htmlmetaelement.rs b/components/script/dom/htmlmetaelement.rs
index e1194376f31..0b0fcd4e4c8 100644
--- a/components/script/dom/htmlmetaelement.rs
+++ b/components/script/dom/htmlmetaelement.rs
@@ -57,8 +57,7 @@ impl HTMLMetaElement {
             let content = content.value();
             if !content.is_empty() {
                 if let Some(translated_rule) = ViewportRule::from_meta(&**content) {
-                    let node = self.upcast::<Node>();
-                    let win = window_from_node(node);
+                    let win = window_from_node(self);
                     let LayoutChan(ref layout_chan) = win.r().layout_chan();
 
                     layout_chan.send(Msg::AddMetaViewport(translated_rule)).unwrap();
@@ -84,8 +83,7 @@ impl HTMLMetaElementMethods for HTMLMetaElement {
 
 impl VirtualMethods for HTMLMetaElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
-        Some(htmlelement as &VirtualMethods)
+        Some(self.upcast::<HTMLElement>() as &VirtualMethods)
     }
 
     fn bind_to_tree(&self, tree_in_doc: bool) {
diff --git a/components/script/dom/htmlobjectelement.rs b/components/script/dom/htmlobjectelement.rs
index 3e11c832514..49a16688854 100644
--- a/components/script/dom/htmlobjectelement.rs
+++ b/components/script/dom/htmlobjectelement.rs
@@ -92,8 +92,7 @@ impl HTMLObjectElementMethods for HTMLObjectElement {
 
 impl VirtualMethods for HTMLObjectElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
-        Some(htmlelement as &VirtualMethods)
+        Some(self.upcast::<HTMLElement>() as &VirtualMethods)
     }
 
     fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
diff --git a/components/script/dom/htmloptgroupelement.rs b/components/script/dom/htmloptgroupelement.rs
index f1c011325bf..4d9ec9b6ca9 100644
--- a/components/script/dom/htmloptgroupelement.rs
+++ b/components/script/dom/htmloptgroupelement.rs
@@ -50,8 +50,7 @@ impl HTMLOptGroupElementMethods for HTMLOptGroupElement {
 
 impl VirtualMethods for HTMLOptGroupElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
-        Some(htmlelement as &VirtualMethods)
+        Some(self.upcast::<HTMLElement>() as &VirtualMethods)
     }
 
     fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
diff --git a/components/script/dom/htmloptionelement.rs b/components/script/dom/htmloptionelement.rs
index d60ae457203..60af71b6c2e 100644
--- a/components/script/dom/htmloptionelement.rs
+++ b/components/script/dom/htmloptionelement.rs
@@ -64,7 +64,7 @@ fn collect_text(element: &Element, value: &mut DOMString) {
         if child.is::<Text>() {
             let characterdata = child.downcast::<CharacterData>().unwrap();
             value.push_str(&characterdata.Data());
-        } else if let Some(element_child) = child.downcast::<Element>() {
+        } else if let Some(element_child) = child.downcast() {
             collect_text(element_child, value);
         }
     }
@@ -76,22 +76,19 @@ impl HTMLOptionElementMethods for HTMLOptionElement {
 
     // https://html.spec.whatwg.org/multipage/#dom-option-disabled
     fn SetDisabled(&self, disabled: bool) {
-        let elem = self.upcast::<Element>();
-        elem.set_bool_attribute(&atom!("disabled"), disabled)
+        self.upcast::<Element>().set_bool_attribute(&atom!("disabled"), disabled)
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-option-text
     fn Text(&self) -> DOMString {
-        let element = self.upcast::<Element>();
         let mut content = String::new();
-        collect_text(element, &mut content);
+        collect_text(self.upcast(), &mut content);
         str_join(split_html_space_chars(&content), " ")
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-option-text
     fn SetText(&self, value: DOMString) {
-        let node = self.upcast::<Node>();
-        node.SetTextContent(Some(value))
+        self.upcast::<Node>().SetTextContent(Some(value))
     }
 
     // https://html.spec.whatwg.org/multipage/#attr-option-value
@@ -144,8 +141,7 @@ impl HTMLOptionElementMethods for HTMLOptionElement {
 
 impl VirtualMethods for HTMLOptionElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
-        Some(htmlelement as &VirtualMethods)
+        Some(self.upcast::<HTMLElement>() as &VirtualMethods)
     }
 
     fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
@@ -190,8 +186,7 @@ impl VirtualMethods for HTMLOptionElement {
             s.bind_to_tree(tree_in_doc);
         }
 
-        let el = self.upcast::<Element>();
-        el.check_parent_disabled_state_for_option();
+        self.upcast::<Element>().check_parent_disabled_state_for_option();
     }
 
     fn unbind_from_tree(&self, tree_in_doc: bool) {
diff --git a/components/script/dom/htmlscriptelement.rs b/components/script/dom/htmlscriptelement.rs
index 7ae38f951bb..a32b481d252 100644
--- a/components/script/dom/htmlscriptelement.rs
+++ b/components/script/dom/htmlscriptelement.rs
@@ -19,7 +19,6 @@ use dom::bindings::trace::JSTraceable;
 use dom::document::Document;
 use dom::element::{AttributeMutation, Element, ElementCreator};
 use dom::event::{Event, EventBubbles, EventCancelable};
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::{ChildrenMutation, CloneChildrenFlag, Node};
 use dom::node::{document_from_node, window_from_node};
@@ -190,8 +189,7 @@ impl HTMLScriptElement {
             return NextParserState::Continue;
         }
         // Step 5.
-        let node = self.upcast::<Node>();
-        if !node.is_in_doc() {
+        if !self.upcast::<Node>().is_in_doc() {
             return NextParserState::Continue;
         }
         // Step 6, 7.
@@ -507,16 +505,13 @@ impl HTMLScriptElement {
                                type_,
                                bubbles,
                                cancelable);
-        let event = event.r();
-        let target = self.upcast::<EventTarget>();
-        event.fire(target)
+        event.fire(self.upcast())
     }
 }
 
 impl VirtualMethods for HTMLScriptElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
-        Some(htmlelement as &VirtualMethods)
+        Some(self.upcast::<HTMLElement>() as &VirtualMethods)
     }
 
     fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
@@ -537,8 +532,7 @@ impl VirtualMethods for HTMLScriptElement {
         if let Some(ref s) = self.super_type() {
             s.children_changed(mutation);
         }
-        let node = self.upcast::<Node>();
-        if !self.parser_inserted.get() && node.is_in_doc() {
+        if !self.parser_inserted.get() && self.upcast::<Node>().is_in_doc() {
             self.prepare();
         }
     }
@@ -561,8 +555,7 @@ impl VirtualMethods for HTMLScriptElement {
 
         // https://html.spec.whatwg.org/multipage/#already-started
         if self.already_started.get() {
-            let copy_elem = copy.downcast::<HTMLScriptElement>().unwrap();
-            copy_elem.mark_already_started();
+            copy.downcast::<HTMLScriptElement>().unwrap().mark_already_started();
         }
     }
 }
@@ -580,8 +573,7 @@ impl HTMLScriptElementMethods for HTMLScriptElement {
 
     // https://html.spec.whatwg.org/multipage/#dom-script-text
     fn SetText(&self, value: DOMString) {
-        let node = self.upcast::<Node>();
-        node.SetTextContent(Some(value))
+        self.upcast::<Node>().SetTextContent(Some(value))
     }
 }
 
diff --git a/components/script/dom/htmlselectelement.rs b/components/script/dom/htmlselectelement.rs
index 238d6a6f1de..f82eddf39fe 100644
--- a/components/script/dom/htmlselectelement.rs
+++ b/components/script/dom/htmlselectelement.rs
@@ -101,8 +101,7 @@ impl HTMLSelectElementMethods for HTMLSelectElement {
 
 impl VirtualMethods for HTMLSelectElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
-        Some(htmlelement as &VirtualMethods)
+        Some(self.upcast::<HTMLElement>() as &VirtualMethods)
     }
 
     fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
@@ -128,8 +127,7 @@ impl VirtualMethods for HTMLSelectElement {
             s.bind_to_tree(tree_in_doc);
         }
 
-        let el = self.upcast::<Element>();
-        el.check_ancestors_disabled_state_for_form_control();
+        self.upcast::<Element>().check_ancestors_disabled_state_for_form_control();
     }
 
     fn unbind_from_tree(&self, tree_in_doc: bool) {
diff --git a/components/script/dom/htmlstyleelement.rs b/components/script/dom/htmlstyleelement.rs
index 695e250b5c6..f33eb938f4e 100644
--- a/components/script/dom/htmlstyleelement.rs
+++ b/components/script/dom/htmlstyleelement.rs
@@ -65,16 +65,14 @@ impl HTMLStyleElement {
 
 impl VirtualMethods for HTMLStyleElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
-        Some(htmlelement as &VirtualMethods)
+        Some(self.upcast::<HTMLElement>() as &VirtualMethods)
     }
 
     fn children_changed(&self, mutation: &ChildrenMutation) {
         if let Some(ref s) = self.super_type() {
             s.children_changed(mutation);
         }
-        let node = self.upcast::<Node>();
-        if node.is_in_doc() {
+        if self.upcast::<Node>().is_in_doc() {
             self.parse_own_css();
         }
     }
diff --git a/components/script/dom/htmltablecellelement.rs b/components/script/dom/htmltablecellelement.rs
index 2cb325d4912..3f1b13633f2 100644
--- a/components/script/dom/htmltablecellelement.rs
+++ b/components/script/dom/htmltablecellelement.rs
@@ -102,8 +102,7 @@ impl HTMLTableCellElementLayoutHelpers for LayoutJS<HTMLTableCellElement> {
 
 impl VirtualMethods for HTMLTableCellElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
-        Some(htmlelement as &VirtualMethods)
+        Some(self.upcast::<HTMLElement>() as &VirtualMethods)
     }
 
     fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
diff --git a/components/script/dom/htmltableelement.rs b/components/script/dom/htmltableelement.rs
index bf22ffa429c..ddd87314587 100644
--- a/components/script/dom/htmltableelement.rs
+++ b/components/script/dom/htmltableelement.rs
@@ -52,25 +52,19 @@ impl HTMLTableElement {
 impl HTMLTableElementMethods for HTMLTableElement {
     // https://html.spec.whatwg.org/multipage/#dom-table-caption
     fn GetCaption(&self) -> Option<Root<HTMLTableCaptionElement>> {
-        let node = self.upcast::<Node>();
-        node.children()
-            .filter_map(|c| {
-                c.downcast::<HTMLTableCaptionElement>().map(Root::from_ref)
-            })
-            .next()
+        self.upcast::<Node>().children().filter_map(Root::downcast).next()
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-table-caption
     fn SetCaption(&self, new_caption: Option<&HTMLTableCaptionElement>) {
-        let node = self.upcast::<Node>();
-
         if let Some(ref caption) = self.GetCaption() {
             caption.upcast::<Node>().remove_self();
         }
 
         if let Some(caption) = new_caption {
-            assert!(node.InsertBefore(caption.upcast::<Node>(),
-                                      node.GetFirstChild().as_ref().map(|n| n.r())).is_ok());
+            let node = self.upcast::<Node>();
+            node.InsertBefore(caption.upcast(), node.GetFirstChild().r())
+                .expect("Insertion failed");
         }
     }
 
@@ -86,7 +80,7 @@ impl HTMLTableElementMethods for HTMLTableElement {
                 caption
             }
         };
-        Root::upcast::<HTMLElement>(caption)
+        Root::upcast(caption)
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-table-deletecaption
@@ -107,10 +101,10 @@ impl HTMLTableElementMethods for HTMLTableElement {
                 .filter_map(Root::downcast::<Element>)
                 .find(|n| n.is::<HTMLTableSectionElement>() && n.local_name() == &atom!("tbody"));
         let reference_element =
-            last_tbody.and_then(|t| Root::upcast::<Node>(t).GetNextSibling());
+            last_tbody.and_then(|t| t.upcast::<Node>().GetNextSibling());
 
-        assert!(node.InsertBefore(tbody.upcast::<Node>(),
-                                  reference_element.r()).is_ok());
+        node.InsertBefore(tbody.upcast(), reference_element.r())
+            .expect("Insertion failed");
         tbody
     }
 
@@ -142,8 +136,7 @@ impl HTMLTableElement {
 
 impl VirtualMethods for HTMLTableElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
-        Some(htmlelement as &VirtualMethods)
+        Some(self.upcast::<HTMLElement>() as &VirtualMethods)
     }
 
     fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
diff --git a/components/script/dom/htmltablerowelement.rs b/components/script/dom/htmltablerowelement.rs
index 66f3e424414..8db70bd9d2a 100644
--- a/components/script/dom/htmltablerowelement.rs
+++ b/components/script/dom/htmltablerowelement.rs
@@ -72,7 +72,7 @@ impl HTMLTableRowElementMethods for HTMLTableRowElement {
         self.cells.or_init(|| {
             let window = window_from_node(self);
             let filter = box CellsFilter;
-            HTMLCollection::create(window.r(), self.upcast::<Node>(), filter)
+            HTMLCollection::create(window.r(), self.upcast(), filter)
         })
     }
 
@@ -97,8 +97,7 @@ impl HTMLTableRowElementMethods for HTMLTableRowElement {
 
 impl VirtualMethods for HTMLTableRowElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
-        Some(htmlelement as &VirtualMethods)
+        Some(self.upcast::<HTMLElement>() as &VirtualMethods)
     }
 
     fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
diff --git a/components/script/dom/htmltablesectionelement.rs b/components/script/dom/htmltablesectionelement.rs
index b5aa3d9f675..5c6f04ef0ec 100644
--- a/components/script/dom/htmltablesectionelement.rs
+++ b/components/script/dom/htmltablesectionelement.rs
@@ -58,7 +58,7 @@ impl CollectionFilter for RowsFilter {
 impl HTMLTableSectionElementMethods for HTMLTableSectionElement {
     // https://html.spec.whatwg.org/multipage/#dom-tbody-rows
     fn Rows(&self) -> Root<HTMLCollection> {
-        HTMLCollection::create(&window_from_node(self), self.upcast::<Node>(), box RowsFilter)
+        HTMLCollection::create(&window_from_node(self), self.upcast(), box RowsFilter)
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-tbody-insertrow
@@ -82,8 +82,7 @@ impl HTMLTableSectionElementMethods for HTMLTableSectionElement {
 
 impl VirtualMethods for HTMLTableSectionElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
-        Some(htmlelement as &VirtualMethods)
+        Some(self.upcast::<HTMLElement>() as &VirtualMethods)
     }
 
     fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
diff --git a/components/script/dom/htmltemplateelement.rs b/components/script/dom/htmltemplateelement.rs
index 36090dfbe0a..cd2f7393614 100644
--- a/components/script/dom/htmltemplateelement.rs
+++ b/components/script/dom/htmltemplateelement.rs
@@ -64,7 +64,7 @@ impl VirtualMethods for HTMLTemplateElement {
         // Step 1.
         let doc = document_from_node(self).appropriate_template_contents_owner_document();
         // Step 2.
-        Node::adopt(self.Content().upcast::<Node>(), &doc);
+        Node::adopt(self.Content().upcast(), &doc);
     }
 
     /// https://html.spec.whatwg.org/multipage/#the-template-element:concept-node-clone-ext
@@ -79,7 +79,7 @@ impl VirtualMethods for HTMLTemplateElement {
         // Steps 2-3.
         let copy_contents = Root::upcast::<Node>(copy.Content());
         let copy_contents_doc = copy_contents.owner_doc();
-        for child in Root::upcast::<Node>(self.Content()).children() {
+        for child in self.Content().upcast::<Node>().children() {
             let copy_child = Node::clone(
                 &child, Some(&copy_contents_doc), CloneChildrenFlag::CloneChildren);
             copy_contents.AppendChild(&copy_child).unwrap();
diff --git a/components/script/dom/htmltextareaelement.rs b/components/script/dom/htmltextareaelement.rs
index a051d1d3245..d802760a308 100644
--- a/components/script/dom/htmltextareaelement.rs
+++ b/components/script/dom/htmltextareaelement.rs
@@ -169,14 +169,12 @@ impl HTMLTextAreaElementMethods for HTMLTextAreaElement {
 
     // https://html.spec.whatwg.org/multipage/#dom-textarea-defaultvalue
     fn DefaultValue(&self) -> DOMString {
-        let node = self.upcast::<Node>();
-        node.GetTextContent().unwrap()
+        self.upcast::<Node>().GetTextContent().unwrap()
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-textarea-defaultvalue
     fn SetDefaultValue(&self, value: DOMString) {
-        let node = self.upcast::<Node>();
-        node.SetTextContent(Some(value));
+        self.upcast::<Node>().SetTextContent(Some(value));
 
         // if the element's dirty value flag is false, then the element's
         // raw value must be set to the value of the element's textContent IDL attribute
@@ -218,8 +216,7 @@ impl HTMLTextAreaElement {
 impl HTMLTextAreaElement {
     fn force_relayout(&self) {
         let doc = document_from_node(self);
-        let node = self.upcast::<Node>();
-        doc.r().content_changed(node, NodeDamage::OtherNodeDamage)
+        doc.content_changed(self.upcast(), NodeDamage::OtherNodeDamage)
     }
 
     fn dispatch_change_event(&self) {
@@ -230,15 +227,13 @@ impl HTMLTextAreaElement {
                                EventBubbles::DoesNotBubble,
                                EventCancelable::NotCancelable);
 
-        let target = self.upcast::<EventTarget>();
-        target.dispatch_event(event.r());
+        self.upcast::<EventTarget>().dispatch_event(&event);
     }
 }
 
 impl VirtualMethods for HTMLTextAreaElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
-        Some(htmlelement as &VirtualMethods)
+        Some(self.upcast::<HTMLElement>() as &VirtualMethods)
     }
 
     fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
@@ -279,8 +274,7 @@ impl VirtualMethods for HTMLTextAreaElement {
             s.bind_to_tree(tree_in_doc);
         }
 
-        let el = self.upcast::<Element>();
-        el.check_ancestors_disabled_state_for_form_control();
+        self.upcast::<Element>().check_ancestors_disabled_state_for_form_control();
     }
 
     fn parse_plain_attribute(&self, name: &Atom, value: DOMString) -> AttrValue {
@@ -298,7 +292,7 @@ impl VirtualMethods for HTMLTextAreaElement {
 
         let node = self.upcast::<Node>();
         let el = self.upcast::<Element>();
-        if node.ancestors().any(|ancestor| ancestor.r().is::<HTMLFieldSetElement>()) {
+        if node.ancestors().any(|ancestor| ancestor.is::<HTMLFieldSetElement>()) {
             el.check_ancestors_disabled_state_for_form_control();
         } else {
             el.check_disabled_attribute();
@@ -323,11 +317,9 @@ impl VirtualMethods for HTMLTextAreaElement {
         if &*event.Type() == "click" && !event.DefaultPrevented() {
             //TODO: set the editing position for text inputs
 
-            let doc = document_from_node(self);
-            doc.r().request_focus(self.upcast::<Element>());
+            document_from_node(self).request_focus(self.upcast());
         } else if &*event.Type() == "keydown" && !event.DefaultPrevented() {
-            let keyevent: Option<&KeyboardEvent> = event.downcast::<KeyboardEvent>();
-            keyevent.map(|kevent| {
+            if let Some(kevent) = event.downcast::<KeyboardEvent>() {
                 match self.textinput.borrow_mut().handle_keydown(kevent) {
                     KeyReaction::TriggerDefaultAction => (),
                     KeyReaction::DispatchInput => {
@@ -351,7 +343,7 @@ impl VirtualMethods for HTMLTextAreaElement {
                     }
                     KeyReaction::Nothing => (),
                 }
-            });
+            }
         }
     }
 }
diff --git a/components/script/dom/htmltitleelement.rs b/components/script/dom/htmltitleelement.rs
index 8a5f90ff14e..cb22a7bd9c2 100644
--- a/components/script/dom/htmltitleelement.rs
+++ b/components/script/dom/htmltitleelement.rs
@@ -39,13 +39,10 @@ impl HTMLTitleElement {
 impl HTMLTitleElementMethods for HTMLTitleElement {
     // https://html.spec.whatwg.org/multipage/#dom-title-text
     fn Text(&self) -> DOMString {
-        let node = self.upcast::<Node>();
         let mut content = String::new();
-        for child in node.children() {
-            let text: Option<&Text> = child.downcast::<Text>();
-            match text {
-                Some(text) => content.push_str(&text.upcast::<CharacterData>().data()),
-                None => (),
+        for child in self.upcast::<Node>().children() {
+            if let Some(text) = child.downcast::<Text>() {
+                content.push_str(&text.upcast::<CharacterData>().data());
             }
         }
         content
@@ -53,15 +50,13 @@ impl HTMLTitleElementMethods for HTMLTitleElement {
 
     // https://html.spec.whatwg.org/multipage/#dom-title-text
     fn SetText(&self, value: DOMString) {
-        let node = self.upcast::<Node>();
-        node.SetTextContent(Some(value))
+        self.upcast::<Node>().SetTextContent(Some(value))
     }
 }
 
 impl VirtualMethods for HTMLTitleElement {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let htmlelement: &HTMLElement = self.upcast::<HTMLElement>();
-        Some(htmlelement as &VirtualMethods)
+        Some(self.upcast::<HTMLElement>() as &VirtualMethods)
     }
 
     fn children_changed(&self, mutation: &ChildrenMutation) {
diff --git a/components/script/dom/keyboardevent.rs b/components/script/dom/keyboardevent.rs
index e877ea95fbc..e3d2bf4f657 100644
--- a/components/script/dom/keyboardevent.rs
+++ b/components/script/dom/keyboardevent.rs
@@ -762,13 +762,12 @@ impl KeyboardEventMethods for KeyboardEvent {
                          _modifiersListArg: DOMString,
                          repeat: bool,
                          _locale: DOMString) {
-        let event = self.upcast::<Event>();
-        if event.dispatching() {
+        if self.upcast::<Event>().dispatching() {
             return;
         }
 
-        let uievent = self.upcast::<UIEvent>();
-        uievent.InitUIEvent(typeArg, canBubbleArg, cancelableArg, viewArg, 0);
+        self.upcast::<UIEvent>()
+            .InitUIEvent(typeArg, canBubbleArg, cancelableArg, viewArg, 0);
         *self.key_string.borrow_mut() = keyArg;
         self.location.set(locationArg);
         self.repeat.set(repeat);
diff --git a/components/script/dom/messageevent.rs b/components/script/dom/messageevent.rs
index 88ff10e4a55..4af83b3af7d 100644
--- a/components/script/dom/messageevent.rs
+++ b/components/script/dom/messageevent.rs
@@ -78,8 +78,7 @@ impl MessageEvent {
         let messageevent = MessageEvent::new(
             scope, "message".to_owned(), false, false, message,
             "".to_owned(), "".to_owned());
-        let event = messageevent.upcast::<Event>();
-        event.fire(target);
+        messageevent.upcast::<Event>().fire(target);
     }
 }
 
diff --git a/components/script/dom/mod.rs b/components/script/dom/mod.rs
index 6ae697ab19d..a61ddd76c2c 100644
--- a/components/script/dom/mod.rs
+++ b/components/script/dom/mod.rs
@@ -151,8 +151,8 @@
 //! # use script::dom::node::Node;
 //! # use script::dom::htmlelement::HTMLElement;
 //! fn f(element: &Element) {
-//!     let base: &Node = element.upcast::<Node>();
-//!     let derived: Option<&HTMLElement> = element.downcast::<HTMLElement>();
+//!     let base = element.upcast::<Node>();
+//!     let derived = element.downcast::<HTMLElement>();
 //! }
 //! ```
 //!
diff --git a/components/script/dom/mouseevent.rs b/components/script/dom/mouseevent.rs
index 63c4e5ba8bd..a81d54f0b9b 100644
--- a/components/script/dom/mouseevent.rs
+++ b/components/script/dom/mouseevent.rs
@@ -189,13 +189,12 @@ impl MouseEventMethods for MouseEvent {
                       metaKeyArg: bool,
                       buttonArg: i16,
                       relatedTargetArg: Option<&EventTarget>) {
-        let event: &Event = self.upcast::<Event>();
-        if event.dispatching() {
+        if self.upcast::<Event>().dispatching() {
             return;
         }
 
-        let uievent: &UIEvent = self.upcast::<UIEvent>();
-        uievent.InitUIEvent(typeArg, canBubbleArg, cancelableArg, viewArg, detailArg);
+        self.upcast::<UIEvent>()
+            .InitUIEvent(typeArg, canBubbleArg, cancelableArg, viewArg, detailArg);
         self.screen_x.set(screenXArg);
         self.screen_y.set(screenYArg);
         self.client_x.set(clientXArg);
diff --git a/components/script/dom/node.rs b/components/script/dom/node.rs
index 92389b127aa..1eb4240f307 100644
--- a/components/script/dom/node.rs
+++ b/components/script/dom/node.rs
@@ -355,9 +355,9 @@ impl<'a> Iterator for QuerySelectorIterator {
         // TODO(cgaebel): Is it worth it to build a bloom filter here
         // (instead of passing `None`)? Probably.
         self.iterator.by_ref().filter_map(|node| {
-            if let Some(element) = Root::downcast::<Element>(node) {
+            if let Some(element) = Root::downcast(node) {
                 if matches(selectors, &element, None) {
-                    return Some(Root::upcast::<Node>(element))
+                    return Some(Root::upcast(element));
                 }
             }
             None
@@ -718,7 +718,7 @@ impl Node {
             Err(()) => Err(Error::Syntax),
             // Step 3.
             Ok(ref selectors) => {
-                Ok(self.traverse_preorder().filter_map(Root::downcast::<Element>).find(|element| {
+                Ok(self.traverse_preorder().filter_map(Root::downcast).find(|element| {
                     matches(selectors, element, None)
                 }))
             }
@@ -787,12 +787,7 @@ impl Node {
     }
 
     pub fn child_elements(&self) -> ChildElementIterator {
-        fn to_temporary(node: Root<Node>) -> Option<Root<Element>> {
-            Root::downcast::<Element>(node)
-        }
-        self.children()
-            .filter_map(to_temporary as fn(_) -> _)
-            .peekable()
+        self.children().filter_map(Root::downcast as fn(_) -> _).peekable()
     }
 
     pub fn remove_self(&self) {
@@ -823,18 +818,10 @@ impl Node {
             name: "".to_owned(),
             publicId: "".to_owned(),
             systemId: "".to_owned(),
-
-            attrs: {
-                let e: Option<&Element> = self.downcast::<Element>();
-                match e {
-                    Some(element) => element.summarize(),
-                    None => vec!(),
-                }
-            },
+            attrs: self.downcast().map(Element::summarize).unwrap_or(vec![]),
 
             isDocumentElement:
                 self.owner_doc()
-                    .r()
                     .GetDocumentElement()
                     .map(|elem| elem.upcast::<Node>() == self)
                     .unwrap_or(false),
@@ -846,12 +833,10 @@ impl Node {
 
     // https://dvcs.w3.org/hg/innerhtml/raw-file/tip/index.html#dfn-concept-parse-fragment
     pub fn parse_fragment(&self, markup: DOMString) -> Fallible<Root<DocumentFragment>> {
-        let context_node: &Node = self.upcast::<Node>();
         let context_document = document_from_node(self);
         let fragment = DocumentFragment::new(context_document.r());
         if context_document.r().is_html_document() {
-            let fragment_node = fragment.upcast::<Node>();
-            parse_html_fragment(context_node, markup, fragment_node);
+            parse_html_fragment(self.upcast(), markup, fragment.upcast());
         } else {
             // FIXME: XML case
             unimplemented!();
@@ -1619,7 +1604,7 @@ impl Node {
         // XXXabinader: clone() for each node as trait?
         let copy: Root<Node> = match node.type_id() {
             NodeTypeId::DocumentType => {
-                let doctype: &DocumentType = node.downcast::<DocumentType>().unwrap();
+                let doctype = node.downcast::<DocumentType>().unwrap();
                 let doctype = DocumentType::new(doctype.name().clone(),
                                                 Some(doctype.public_id().clone()),
                                                 Some(doctype.system_id().clone()), document.r());
@@ -1720,8 +1705,7 @@ impl Node {
     pub fn collect_text_contents<T: Iterator<Item=Root<Node>>>(iterator: T) -> String {
         let mut content = String::new();
         for node in iterator {
-            let text = node.downcast::<Text>();
-            match text {
+            match node.downcast::<Text>() {
                 Some(text) => content.push_str(&text.upcast::<CharacterData>().Data()),
                 None => (),
             }
@@ -1778,7 +1762,7 @@ impl Node {
                     // Step 3.
                     None => ns!(""),
                     // Step 4.
-                    Some(parent) => Node::locate_namespace(parent.upcast::<Node>(), prefix)
+                    Some(parent) => Node::locate_namespace(parent.upcast(), prefix)
                 }
             },
             NodeTypeId::Document => {
@@ -1787,7 +1771,7 @@ impl Node {
                     None => ns!(""),
                     // Step 2.
                     Some(document_element) => {
-                        Node::locate_namespace(document_element.upcast::<Node>(), prefix)
+                        Node::locate_namespace(document_element.upcast(), prefix)
                     }
                 }
             },
@@ -1797,7 +1781,7 @@ impl Node {
                      // Step 1.
                      None => ns!(""),
                      // Step 2.
-                     Some(parent) => Node::locate_namespace(parent.upcast::<Node>(), prefix)
+                     Some(parent) => Node::locate_namespace(parent.upcast(), prefix)
                  }
         }
     }
@@ -1828,19 +1812,15 @@ impl NodeMethods for Node {
     fn NodeName(&self) -> DOMString {
         match self.type_id() {
             NodeTypeId::Element(..) => {
-                let elem: &Element = self.downcast::<Element>().unwrap();
-                elem.TagName()
+                self.downcast::<Element>().unwrap().TagName()
             }
             NodeTypeId::CharacterData(CharacterDataTypeId::Text) => "#text".to_owned(),
             NodeTypeId::CharacterData(CharacterDataTypeId::ProcessingInstruction) => {
-                let processing_instruction: &ProcessingInstruction =
-                    self.downcast::<ProcessingInstruction>().unwrap();
-                processing_instruction.Target()
+                self.downcast::<ProcessingInstruction>().unwrap().Target()
             }
             NodeTypeId::CharacterData(CharacterDataTypeId::Comment) => "#comment".to_owned(),
             NodeTypeId::DocumentType => {
-                let doctype: &DocumentType = self.downcast::<DocumentType>().unwrap();
-                doctype.name().clone()
+                self.downcast::<DocumentType>().unwrap().name().clone()
             },
             NodeTypeId::DocumentFragment => "#document-fragment".to_owned(),
             NodeTypeId::Document => "#document".to_owned()
@@ -1870,7 +1850,7 @@ impl NodeMethods for Node {
 
     // https://dom.spec.whatwg.org/#dom-node-parentelement
     fn GetParentElement(&self) -> Option<Root<Element>> {
-        self.GetParentNode().and_then(Root::downcast::<Element>)
+        self.GetParentNode().and_then(Root::downcast)
     }
 
     // https://dom.spec.whatwg.org/#dom-node-haschildnodes
@@ -1911,7 +1891,7 @@ impl NodeMethods for Node {
     fn GetNodeValue(&self) -> Option<DOMString> {
         match self.type_id() {
             NodeTypeId::CharacterData(..) => {
-                let chardata: &CharacterData = self.downcast::<CharacterData>().unwrap();
+                let chardata = self.downcast::<CharacterData>().unwrap();
                 Some(chardata.Data())
             }
             _ => {
@@ -1939,7 +1919,7 @@ impl NodeMethods for Node {
                 Some(content)
             }
             NodeTypeId::CharacterData(..) => {
-                let characterdata: &CharacterData = self.downcast::<CharacterData>().unwrap();
+                let characterdata = self.downcast::<CharacterData>().unwrap();
                 Some(characterdata.Data())
             }
             NodeTypeId::DocumentType |
@@ -1959,15 +1939,14 @@ impl NodeMethods for Node {
                 let node = if value.is_empty() {
                     None
                 } else {
-                    let document = self.owner_doc();
-                    Some(Root::upcast::<Node>(document.r().CreateTextNode(value)))
+                    Some(Root::upcast(self.owner_doc().CreateTextNode(value)))
                 };
 
                 // Step 3.
                 Node::replace_all(node.r(), self);
             }
             NodeTypeId::CharacterData(..) => {
-                let characterdata: &CharacterData = self.downcast::<CharacterData>().unwrap();
+                let characterdata = self.downcast::<CharacterData>().unwrap();
                 characterdata.SetData(value);
 
                 // Notify the document that the content of this node is different
@@ -2034,8 +2013,7 @@ impl NodeMethods for Node {
                         0 => (),
                         // Step 6.1.2
                         1 => {
-                            if self.child_elements()
-                                   .any(|c| c.upcast::<Node>() != child) {
+                            if self.child_elements().any(|c| c.upcast::<Node>() != child) {
                                 return Err(Error::HierarchyRequest);
                             }
                             if child.following_siblings()
@@ -2137,14 +2115,13 @@ impl NodeMethods for Node {
         for child in self.children() {
             match child.downcast::<Text>() {
                 Some(text) => {
-                    let characterdata: &CharacterData = text.upcast::<CharacterData>();
+                    let characterdata = text.upcast::<CharacterData>();
                     if characterdata.Length() == 0 {
                         Node::remove(&*child, self, SuppressObserver::Unsuppressed);
                     } else {
                         match prev_text {
                             Some(ref text_node) => {
-                                let prev_characterdata =
-                                    text_node.upcast::<CharacterData>();
+                                let prev_characterdata = text_node.upcast::<CharacterData>();
                                 prev_characterdata.append_data(&**characterdata.data());
                                 Node::remove(&*child, self, SuppressObserver::Unsuppressed);
                             },
@@ -2172,34 +2149,34 @@ impl NodeMethods for Node {
     // https://dom.spec.whatwg.org/#dom-node-isequalnode
     fn IsEqualNode(&self, maybe_node: Option<&Node>) -> bool {
         fn is_equal_doctype(node: &Node, other: &Node) -> bool {
-            let doctype: &DocumentType = node.downcast::<DocumentType>().unwrap();
-            let other_doctype: &DocumentType = other.downcast::<DocumentType>().unwrap();
+            let doctype = node.downcast::<DocumentType>().unwrap();
+            let other_doctype = other.downcast::<DocumentType>().unwrap();
             (*doctype.name() == *other_doctype.name()) &&
             (*doctype.public_id() == *other_doctype.public_id()) &&
             (*doctype.system_id() == *other_doctype.system_id())
         }
         fn is_equal_element(node: &Node, other: &Node) -> bool {
-            let element: &Element = node.downcast::<Element>().unwrap();
-            let other_element: &Element = other.downcast::<Element>().unwrap();
+            let element = node.downcast::<Element>().unwrap();
+            let other_element = other.downcast::<Element>().unwrap();
             (*element.namespace() == *other_element.namespace()) &&
             (*element.prefix() == *other_element.prefix()) &&
             (*element.local_name() == *other_element.local_name()) &&
             (element.attrs().len() == other_element.attrs().len())
         }
         fn is_equal_processinginstruction(node: &Node, other: &Node) -> bool {
-            let pi: &ProcessingInstruction = node.downcast::<ProcessingInstruction>().unwrap();
-            let other_pi: &ProcessingInstruction = other.downcast::<ProcessingInstruction>().unwrap();
+            let pi = node.downcast::<ProcessingInstruction>().unwrap();
+            let other_pi = other.downcast::<ProcessingInstruction>().unwrap();
             (*pi.target() == *other_pi.target()) &&
             (*pi.upcast::<CharacterData>().data() == *other_pi.upcast::<CharacterData>().data())
         }
         fn is_equal_characterdata(node: &Node, other: &Node) -> bool {
-            let characterdata: &CharacterData = node.downcast::<CharacterData>().unwrap();
-            let other_characterdata: &CharacterData = other.downcast::<CharacterData>().unwrap();
+            let characterdata = node.downcast::<CharacterData>().unwrap();
+            let other_characterdata = other.downcast::<CharacterData>().unwrap();
             *characterdata.data() == *other_characterdata.data()
         }
         fn is_equal_element_attrs(node: &Node, other: &Node) -> bool {
-            let element: &Element = node.downcast::<Element>().unwrap();
-            let other_element: &Element = other.downcast::<Element>().unwrap();
+            let element = node.downcast::<Element>().unwrap();
+            let other_element = other.downcast::<Element>().unwrap();
             assert!(element.attrs().len() == other_element.attrs().len());
             // FIXME(https://github.com/rust-lang/rust/issues/23338)
             let attrs = element.attrs();
@@ -2327,7 +2304,9 @@ impl NodeMethods for Node {
 
         // Step 2.
         match self.type_id() {
-            NodeTypeId::Element(..) => self.downcast::<Element>().unwrap().lookup_prefix(namespace),
+            NodeTypeId::Element(..) => {
+                self.downcast::<Element>().unwrap().lookup_prefix(namespace)
+            },
             NodeTypeId::Document => {
                 self.downcast::<Document>().unwrap().GetDocumentElement().and_then(|element| {
                     element.r().lookup_prefix(namespace)
@@ -2376,8 +2355,7 @@ pub struct TrustedNodeAddress(pub *const c_void);
 unsafe impl Send for TrustedNodeAddress {}
 
 pub fn document_from_node<T: DerivedFrom<Node> + Reflectable>(derived: &T) -> Root<Document> {
-    let node: &Node = derived.upcast::<Node>();
-    node.owner_doc()
+    derived.upcast().owner_doc()
 }
 
 pub fn window_from_node<T: DerivedFrom<Node> + Reflectable>(derived: &T) -> Root<Window> {
@@ -2387,8 +2365,7 @@ pub fn window_from_node<T: DerivedFrom<Node> + Reflectable>(derived: &T) -> Root
 
 impl VirtualMethods for Node {
     fn super_type(&self) -> Option<&VirtualMethods> {
-        let eventtarget: &EventTarget = self.upcast::<EventTarget>();
-        Some(eventtarget as &VirtualMethods)
+        Some(self.upcast::<EventTarget>() as &VirtualMethods)
     }
 
     fn children_changed(&self, mutation: &ChildrenMutation) {
diff --git a/components/script/dom/range.rs b/components/script/dom/range.rs
index 725bce6de50..a67140db970 100644
--- a/components/script/dom/range.rs
+++ b/components/script/dom/range.rs
@@ -43,7 +43,7 @@ impl Range {
     }
 
     pub fn new_with_doc(document: &Document) -> Root<Range> {
-        let root = document.upcast::<Node>();
+        let root = document.upcast();
         Range::new(document, root, 0, root, 0)
     }
 
@@ -369,7 +369,7 @@ impl RangeMethods for Range {
                 let text = text.SubstringData(start_offset, end_offset - start_offset);
                 clone.downcast::<CharacterData>().unwrap().SetData(text.unwrap());
                 // Step 4.3.
-                try!(fragment.upcast::<Node>().AppendChild(clone.r()));
+                try!(fragment.upcast::<Node>().AppendChild(&clone));
                 // Step 4.4
                 return Ok(fragment);
             }
@@ -389,12 +389,12 @@ impl RangeMethods for Range {
                 let text = text.SubstringData(start_offset, start_node.len() - start_offset);
                 clone.downcast::<CharacterData>().unwrap().SetData(text.unwrap());
                 // Step 13.3.
-                try!(fragment.upcast::<Node>().AppendChild(clone.r()));
+                try!(fragment.upcast::<Node>().AppendChild(&clone));
             } else {
                 // Step 14.1.
                 let clone = child.CloneNode(false);
                 // Step 14.2.
-                try!(fragment.upcast::<Node>().AppendChild(clone.r()));
+                try!(fragment.upcast::<Node>().AppendChild(&clone));
                 // Step 14.3.
                 let subrange = Range::new(clone.owner_doc().r(),
                                           start_node.r(),
@@ -404,7 +404,7 @@ impl RangeMethods for Range {
                 // Step 14.4.
                 let subfragment = try!(subrange.CloneContents());
                 // Step 14.5.
-                try!(clone.AppendChild(subfragment.upcast::<Node>()));
+                try!(clone.AppendChild(subfragment.upcast()));
             }
         }
 
@@ -413,7 +413,7 @@ impl RangeMethods for Range {
             // Step 15.1.
             let clone = child.CloneNode(true);
             // Step 15.2.
-            try!(fragment.upcast::<Node>().AppendChild(clone.r()));
+            try!(fragment.upcast::<Node>().AppendChild(&clone));
         }
 
         if let Some(child) = last_contained_child {
@@ -426,12 +426,12 @@ impl RangeMethods for Range {
                 let text = text.SubstringData(0, end_offset);
                 clone.downcast::<CharacterData>().unwrap().SetData(text.unwrap());
                 // Step 16.3.
-                try!(fragment.upcast::<Node>().AppendChild(clone.r()));
+                try!(fragment.upcast::<Node>().AppendChild(&clone));
             } else {
                 // Step 17.1.
                 let clone = child.CloneNode(false);
                 // Step 17.2.
-                try!(fragment.upcast::<Node>().AppendChild(clone.r()));
+                try!(fragment.upcast::<Node>().AppendChild(&clone));
                 // Step 17.3.
                 let subrange = Range::new(clone.owner_doc().r(),
                                           child.r(),
@@ -441,7 +441,7 @@ impl RangeMethods for Range {
                 // Step 17.4.
                 let subfragment = try!(subrange.CloneContents());
                 // Step 17.5.
-                try!(clone.AppendChild(subfragment.upcast::<Node>()));
+                try!(clone.AppendChild(subfragment.upcast()));
             }
         }
 
@@ -477,7 +477,7 @@ impl RangeMethods for Range {
                 let text = end_data.SubstringData(start_offset, end_offset - start_offset);
                 clone.downcast::<CharacterData>().unwrap().SetData(text.unwrap());
                 // Step 4.3.
-                try!(fragment.upcast::<Node>().AppendChild(clone.r()));
+                try!(fragment.upcast::<Node>().AppendChild(&clone));
                 // Step 4.4.
                 try!(end_data.ReplaceData(start_offset,
                                           end_offset - start_offset,
@@ -513,7 +513,7 @@ impl RangeMethods for Range {
                                                     start_node.len() - start_offset);
                 clone.downcast::<CharacterData>().unwrap().SetData(text.unwrap());
                 // Step 15.3.
-                try!(fragment.upcast::<Node>().AppendChild(clone.r()));
+                try!(fragment.upcast::<Node>().AppendChild(&clone));
                 // Step 15.4.
                 try!(start_data.ReplaceData(start_offset,
                                             start_node.len() - start_offset,
@@ -522,7 +522,7 @@ impl RangeMethods for Range {
                 // Step 16.1.
                 let clone = child.CloneNode(false);
                 // Step 16.2.
-                try!(fragment.upcast::<Node>().AppendChild(clone.r()));
+                try!(fragment.upcast::<Node>().AppendChild(&clone));
                 // Step 16.3.
                 let subrange = Range::new(clone.owner_doc().r(),
                                           start_node.r(),
@@ -532,13 +532,13 @@ impl RangeMethods for Range {
                 // Step 16.4.
                 let subfragment = try!(subrange.ExtractContents());
                 // Step 16.5.
-                try!(clone.AppendChild(subfragment.upcast::<Node>()));
+                try!(clone.AppendChild(subfragment.upcast()));
             }
         }
 
         // Step 17.
         for child in contained_children {
-            try!(fragment.upcast::<Node>().AppendChild(child.r()));
+            try!(fragment.upcast::<Node>().AppendChild(&child));
         }
 
         if let Some(child) = last_contained_child {
@@ -550,14 +550,14 @@ impl RangeMethods for Range {
                 let text = end_data.SubstringData(0, end_offset);
                 clone.downcast::<CharacterData>().unwrap().SetData(text.unwrap());
                 // Step 18.3.
-                try!(fragment.upcast::<Node>().AppendChild(clone.r()));
+                try!(fragment.upcast::<Node>().AppendChild(&clone));
                 // Step 18.4.
                 try!(end_data.ReplaceData(0, end_offset, "".to_owned()));
             } else {
                 // Step 19.1.
                 let clone = child.CloneNode(false);
                 // Step 19.2.
-                try!(fragment.upcast::<Node>().AppendChild(clone.r()));
+                try!(fragment.upcast::<Node>().AppendChild(&clone));
                 // Step 19.3.
                 let subrange = Range::new(clone.owner_doc().r(),
                                           child.r(),
@@ -567,7 +567,7 @@ impl RangeMethods for Range {
                 // Step 19.4.
                 let subfragment = try!(subrange.ExtractContents());
                 // Step 19.5.
-                try!(clone.AppendChild(subfragment.upcast::<Node>()));
+                try!(clone.AppendChild(subfragment.upcast()));
             }
         }
 
@@ -697,7 +697,7 @@ impl RangeMethods for Range {
         try!(self.InsertNode(new_parent));
 
         // Step 6.
-        let _ = try!(new_parent.AppendChild(fragment.upcast::<Node>()));
+        try!(new_parent.AppendChild(fragment.upcast()));
 
         // Step 7.
         self.SelectNode(new_parent)
diff --git a/components/script/dom/servohtmlparser.rs b/components/script/dom/servohtmlparser.rs
index 061cdd533c7..4999d600a20 100644
--- a/components/script/dom/servohtmlparser.rs
+++ b/components/script/dom/servohtmlparser.rs
@@ -48,7 +48,7 @@ impl Sink {
             NodeOrText::AppendNode(n) => n.root(),
             NodeOrText::AppendText(t) => {
                 let text = Text::new(t.into(), &self.document);
-                Root::upcast::<Node>(text)
+                Root::upcast(text)
             }
         }
     }
diff --git a/components/script/dom/storage.rs b/components/script/dom/storage.rs
index 926848e66c7..8d0377b30ee 100644
--- a/components/script/dom/storage.rs
+++ b/components/script/dom/storage.rs
@@ -11,7 +11,6 @@ use dom::bindings::js::{Root, RootedReference};
 use dom::bindings::refcounted::Trusted;
 use dom::bindings::utils::{Reflector, reflect_dom_object};
 use dom::event::{Event, EventBubbles, EventCancelable};
-use dom::eventtarget::EventTarget;
 use dom::storageevent::StorageEvent;
 use dom::urlhelper::UrlHelper;
 use ipc_channel::ipc;
@@ -193,7 +192,6 @@ impl MainThreadRunnable for StorageEventRunnable {
             ev_url.to_string(),
             Some(storage)
         );
-        let event = storage_event.upcast::<Event>();
 
         let root_page = script_task.root_page();
         for it_page in root_page.iter() {
@@ -203,8 +201,7 @@ impl MainThreadRunnable for StorageEventRunnable {
             // TODO: Such a Document object is not necessarily fully active, but events fired on such
             // objects are ignored by the event loop until the Document becomes fully active again.
             if ev_window.pipeline() != it_window.pipeline() {
-                let target = it_window.upcast::<EventTarget>();
-                event.fire(target);
+                storage_event.upcast::<Event>().fire(it_window.upcast());
             }
         }
     }
diff --git a/components/script/dom/text.rs b/components/script/dom/text.rs
index 6f6e713ef27..d7c21cfa78d 100644
--- a/components/script/dom/text.rs
+++ b/components/script/dom/text.rs
@@ -63,9 +63,7 @@ impl TextMethods for Text {
         let parent = node.GetParentNode();
         if let Some(ref parent) = parent {
             // Step 7.
-            parent.r().InsertBefore(new_node.upcast::<Node>(),
-                                    node.GetNextSibling().r())
-                  .unwrap();
+            parent.InsertBefore(new_node.upcast(), node.GetNextSibling().r()).unwrap();
             // TODO: Ranges.
         }
         // Step 8.
diff --git a/components/script/dom/uievent.rs b/components/script/dom/uievent.rs
index 45b3aa07a7c..343d9f31620 100644
--- a/components/script/dom/uievent.rs
+++ b/components/script/dom/uievent.rs
@@ -86,7 +86,7 @@ impl UIEventMethods for UIEvent {
                    cancelable: bool,
                    view: Option<&Window>,
                    detail: i32) {
-        let event: &Event = self.upcast::<Event>();
+        let event = self.upcast::<Event>();
         if event.dispatching() {
             return;
         }
diff --git a/components/script/dom/userscripts.rs b/components/script/dom/userscripts.rs
index b7546ad4b27..35b1c2333a5 100644
--- a/components/script/dom/userscripts.rs
+++ b/components/script/dom/userscripts.rs
@@ -44,8 +44,7 @@ pub fn load_script(head: &HTMLHeadElement) {
             let new_script = doc.CreateElement("script".to_owned()).unwrap();
             let new_script = new_script.r();
             new_script.set_string_attribute(&atom!("src"), name);
-            let new_script_node = new_script.upcast::<Node>();
-            node.InsertBefore(new_script_node, first_child.r()).unwrap();
+            node.InsertBefore(new_script.upcast(), first_child.r()).unwrap();
         }
     }
 }
diff --git a/components/script/dom/virtualmethods.rs b/components/script/dom/virtualmethods.rs
index 95a40df6f6c..da80f414da4 100644
--- a/components/script/dom/virtualmethods.rs
+++ b/components/script/dom/virtualmethods.rs
@@ -123,131 +123,97 @@ pub trait VirtualMethods {
 pub fn vtable_for(node: &Node) -> &VirtualMethods {
     match node.type_id() {
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLAnchorElement)) => {
-            let element = node.downcast::<HTMLAnchorElement>().unwrap();
-            element as &VirtualMethods
+            node.downcast::<HTMLAnchorElement>().unwrap() as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLAppletElement)) => {
             node.downcast::<HTMLAppletElement>().unwrap() as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLAreaElement)) => {
-            let element = node.downcast::<HTMLAreaElement>().unwrap();
-            element as &VirtualMethods
+            node.downcast::<HTMLAreaElement>().unwrap() as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLBaseElement)) => {
-            let element = node.downcast::<HTMLBaseElement>().unwrap();
-            element as &VirtualMethods
+            node.downcast::<HTMLBaseElement>().unwrap() as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLBodyElement)) => {
-            let element = node.downcast::<HTMLBodyElement>().unwrap();
-            element as &VirtualMethods
+            node.downcast::<HTMLBodyElement>().unwrap() as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLButtonElement)) => {
-            let element = node.downcast::<HTMLButtonElement>().unwrap();
-            element as &VirtualMethods
+            node.downcast::<HTMLButtonElement>().unwrap() as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLCanvasElement)) => {
-            let element = node.downcast::<HTMLCanvasElement>().unwrap();
-            element as &VirtualMethods
+            node.downcast::<HTMLCanvasElement>().unwrap() as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLFieldSetElement)) => {
-            let element = node.downcast::<HTMLFieldSetElement>().unwrap();
-            element as &VirtualMethods
+            node.downcast::<HTMLFieldSetElement>().unwrap() as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLFontElement)) => {
-            let element = node.downcast::<HTMLFontElement>().unwrap();
-            element as &VirtualMethods
+            node.downcast::<HTMLFontElement>().unwrap() as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLFormElement)) => {
-            let element = node.downcast::<HTMLFormElement>().unwrap();
-            element as &VirtualMethods
+            node.downcast::<HTMLFormElement>().unwrap() as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLHeadElement)) => {
-            let element = node.downcast::<HTMLHeadElement>().unwrap();
-            element as &VirtualMethods
+            node.downcast::<HTMLHeadElement>().unwrap() as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLImageElement)) => {
-            let element = node.downcast::<HTMLImageElement>().unwrap();
-            element as &VirtualMethods
+            node.downcast::<HTMLImageElement>().unwrap() as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLIFrameElement)) => {
-            let element = node.downcast::<HTMLIFrameElement>().unwrap();
-            element as &VirtualMethods
+            node.downcast::<HTMLIFrameElement>().unwrap() as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLInputElement)) => {
-            let element = node.downcast::<HTMLInputElement>().unwrap();
-            element as &VirtualMethods
+            node.downcast::<HTMLInputElement>().unwrap() as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLLinkElement)) => {
-            let element = node.downcast::<HTMLLinkElement>().unwrap();
-            element as &VirtualMethods
+            node.downcast::<HTMLLinkElement>().unwrap() as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLMetaElement)) => {
-            let element = node.downcast::<HTMLMetaElement>().unwrap();
-            element as &VirtualMethods
+            node.downcast::<HTMLMetaElement>().unwrap() as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLObjectElement)) => {
-            let element = node.downcast::<HTMLObjectElement>().unwrap();
-            element as &VirtualMethods
+            node.downcast::<HTMLObjectElement>().unwrap() as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLOptGroupElement)) => {
-            let element = node.downcast::<HTMLOptGroupElement>().unwrap();
-            element as &VirtualMethods
+            node.downcast::<HTMLOptGroupElement>().unwrap() as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLOptionElement)) => {
-            let element = node.downcast::<HTMLOptionElement>().unwrap();
-            element as &VirtualMethods
+            node.downcast::<HTMLOptionElement>().unwrap() as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLScriptElement)) => {
-            let element = node.downcast::<HTMLScriptElement>().unwrap();
-            element as &VirtualMethods
+            node.downcast::<HTMLScriptElement>().unwrap() as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLSelectElement)) => {
-            let element = node.downcast::<HTMLSelectElement>().unwrap();
-            element as &VirtualMethods
+            node.downcast::<HTMLSelectElement>().unwrap() as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLStyleElement)) => {
-            let element = node.downcast::<HTMLStyleElement>().unwrap();
-            element as &VirtualMethods
+            node.downcast::<HTMLStyleElement>().unwrap() as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTableElement)) => {
-            let element =
-                node.downcast::<HTMLTableElement>().unwrap();
-            element as &VirtualMethods
+            node.downcast::<HTMLTableElement>().unwrap() as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTableCellElement(_))) => {
-            let element =
-                node.downcast::<HTMLTableCellElement>().unwrap();
-            element as &VirtualMethods
+            node.downcast::<HTMLTableCellElement>().unwrap() as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTableRowElement)) => {
-            let element =
-                node.downcast::<HTMLTableRowElement>().unwrap();
-            element as &VirtualMethods
+            node.downcast::<HTMLTableRowElement>().unwrap() as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTableSectionElement)) => {
-            let element =
-                node.downcast::<HTMLTableSectionElement>().unwrap();
-            element as &VirtualMethods
+            node.downcast::<HTMLTableSectionElement>().unwrap() as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTemplateElement)) => {
             node.downcast::<HTMLTemplateElement>().unwrap() as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTextAreaElement)) => {
-            let element = node.downcast::<HTMLTextAreaElement>().unwrap();
-            element as &VirtualMethods
+            node.downcast::<HTMLTextAreaElement>().unwrap() as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTitleElement)) => {
-            let element =
-                node.downcast::<HTMLTitleElement>().unwrap();
-            element as &VirtualMethods
+            node.downcast::<HTMLTitleElement>().unwrap() as &VirtualMethods
         }
         NodeTypeId::Element(ElementTypeId::Element) => {
-            let element = node.downcast::<Element>().unwrap();
-            element as &VirtualMethods
+            node.downcast::<Element>().unwrap() as &VirtualMethods
         }
         NodeTypeId::Element(_) => {
-            let element = node.downcast::<HTMLElement>().unwrap();
-            element as &VirtualMethods
+            node.downcast::<HTMLElement>().unwrap() as &VirtualMethods
         }
         _ => {
             node as &VirtualMethods
diff --git a/components/script/dom/webglrenderingcontext.rs b/components/script/dom/webglrenderingcontext.rs
index cc4f4579dd9..c7011c8e056 100644
--- a/components/script/dom/webglrenderingcontext.rs
+++ b/components/script/dom/webglrenderingcontext.rs
@@ -14,7 +14,6 @@ use dom::bindings::global::{GlobalField, GlobalRef};
 use dom::bindings::js::{JS, LayoutJS, MutNullableHeap, Root};
 use dom::bindings::utils::{Reflector, reflect_dom_object};
 use dom::event::{Event, EventBubbles, EventCancelable};
-use dom::eventtarget::EventTarget;
 use dom::htmlcanvaselement::HTMLCanvasElement;
 use dom::htmlcanvaselement::utils as canvas_utils;
 use dom::node::{Node, NodeDamage, window_from_node};
@@ -121,7 +120,7 @@ impl WebGLRenderingContext {
                                                    EventBubbles::DoesNotBubble,
                                                    EventCancelable::Cancelable,
                                                    msg);
-                event.upcast::<Event>().fire(canvas.upcast::<EventTarget>());
+                event.upcast::<Event>().fire(canvas.upcast());
                 None
             }
         }
@@ -153,9 +152,7 @@ impl WebGLRenderingContext {
     }
 
     fn mark_as_dirty(&self) {
-        let canvas = self.canvas.root();
-        let node = canvas.upcast::<Node>();
-        node.dirty(NodeDamage::OtherNodeDamage);
+        self.canvas.root().upcast::<Node>().dirty(NodeDamage::OtherNodeDamage);
     }
 }
 
diff --git a/components/script/dom/websocket.rs b/components/script/dom/websocket.rs
index 149f4ba32e3..88f3c6a2f8e 100644
--- a/components/script/dom/websocket.rs
+++ b/components/script/dom/websocket.rs
@@ -454,7 +454,7 @@ impl Runnable for ConnectionEstablishedTask {
         let event = Event::new(global.r(), "open".to_owned(),
                                EventBubbles::DoesNotBubble,
                                EventCancelable::NotCancelable);
-        event.fire(ws.upcast::<EventTarget>());
+        event.fire(ws.upcast());
     }
 }
 
@@ -496,8 +496,7 @@ impl Runnable for CloseTask {
                                    "error".to_owned(),
                                    EventBubbles::DoesNotBubble,
                                    EventCancelable::Cancelable);
-            let target = ws.upcast::<EventTarget>();
-            event.r().fire(target);
+            event.fire(ws.upcast());
         }
         let rsn = ws.reason.borrow();
         let rsn_clone = rsn.clone();
@@ -511,9 +510,7 @@ impl Runnable for CloseTask {
                                           ws.clean_close.get(),
                                           ws.code.get(),
                                           rsn_clone);
-        let target = ws.upcast::<EventTarget>();
-        let event = close_event.upcast::<Event>();
-        event.fire(target);
+        close_event.upcast::<Event>().fire(ws.upcast());
     }
 }
 
@@ -562,7 +559,6 @@ impl Runnable for MessageReceivedTask {
             },
         }
 
-        let target = ws.upcast::<EventTarget>();
-        MessageEvent::dispatch_jsval(target, global.r(), message.handle());
+        MessageEvent::dispatch_jsval(ws.upcast(), global.r(), message.handle());
     }
 }
diff --git a/components/script/dom/window.rs b/components/script/dom/window.rs
index 9ca6713991d..5a9233319c1 100644
--- a/components/script/dom/window.rs
+++ b/components/script/dom/window.rs
@@ -793,8 +793,7 @@ impl<'a, T: Reflectable> ScriptHelpers for &'a T {
 
 impl Window {
     pub fn clear_js_runtime(&self) {
-        let document = self.Document();
-        document.upcast::<Node>().teardown();
+        self.Document().upcast::<Node>().teardown();
 
         // The above code may not catch all DOM objects
         // (e.g. DOM objects removed from the tree that haven't
@@ -835,9 +834,7 @@ impl Window {
         let body = self.Document().GetBody();
         let (x, y) = match body {
             Some(e) => {
-                let node = e.upcast::<Node>();
-                let content_size = node.get_bounding_content_box();
-
+                let content_size = e.upcast::<Node>().get_bounding_content_box();
                 let content_height = content_size.size.height.to_f64_px();
                 let content_width = content_size.size.width.to_f64_px();
                 (xfinite.max(0.0f64).min(content_width - width),
@@ -1055,7 +1052,7 @@ impl Window {
         let js_runtime = js_runtime.as_ref().unwrap();
         let element = response.node_address.and_then(|parent_node_address| {
             let node = from_untrusted_node_address(js_runtime.rt(), parent_node_address);
-            Root::downcast::<Element>(node)
+            Root::downcast(node)
         });
         (element, response.rect)
     }
diff --git a/components/script/dom/worker.rs b/components/script/dom/worker.rs
index 6d890f1a14e..e3fc2a202e5 100644
--- a/components/script/dom/worker.rs
+++ b/components/script/dom/worker.rs
@@ -115,7 +115,7 @@ impl Worker {
         let worker = address.root();
 
         let global = worker.r().global.root();
-        let target = worker.upcast::<EventTarget>();
+        let target = worker.upcast();
         let _ar = JSAutoRequest::new(global.r().get_cx());
         let _ac = JSAutoCompartment::new(global.r().get_cx(), target.reflector().get_jsobject().get());
         let mut message = RootedValue::new(global.r().get_cx(), UndefinedValue());
@@ -126,13 +126,11 @@ impl Worker {
     pub fn dispatch_simple_error(address: TrustedWorkerAddress) {
         let worker = address.root();
         let global = worker.r().global.root();
-        let target = worker.upcast::<EventTarget>();
-
         let event = Event::new(global.r(),
                                "error".to_owned(),
                                EventBubbles::DoesNotBubble,
                                EventCancelable::NotCancelable);
-        event.r().fire(target);
+        event.fire(worker.upcast());
     }
 
     pub fn handle_error_message(address: TrustedWorkerAddress, message: DOMString,
@@ -140,12 +138,10 @@ impl Worker {
         let worker = address.root();
         let global = worker.r().global.root();
         let error = RootedValue::new(global.r().get_cx(), UndefinedValue());
-        let target = worker.upcast::<EventTarget>();
         let errorevent = ErrorEvent::new(global.r(), "error".to_owned(),
                                          EventBubbles::Bubbles, EventCancelable::Cancelable,
                                          message, filename, lineno, colno, error.handle());
-        let event = errorevent.upcast::<Event>();
-        event.fire(target);
+        errorevent.upcast::<Event>().fire(worker.upcast());
     }
 }
 
diff --git a/components/script/dom/xmlhttprequest.rs b/components/script/dom/xmlhttprequest.rs
index e84a4781bab..067ba1019ed 100644
--- a/components/script/dom/xmlhttprequest.rs
+++ b/components/script/dom/xmlhttprequest.rs
@@ -737,8 +737,7 @@ impl XMLHttpRequest {
                                "readystatechange".to_owned(),
                                EventBubbles::DoesNotBubble,
                                EventCancelable::Cancelable);
-        let target = self.upcast::<EventTarget>();
-        event.r().fire(target);
+        event.fire(self.upcast());
     }
 
     fn process_headers_available(&self, cors_request: Option<CORSRequest>,
@@ -921,12 +920,11 @@ impl XMLHttpRequest {
                                                total.is_some(), loaded,
                                                total.unwrap_or(0));
         let target = if upload {
-            self.upload.upcast::<EventTarget>()
+            self.upload.upcast()
         } else {
-            self.upcast::<EventTarget>()
+            self.upcast()
         };
-        let event = progressevent.upcast::<Event>();
-        event.fire(target);
+        progressevent.upcast::<Event>().fire(target);
     }
 
     fn dispatch_upload_progress_event(&self, type_: DOMString, partial_load: Option<u64>) {
diff --git a/components/script/parse/html.rs b/components/script/parse/html.rs
index 36955322d6c..4943fecdb5f 100644
--- a/components/script/parse/html.rs
+++ b/components/script/parse/html.rs
@@ -45,16 +45,14 @@ impl<'a> TreeSink for servohtmlparser::Sink {
     type Handle = JS<Node>;
 
     fn get_document(&mut self) -> JS<Node> {
-        let doc = self.document.root();
-        let node = doc.upcast::<Node>();
-        JS::from_ref(node)
+        JS::from_ref(self.document.root().upcast())
     }
 
     fn get_template_contents(&self, target: JS<Node>) -> JS<Node> {
         let target = target.root();
         let template = target.downcast::<HTMLTemplateElement>()
             .expect("tried to get template contents of non-HTMLTemplateElement in HTML parsing");
-        JS::from_ref(template.Content().upcast::<Node>())
+        JS::from_ref(template.Content().upcast())
     }
 
     fn same_node(&self, x: JS<Node>, y: JS<Node>) -> bool {
@@ -81,15 +79,13 @@ impl<'a> TreeSink for servohtmlparser::Sink {
             elem.r().set_attribute_from_parser(attr.name, attr.value.into(), None);
         }
 
-        let node = elem.upcast::<Node>();
-        JS::from_ref(node)
+        JS::from_ref(elem.upcast())
     }
 
     fn create_comment(&mut self, text: StrTendril) -> JS<Node> {
         let doc = self.document.root();
         let comment = Comment::new(text.into(), doc.r());
-        let node = Root::upcast::<Node>(comment);
-        JS::from_rooted(&node)
+        JS::from_ref(comment.upcast())
     }
 
     fn append_before_sibling(&mut self,
@@ -127,12 +123,9 @@ impl<'a> TreeSink for servohtmlparser::Sink {
     fn append_doctype_to_document(&mut self, name: StrTendril, public_id: StrTendril,
                                   system_id: StrTendril) {
         let doc = self.document.root();
-        let doc_node = doc.upcast::<Node>();
         let doctype = DocumentType::new(
             name.into(), Some(public_id.into()), Some(system_id.into()), doc.r());
-        let node: Root<Node> = Root::upcast::<Node>(doctype);
-
-        assert!(doc_node.AppendChild(node.r()).is_ok());
+        doc.upcast::<Node>().AppendChild(doctype.upcast()).expect("Appending failed");
     }
 
     fn add_attrs_if_missing(&mut self, target: JS<Node>, attrs: Vec<Attribute>) {
@@ -153,13 +146,13 @@ impl<'a> TreeSink for servohtmlparser::Sink {
 
     fn mark_script_already_started(&mut self, node: JS<Node>) {
         let node: Root<Node> = node.root();
-        let script: Option<&HTMLScriptElement> = node.downcast::<HTMLScriptElement>();
+        let script = node.downcast::<HTMLScriptElement>();
         script.map(|script| script.mark_already_started());
     }
 
     fn complete_script(&mut self, node: JS<Node>) -> NextParserState {
         let node: Root<Node> = node.root();
-        let script: Option<&HTMLScriptElement> = node.downcast::<HTMLScriptElement>();
+        let script = node.downcast::<HTMLScriptElement>();
         if let Some(script) = script {
             return script.prepare();
         }
@@ -305,8 +298,7 @@ pub fn parse_html_fragment(context_node: &Node,
 
     // Step 14.
     let root_element = document.r().GetDocumentElement().expect("no document element");
-    let root_node = root_element.upcast::<Node>();
-    for child in root_node.children() {
+    for child in root_element.upcast::<Node>().children() {
         output.AppendChild(child.r()).unwrap();
     }
 }
diff --git a/components/script/script_task.rs b/components/script/script_task.rs
index c52bcd66f4c..79e749b82d6 100644
--- a/components/script/script_task.rs
+++ b/components/script/script_task.rs
@@ -34,7 +34,6 @@ use dom::document::{Document, DocumentProgressHandler, IsHTMLDocument};
 use dom::document::{DocumentProgressTask, DocumentSource, MouseEventType};
 use dom::element::Element;
 use dom::event::{Event, EventBubbles, EventCancelable};
-use dom::eventtarget::EventTarget;
 use dom::node::{Node, NodeDamage, window_from_node};
 use dom::servohtmlparser::{ParserContext, ServoHTMLParser};
 use dom::uievent::UIEvent;
@@ -1256,12 +1255,10 @@ impl ScriptTask {
                 urls.push(current_url.clone());
 
                 for child in it_page.document().upcast::<Node>().traverse_preorder() {
-                    let target = child.upcast::<EventTarget>();
-                    dom_tree_size += heap_size_of_self_and_children(target);
+                    dom_tree_size += heap_size_of_self_and_children(&*child);
                 }
                 let window = it_page.window();
-                let target = window.upcast::<EventTarget>();
-                dom_tree_size += heap_size_of_self_and_children(target);
+                dom_tree_size += heap_size_of_self_and_children(&*window);
 
                 reports.push(Report {
                     path: path![format!("url({})", current_url), "dom-tree"],
@@ -1323,9 +1320,8 @@ impl ScriptTask {
         let frame_element = doc.find_iframe(subpage_id);
 
         if let Some(ref frame_element) = frame_element {
-            let element = frame_element.upcast::<Element>();
             doc.r().begin_focus_transaction();
-            doc.r().request_focus(element);
+            doc.r().request_focus(frame_element.upcast());
             doc.r().commit_focus_transaction(FocusType::Parent);
         }
     }
@@ -1625,7 +1621,7 @@ impl ScriptTask {
                                      DocumentSource::FromParser,
                                      loader);
 
-        let frame_element = frame_element.r().map(Castable::upcast::<Element>);
+        let frame_element = frame_element.r().map(Castable::upcast);
         window.r().init_browsing_context(document.r(), frame_element);
 
         // Create the root frame
@@ -1671,9 +1667,8 @@ impl ScriptTask {
         }
     }
 
-    fn scroll_fragment_point(&self, pipeline_id: PipelineId, node: &Element) {
-        let node = node.upcast::<Node>();
-        let rect = node.get_bounding_content_box();
+    fn scroll_fragment_point(&self, pipeline_id: PipelineId, element: &Element) {
+        let rect = element.upcast::<Node>().get_bounding_content_box();
         let point = Point2D::new(rect.origin.x.to_f32_px(), rect.origin.y.to_f32_px());
         // FIXME(#2003, pcwalton): This is pretty bogus when multiple layers are involved.
         // Really what needs to happen is that this needs to go through layout to ask which
@@ -1844,10 +1839,7 @@ impl ScriptTask {
                                    "resize".to_owned(), EventBubbles::DoesNotBubble,
                                    EventCancelable::NotCancelable, Some(window.r()),
                                    0i32);
-        let event = uievent.upcast::<Event>();
-
-        let wintarget = window.upcast::<EventTarget>();
-        event.fire(wintarget);
+        uievent.upcast::<Event>().fire(window.upcast());
     }
 
     /// Initiate a non-blocking fetch for a specified resource. Stores the InProgressLoad
@@ -1905,7 +1897,7 @@ impl ScriptTask {
         // Kick off the initial reflow of the page.
         debug!("kicking off initial reflow of {:?}", final_url);
         document.r().disarm_reflow_timeout();
-        document.r().content_changed(document.upcast::<Node>(),
+        document.r().content_changed(document.upcast(),
                                      NodeDamage::OtherNodeDamage);
         let window = window_from_node(document.r());
         window.r().reflow(ReflowGoal::ForDisplay, ReflowQueryType::NoQuery, ReflowReason::FirstLoad);
diff --git a/components/script/webdriver_handlers.rs b/components/script/webdriver_handlers.rs
index 1812f16b802..5e9b87be23a 100644
--- a/components/script/webdriver_handlers.rs
+++ b/components/script/webdriver_handlers.rs
@@ -116,8 +116,7 @@ pub fn handle_find_element_css(page: &Rc<Page>, _pipeline: PipelineId, selector:
                                reply: IpcSender<Result<Option<String>, ()>>) {
     reply.send(match page.document().r().QuerySelector(selector.clone()) {
         Ok(node) => {
-            let result = node.map(|x| x.upcast::<Node>().get_unique_id());
-            Ok(result)
+            Ok(node.map(|x| x.upcast::<Node>().get_unique_id()))
         }
         Err(_) => Err(())
     }).unwrap();
@@ -172,8 +171,7 @@ pub fn handle_get_name(page: &Rc<Page>,
                        reply: IpcSender<Result<String, ()>>) {
     reply.send(match find_node_by_unique_id(&*page, pipeline, node_id) {
         Some(node) => {
-            let element = node.downcast::<Element>().unwrap();
-            Ok(element.TagName())
+            Ok(node.downcast::<Element>().unwrap().TagName())
         },
         None => Err(())
     }).unwrap();

From d0e022b64e7b708e6fbe7348526c49a3665361ba Mon Sep 17 00:00:00 2001
From: Anthony Ramine <n.oxyde@gmail.com>
Date: Wed, 21 Oct 2015 13:11:15 +0200
Subject: [PATCH 5/5] Document the new inheritance machinery (fixes #8125)

---
 components/script/dom/mod.rs | 42 +++++++++++++++++++++++++-----------
 1 file changed, 30 insertions(+), 12 deletions(-)

diff --git a/components/script/dom/mod.rs b/components/script/dom/mod.rs
index a61ddd76c2c..ae4524cd05e 100644
--- a/components/script/dom/mod.rs
+++ b/components/script/dom/mod.rs
@@ -54,21 +54,39 @@
 //! This invariant is enforced by the lint in
 //! `plugins::lints::inheritance_integrity`.
 //!
-//! The same principle applies to typeids,
-//! the derived type enum should
-//! use one addititional type (the parent class) because sometimes the parent
-//! can be the most-derived class of an object.
+//! Interfaces which either derive from or are derived by other interfaces
+//! implement the `Castable` trait, which provides three methods `is::<T>()`,
+//! `downcast::<T>()` and `upcast::<T>()` to cast across the type hierarchy
+//! and check whether a given instance is of a given type.
 //!
 //! ```ignore
-//! pub enum EventTypeId {
-//!     UIEvent(UIEventTypeId),
-//!     //others events
-//! }
+//! use dom::bindings::conversions::Castable;
+//! use dom::element::Element;
+//! use dom::htmlelement::HTMLElement;
+//! use dom::htmlinputelement::HTMLInputElement;
 //!
-//! pub enum UIEventTypeId {
-//!    MouseEvent,
-//!    KeyboardEvent,
-//!    UIEvent, //<- parent of MouseEvent and KeyboardEvent
+//! if let Some(elem) = node.downcast::<Element> {
+//!     if elem.is::<HTMLInputElement>() {
+//!         return elem.upcast::<HTMLElement>();
+//!     }
+//! }
+//! ```
+//!
+//! Furthermore, when discriminating a given instance against multiple
+//! interface types, code generation provides a convenient TypeId enum
+//! which can be used to write `match` expressions instead of multiple
+//! calls to `Castable::is::<T>`. The `type_id()` method of an instance is
+//! provided by the farthest interface it derives from, e.g. `EventTarget`
+//! for `HTMLMediaElement`. For convenience, that method is also provided
+//! on the `Node` interface to avoid unnecessary upcasts to `EventTarget`.
+//!
+//! ```ignore
+//! use dom::bindings::codegen::InheritTypes::{EventTargetTypeId, NodeTypeId};
+//!
+//! match *node.type_id() {
+//!     EventTargetTypeId::Node(NodeTypeId::CharacterData(_)) => ...,
+//!     EventTargetTypeId::Node(NodeTypeId::Element(_)) => ...,
+//!     ...,
 //! }
 //! ```
 //!