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

3 files changed, 76 insertions, 116 deletions

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 {}
-
-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) }
-    }
-}
+            if not upcast:
+                # No other interface will implement DeriveFrom<Foo> for this Foo, so avoid
+                # implementing it for itself.
+                chain = chain[:-1]
 
-""" % {'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