Update rustc to revision 3dcd2157403163789aaf21a9ab3c4d30a7c6494d.

117 files changed, 1586 insertions, 1571 deletions

diff --git a/components/script/dom/attr.rs b/components/script/dom/attr.rs
index 34d8e121375..01074b42ac9 100644
--- a/components/script/dom/attr.rs
+++ b/components/script/dom/attr.rs
@@ -30,32 +30,32 @@ pub enum AttrSettingType {
 #[deriving(PartialEq, Clone)]
 #[jstraceable]
 pub enum AttrValue {
-    StringAttrValue(DOMString),
-    TokenListAttrValue(DOMString, Vec<Atom>),
-    UIntAttrValue(DOMString, u32),
-    AtomAttrValue(Atom),
+    String(DOMString),
+    TokenList(DOMString, Vec<Atom>),
+    UInt(DOMString, u32),
+    Atom(Atom),
 }
 
 impl AttrValue {
     pub fn from_tokenlist(tokens: DOMString) -> AttrValue {
         let atoms = split_html_space_chars(tokens.as_slice())
             .map(|token| Atom::from_slice(token)).collect();
-        TokenListAttrValue(tokens, atoms)
+        AttrValue::TokenList(tokens, atoms)
     }
 
     pub fn from_u32(string: DOMString, default: u32) -> AttrValue {
         let result: u32 = from_str(string.as_slice()).unwrap_or(default);
-        UIntAttrValue(string, result)
+        AttrValue::UInt(string, result)
     }
 
     pub fn from_atomic(string: DOMString) -> AttrValue {
         let value = Atom::from_slice(string.as_slice());
-        AtomAttrValue(value)
+        AttrValue::Atom(value)
     }
 
     pub fn tokens<'a>(&'a self) -> Option<&'a [Atom]> {
         match *self {
-            TokenListAttrValue(_, ref tokens) => Some(tokens.as_slice()),
+            AttrValue::TokenList(_, ref tokens) => Some(tokens.as_slice()),
             _ => None
         }
     }
@@ -64,10 +64,10 @@ impl AttrValue {
 impl Str for AttrValue {
     fn as_slice<'a>(&'a self) -> &'a str {
         match *self {
-            StringAttrValue(ref value) |
-            TokenListAttrValue(ref value, _) |
-            UIntAttrValue(ref value, _) => value.as_slice(),
-            AtomAttrValue(ref value) => value.as_slice(),
+            AttrValue::String(ref value) |
+            AttrValue::TokenList(ref value, _) |
+            AttrValue::UInt(ref value, _) => value.as_slice(),
+            AttrValue::Atom(ref value) => value.as_slice(),
         }
     }
 }
@@ -141,12 +141,12 @@ impl<'a> AttrMethods for JSRef<'a, Attr> {
     fn SetValue(self, value: DOMString) {
         match self.owner {
             None => {
-                *self.value.borrow_mut() = StringAttrValue(value)
+                *self.value.borrow_mut() = AttrValue::String(value)
             }
             Some(o) => {
                 let owner = o.root();
                 let value = owner.parse_attribute(&self.namespace, self.local_name(), value);
-                self.set_value(ReplacedAttr, value, *owner);
+                self.set_value(AttrSettingType::ReplacedAttr, value, *owner);
             }
         }
     }
@@ -207,7 +207,8 @@ impl<'a> AttrHelpers<'a> for JSRef<'a, Attr> {
         let namespace_is_null = self.namespace == ns!("");
 
         match set_type {
-            ReplacedAttr if namespace_is_null => vtable_for(&node).before_remove_attr(self),
+            AttrSettingType::ReplacedAttr if namespace_is_null =>
+                vtable_for(&node).before_remove_attr(self),
             _ => ()
         }
 
@@ -255,7 +256,7 @@ impl AttrHelpersForLayout for Attr {
     unsafe fn value_atom_forever(&self) -> Option<Atom> {
         let value = self.value.borrow_for_layout();
         match *value {
-            AtomAttrValue(ref val) => Some(val.clone()),
+            AttrValue::Atom(ref val) => Some(val.clone()),
             _ => None,
         }
     }
@@ -265,7 +266,7 @@ impl AttrHelpersForLayout for Attr {
         // This transmute is used to cheat the lifetime restriction.
         let value = mem::transmute::<&AttrValue, &AttrValue>(self.value.borrow_for_layout());
         match *value {
-            TokenListAttrValue(_, ref tokens) => Some(tokens.as_slice()),
+            AttrValue::TokenList(_, ref tokens) => Some(tokens.as_slice()),
             _ => None,
         }
     }
diff --git a/components/script/dom/bindings/codegen/CodegenRust.py b/components/script/dom/bindings/codegen/CodegenRust.py
index 5ad8ab8b1b4..4a760225cf4 100644
--- a/components/script/dom/bindings/codegen/CodegenRust.py
+++ b/components/script/dom/bindings/codegen/CodegenRust.py
@@ -425,7 +425,7 @@ def typeNeedsRooting(type, descriptorProvider):
 
 def union_native_type(t):
     name = t.unroll().name
-    return 'UnionTypes::%s::%s' % (name, name)
+    return 'UnionTypes::%s' % name
 
 
 def getJSToNativeConversionTemplate(type, descriptorProvider, failureCode=None,
@@ -741,7 +741,7 @@ def getJSToNativeConversionTemplate(type, descriptorProvider, failureCode=None,
 
         if defaultValue is not None:
             assert(defaultValue.type.tag() == IDLType.Tags.domstring)
-            default = "%sValues::%s" % (enum, getEnumValueName(defaultValue.value))
+            default = "%s::%s" % (enum, getEnumValueName(defaultValue.value))
         else:
             default = None
 
@@ -1419,11 +1419,11 @@ class CGNamespace(CGWrapper):
 
 def DOMClass(descriptor):
         protoList = ['PrototypeList::id::' + proto for proto in descriptor.prototypeChain]
-        # Pad out the list to the right length with IDCount so we
-        # guarantee that all the lists are the same length.  IDCount
+        # Pad out the list to the right length with id::Count so we
+        # guarantee that all the lists are the same length.  id::Count
         # is never the ID of any prototype, so it's safe to use as
         # padding.
-        protoList.extend(['PrototypeList::id::IDCount'] * (descriptor.config.maxProtoChainLength - len(protoList)))
+        protoList.extend(['PrototypeList::id::Count'] * (descriptor.config.maxProtoChainLength - len(protoList)))
         prototypeChainString = ', '.join(protoList)
         return """DOMClass {
   interface_chain: [ %s ],
@@ -1673,7 +1673,7 @@ def UnionTypes(descriptors, dictionaries, callbacks, config):
         'dom::bindings::codegen::PrototypeList',
         'dom::bindings::conversions::FromJSValConvertible',
         'dom::bindings::conversions::ToJSValConvertible',
-        'dom::bindings::conversions::Default',
+        'dom::bindings::conversions::StringificationBehavior::Default',
         'dom::bindings::error::throw_not_in_union',
         'dom::bindings::js::JS',
         'dom::types::*',
@@ -1693,14 +1693,12 @@ def UnionTypes(descriptors, dictionaries, callbacks, config):
         name = str(t)
         if not name in unionStructs:
             provider = descriptor or config.getDescriptorProvider()
-            unionStructs[name] = CGNamespace(name,
-                CGImports(CGList([
-                    CGUnionStruct(t, provider),
-                    CGUnionConversionStruct(t, provider)
-                ]), [], imports),
-                public=True)
+            unionStructs[name] = CGList([
+                CGUnionStruct(t, provider),
+                CGUnionConversionStruct(t, provider)
+            ])
 
-    return CGList(SortedDictValues(unionStructs), "\n\n")
+    return CGImports(CGList(SortedDictValues(unionStructs), "\n\n"), [], imports)
 
 
 class Argument():
@@ -1889,7 +1887,7 @@ class CGIDLInterface(CGThing):
         }
         return string.Template("""
 impl IDLInterface for ${type} {
-    fn get_prototype_id(_: Option<${type}>) -> PrototypeList::id::ID {
+    fn get_prototype_id(_: Option<${type}>) -> PrototypeList::id {
         PrototypeList::id::${type}
     }
     fn get_prototype_depth(_: Option<${type}>) -> uint {
@@ -2753,35 +2751,36 @@ def getEnumValueName(value):
 class CGEnum(CGThing):
     def __init__(self, enum):
         CGThing.__init__(self)
-        inner = """
-use dom::bindings::conversions::ToJSValConvertible;
-use js::jsapi::JSContext;
-use js::jsval::JSVal;
 
+        decl = """
 #[repr(uint)]
 #[deriving(PartialEq)]
 #[jstraceable]
-pub enum valuelist {
+pub enum %s {
   %s
 }
+""" % (enum.identifier.name, ",\n  ".join(map(getEnumValueName, enum.values())))
+
+        inner = """
+use dom::bindings::conversions::ToJSValConvertible;
+use js::jsapi::JSContext;
+use js::jsval::JSVal;
 
 pub const strings: &'static [&'static str] = &[
   %s,
 ];
 
-impl ToJSValConvertible for valuelist {
+impl ToJSValConvertible for super::%s {
   fn to_jsval(&self, cx: *mut JSContext) -> JSVal {
     strings[*self as uint].to_string().to_jsval(cx)
   }
 }
-""" % (",\n  ".join(map(getEnumValueName, enum.values())),
-       ",\n  ".join(['"%s"' % val for val in enum.values()]))
+""" % (",\n  ".join(['"%s"' % val for val in enum.values()]), enum.identifier.name)
 
         self.cgRoot = CGList([
+            CGGeneric(decl),
             CGNamespace.build([enum.identifier.name + "Values"],
                               CGIndenter(CGGeneric(inner)), public=True),
-            CGGeneric("pub type %s = self::%sValues::valuelist;\n" %
-                                      (enum.identifier.name, enum.identifier.name)),
         ])
 
     def define(self):
@@ -2876,7 +2875,7 @@ class CGUnionStruct(CGThing):
             "    e%s(%s)," % (v["name"], v["typeName"]) for v in templateVars
         ]
         enumConversions = [
-            "            e%s(ref inner) => inner.to_jsval(cx)," % v["name"] for v in templateVars
+            "            %s::e%s(ref inner) => inner.to_jsval(cx)," % (self.type, v["name"]) for v in templateVars
         ]
         # XXXManishearth The following should be #[must_root],
         # however we currently allow it till #2661 is fixed
@@ -2922,9 +2921,9 @@ class CGUnionConversionStruct(CGThing):
                 return (
                     "match %s::TryConvertTo%s(cx, value) {\n"
                     "    Err(_) => return Err(()),\n"
-                    "    Ok(Some(value)) => return Ok(e%s(value)),\n"
+                    "    Ok(Some(value)) => return Ok(%s::e%s(value)),\n"
                     "    Ok(None) => (),\n"
-                    "}\n") % (self.type, name, name)
+                    "}\n") % (self.type, name, self.type, name)
 
             typeNames = [get_name(memberType) for memberType in interfaceMemberTypes]
             interfaceObject = CGList(CGGeneric(get_match(typeName)) for typeName in typeNames)
@@ -2990,9 +2989,9 @@ class CGUnionConversionStruct(CGThing):
             match = (
                     "match %s::TryConvertTo%s(cx, value) {\n"
                     "    Err(_) => return Err(()),\n"
-                    "    Ok(Some(value)) => return Ok(e%s(value)),\n"
+                    "    Ok(Some(value)) => return Ok(%s::e%s(value)),\n"
                     "    Ok(None) => (),\n"
-                    "}\n") % (self.type, name, name)
+                    "}\n") % (self.type, name, self.type, name)
             conversions.append(CGGeneric(match))
             names.append(name)
 
@@ -4182,8 +4181,8 @@ class CGDescriptor(CGThing):
     def define(self):
         return self.cgRoot.define()
 
-class CGNamespacedEnum(CGThing):
-    def __init__(self, namespace, enumName, names, values, comment="", deriving=""):
+class CGNonNamespacedEnum(CGThing):
+    def __init__(self, enumName, names, values, comment="", deriving=""):
 
         if not values:
             values = []
@@ -4198,7 +4197,7 @@ class CGNamespacedEnum(CGThing):
             entries.append(entry)
 
         # Append a Count.
-        entries.append(enumName + 'Count = ' + str(len(entries)))
+        entries.append('Count = ' + str(len(entries)))
 
         # Indent.
         entries = ['  ' + e for e in entries]
@@ -4212,9 +4211,6 @@ class CGNamespacedEnum(CGThing):
         # Add some whitespace padding.
         curr = CGWrapper(curr, pre='\n',post='\n')
 
-        # Add the namespace.
-        curr = CGNamespace(namespace, curr, public=True)
-
         # Add the typedef
         #typedef = '\ntypedef %s::%s %s;\n\n' % (namespace, enumName, enumName)
         #curr = CGList([curr, CGGeneric(typedef)])
@@ -4504,23 +4500,25 @@ class CGBindingRoot(CGThing):
             'dom::bindings::utils::{DOMJSClass, JSCLASS_DOM_GLOBAL}',
             'dom::bindings::utils::{FindEnumStringIndex, GetArrayIndexFromId}',
             'dom::bindings::utils::{GetPropertyOnPrototype, GetProtoOrIfaceArray}',
-            'dom::bindings::utils::{HasPropertyOnPrototype, IntVal, UintVal}',
+            'dom::bindings::utils::HasPropertyOnPrototype',
             'dom::bindings::utils::{Reflectable}',
             'dom::bindings::utils::{squirrel_away_unique}',
             'dom::bindings::utils::{ThrowingConstructor,  unwrap, unwrap_jsmanaged}',
             'dom::bindings::utils::get_dictionary_property',
             'dom::bindings::utils::{NativeProperties, NativePropertyHooks}',
+            'dom::bindings::utils::ConstantVal::{IntVal, UintVal}',
             'dom::bindings::trace::JSTraceable',
             'dom::bindings::callback::{CallbackContainer,CallbackInterface,CallbackFunction}',
             'dom::bindings::callback::{CallSetup,ExceptionHandling}',
             'dom::bindings::callback::{WrapCallThisObject}',
             'dom::bindings::conversions::{FromJSValConvertible, ToJSValConvertible}',
             'dom::bindings::conversions::IDLInterface',
-            'dom::bindings::conversions::{Default, Empty}',
             'dom::bindings::conversions::jsid_to_str',
+            'dom::bindings::conversions::StringificationBehavior::{Default, Empty}',
             'dom::bindings::codegen::{PrototypeList, RegisterBindings, UnionTypes}',
             'dom::bindings::codegen::Bindings::*',
-            'dom::bindings::error::{FailureUnknown, Fallible, Error, ErrorResult}',
+            'dom::bindings::error::{Fallible, Error, ErrorResult}',
+            'dom::bindings::error::Error::FailureUnknown',
             'dom::bindings::error::throw_dom_exception',
             'dom::bindings::error::throw_type_error',
             'dom::bindings::proxyhandler',
@@ -5137,8 +5135,8 @@ class GlobalGenRoots():
         return CGList([
             CGGeneric(AUTOGENERATED_WARNING_COMMENT),
             CGGeneric("pub const MAX_PROTO_CHAIN_LENGTH: uint = %d;\n\n" % config.maxProtoChainLength),
-            CGNamespacedEnum('id', 'ID', protos, [0], deriving="PartialEq"),
-            CGNamespacedEnum('proxies', 'Proxy', proxies, [0], deriving="PartialEq"),
+            CGNonNamespacedEnum('id', protos, [0], deriving="PartialEq"),
+            CGNonNamespacedEnum('proxies', proxies, [0], deriving="PartialEq"),
         ])
 
 
diff --git a/components/script/dom/bindings/conversions.rs b/components/script/dom/bindings/conversions.rs
index 596b722c77d..925311619a4 100644
--- a/components/script/dom/bindings/conversions.rs
+++ b/components/script/dom/bindings/conversions.rs
@@ -37,7 +37,7 @@ use dom::bindings::codegen::PrototypeList;
 //       remove Option<Self> arguments.
 pub trait IDLInterface {
     /// Returns the prototype ID.
-    fn get_prototype_id(_: Option<Self>) -> PrototypeList::id::ID;
+    fn get_prototype_id(_: Option<Self>) -> PrototypeList::id;
     /// Returns the prototype depth, i.e., the number of interfaces this
     /// interface inherits from.
     fn get_prototype_depth(_: Option<Self>) -> uint;
@@ -256,7 +256,7 @@ pub enum StringificationBehavior {
 
 impl default::Default for StringificationBehavior {
     fn default() -> StringificationBehavior {
-        Default
+        StringificationBehavior::Default
     }
 }
 
@@ -283,7 +283,7 @@ pub fn jsid_to_str(cx: *mut JSContext, id: jsid) -> DOMString {
 
 impl FromJSValConvertible<StringificationBehavior> for DOMString {
     fn from_jsval(cx: *mut JSContext, value: JSVal, nullBehavior: StringificationBehavior) -> Result<DOMString, ()> {
-        if nullBehavior == Empty && value.is_null() {
+        if nullBehavior == StringificationBehavior::Empty && value.is_null() {
             Ok("".to_string())
         } else {
             let jsstr = unsafe { JS_ValueToString(cx, value) };
diff --git a/components/script/dom/bindings/global.rs b/components/script/dom/bindings/global.rs
index 7f7e225a63b..549104856f9 100644
--- a/components/script/dom/bindings/global.rs
+++ b/components/script/dom/bindings/global.rs
@@ -7,6 +7,10 @@
 //! This module contains smart pointers to global scopes, to simplify writing
 //! code that works in workers as well as window scopes.
 
+pub use self::GlobalRef::*;
+pub use self::GlobalRoot::*;
+pub use self::GlobalField::*;
+
 use dom::bindings::conversions::FromJSValConvertible;
 use dom::bindings::js::{JS, JSRef, Root};
 use dom::bindings::utils::{Reflectable, Reflector};
diff --git a/components/script/dom/bindings/str.rs b/components/script/dom/bindings/str.rs
index a06aaed5ec4..0882b3538e2 100644
--- a/components/script/dom/bindings/str.rs
+++ b/components/script/dom/bindings/str.rs
@@ -4,9 +4,9 @@
 
 //! The `ByteString` struct.
 
-use std::from_str::FromStr;
 use std::hash::{Hash, sip};
 use std::str;
+use std::str::FromStr;
 
 /// Encapsulates the IDL `ByteString` type.
 #[deriving(Clone,Eq,PartialEq)]
@@ -89,31 +89,31 @@ impl ByteString {
             SPHT // SP or HT
         }
         let ByteString(ref vec) = *self;
-        let mut prev = Other; // The previous character
+        let mut prev = PreviousCharacter::Other; // The previous character
         vec.iter().all(|&x| {
             // http://tools.ietf.org/html/rfc2616#section-2.2
             match x {
                 13  => { // CR
-                    if prev == Other || prev == SPHT {
-                        prev = CR;
+                    if prev == PreviousCharacter::Other || prev == PreviousCharacter::SPHT {
+                        prev = PreviousCharacter::CR;
                         true
                     } else {
                         false
                     }
                 },
                 10 => { // LF
-                    if prev == CR {
-                        prev = LF;
+                    if prev == PreviousCharacter::CR {
+                        prev = PreviousCharacter::LF;
                         true
                     } else {
                         false
                     }
                 },
                 32 => { // SP
-                    if prev == LF || prev == SPHT {
-                        prev = SPHT;
+                    if prev == PreviousCharacter::LF || prev == PreviousCharacter::SPHT {
+                        prev = PreviousCharacter::SPHT;
                         true
-                    } else if prev == Other {
+                    } else if prev == PreviousCharacter::Other {
                         // Counts as an Other here, since it's not preceded by a CRLF
                         // SP is not a CTL, so it can be used anywhere
                         // though if used immediately after a CR the CR is invalid
@@ -124,8 +124,8 @@ impl ByteString {
                     }
                 },
                 9 => { // HT
-                    if prev == LF || prev == SPHT {
-                        prev = SPHT;
+                    if prev == PreviousCharacter::LF || prev == PreviousCharacter::SPHT {
+                        prev = PreviousCharacter::SPHT;
                         true
                     } else {
                         false
@@ -133,8 +133,8 @@ impl ByteString {
                 },
                 0...31 | 127 => false, // CTLs
                 x if x > 127 => false, // non ASCII
-                _ if prev == Other || prev == SPHT => {
-                    prev = Other;
+                _ if prev == PreviousCharacter::Other || prev == PreviousCharacter::SPHT => {
+                    prev = PreviousCharacter::Other;
                     true
                 },
                 _ => false // Previous character was a CR/LF but not part of the [CRLF] (SP|HT) rule
diff --git a/components/script/dom/bindings/utils.rs b/components/script/dom/bindings/utils.rs
index cf7561d4e79..a08b664b3dd 100644
--- a/components/script/dom/bindings/utils.rs
+++ b/components/script/dom/bindings/utils.rs
@@ -124,7 +124,7 @@ pub unsafe fn get_dom_class(obj: *mut JSObject) -> Result<DOMClass, ()> {
 /// not a reflector for a DOM object of the given type (as defined by the
 /// proto_id and proto_depth).
 pub fn unwrap_jsmanaged<T: Reflectable>(mut obj: *mut JSObject,
-                                        proto_id: PrototypeList::id::ID,
+                                        proto_id: PrototypeList::id,
                                         proto_depth: uint) -> Result<JS<T>, ()> {
     unsafe {
         let dom_class = get_dom_class(obj).or_else(|_| {
@@ -212,11 +212,11 @@ impl ConstantSpec {
     /// Returns a `JSVal` that represents the value of this `ConstantSpec`.
     pub fn get_value(&self) -> JSVal {
         match self.value {
-            NullVal => NullValue(),
-            IntVal(i) => Int32Value(i),
-            UintVal(u) => UInt32Value(u),
-            DoubleVal(d) => DoubleValue(d),
-            BoolVal(b) => BooleanValue(b),
+            ConstantVal::NullVal => NullValue(),
+            ConstantVal::IntVal(i) => Int32Value(i),
+            ConstantVal::UintVal(u) => UInt32Value(u),
+            ConstantVal::DoubleVal(d) => DoubleValue(d),
+            ConstantVal::BoolVal(b) => BooleanValue(b),
         }
     }
 }
@@ -234,7 +234,7 @@ pub struct NativePropertyHooks {
 pub struct DOMClass {
     /// A list of interfaces that this object implements, in order of decreasing
     /// derivedness.
-    pub interface_chain: [PrototypeList::id::ID, ..MAX_PROTO_CHAIN_LENGTH],
+    pub interface_chain: [PrototypeList::id, ..MAX_PROTO_CHAIN_LENGTH],
 
     /// The NativePropertyHooks for the interface associated with this class.
     pub native_hooks: &'static NativePropertyHooks,
@@ -421,7 +421,7 @@ pub unsafe extern fn ThrowingConstructor(cx: *mut JSContext, _argc: c_uint, _vp:
 /// Construct and cache the ProtoOrIfaceArray for the given global.
 /// Fails if the argument is not a DOM global.
 pub fn initialize_global(global: *mut JSObject) {
-    let protoArray = box () ([0 as *mut JSObject, ..PrototypeList::id::IDCount as uint]);
+    let protoArray = box () ([0 as *mut JSObject, ..PrototypeList::id::Count as uint]);
     unsafe {
         assert!(((*JS_GetClass(global)).flags & JSCLASS_DOM_GLOBAL) != 0);
         let box_ = squirrel_away_unique(protoArray);
@@ -722,10 +722,10 @@ pub fn xml_name_type(name: &str) -> XMLName {
     let mut non_qname_colons = false;
     let mut seen_colon = false;
     match iter.next() {
-        None => return InvalidXMLName,
+        None => return XMLName::InvalidXMLName,
         Some(c) => {
             if !is_valid_start(c) {
-                return InvalidXMLName;
+                return XMLName::InvalidXMLName;
             }
             if c == ':' {
                 non_qname_colons = true;
@@ -735,7 +735,7 @@ pub fn xml_name_type(name: &str) -> XMLName {
 
     for c in name.chars() {
         if !is_valid_continuation(c) {
-            return InvalidXMLName;
+            return XMLName::InvalidXMLName;
         }
         if c == ':' {
             match seen_colon {
@@ -746,7 +746,7 @@ pub fn xml_name_type(name: &str) -> XMLName {
     }
 
     match non_qname_colons {
-        false => QName,
-        true => Name
+        false => XMLName::QName,
+        true => XMLName::Name
     }
 }
diff --git a/components/script/dom/blob.rs b/components/script/dom/blob.rs
index cbe98b13a47..e51eca2d186 100644
--- a/components/script/dom/blob.rs
+++ b/components/script/dom/blob.rs
@@ -14,15 +14,15 @@ use servo_util::str::DOMString;
 use std::cmp::{min, max};
 
 #[jstraceable]
-pub enum BlobType {
-    BlobTypeId,
-    FileTypeId
+pub enum BlobTypeId {
+    Blob,
+    File,
 }
 
 #[dom_struct]
 pub struct Blob {
     reflector_: Reflector,
-    type_: BlobType,
+    type_: BlobTypeId,
     bytes: Option<Vec<u8>>,
     typeString: DOMString,
     global: GlobalField
@@ -30,7 +30,7 @@ pub struct Blob {
 }
 
 impl Blob {
-    pub fn new_inherited(global: &GlobalRef, type_: BlobType,
+    pub fn new_inherited(global: &GlobalRef, type_: BlobTypeId,
                          bytes: Option<Vec<u8>>) -> Blob {
         Blob {
             reflector_: Reflector::new(),
@@ -43,7 +43,7 @@ impl Blob {
     }
 
     pub fn new(global: &GlobalRef, bytes: Option<Vec<u8>>) -> Temporary<Blob> {
-        reflect_dom_object(box Blob::new_inherited(global, BlobTypeId, bytes),
+        reflect_dom_object(box Blob::new_inherited(global, BlobTypeId::Blob, bytes),
                            *global,
                            BlobBinding::Wrap)
     }
@@ -133,7 +133,7 @@ impl Reflectable for Blob {
 impl FileDerived for Blob {
     fn is_file(&self) -> bool {
         match self.type_ {
-            FileTypeId => true,
+            BlobTypeId::File => true,
             _ => false
         }
     }
diff --git a/components/script/dom/characterdata.rs b/components/script/dom/characterdata.rs
index f1331ceacd4..91bb1de46c2 100644
--- a/components/script/dom/characterdata.rs
+++ b/components/script/dom/characterdata.rs
@@ -7,12 +7,13 @@
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::CharacterDataBinding::CharacterDataMethods;
 use dom::bindings::codegen::InheritTypes::{CharacterDataDerived, NodeCast};
-use dom::bindings::error::{Fallible, ErrorResult, IndexSize};
+use dom::bindings::error::{Fallible, ErrorResult};
+use dom::bindings::error::Error::IndexSize;
 use dom::bindings::js::JSRef;
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
-use dom::node::{CommentNodeTypeId, Node, NodeTypeId, TextNodeTypeId, ProcessingInstructionNodeTypeId, NodeHelpers};
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
+use dom::node::{Node, NodeHelpers, NodeTypeId};
 
 use servo_util::str::DOMString;
 
@@ -27,9 +28,9 @@ pub struct CharacterData {
 impl CharacterDataDerived for EventTarget {
     fn is_characterdata(&self) -> bool {
         match *self.type_id() {
-            NodeTargetTypeId(TextNodeTypeId) |
-            NodeTargetTypeId(CommentNodeTypeId) |
-            NodeTargetTypeId(ProcessingInstructionNodeTypeId) => true,
+            EventTargetTypeId::Node(NodeTypeId::Text) |
+            EventTargetTypeId::Node(NodeTypeId::Comment) |
+            EventTargetTypeId::Node(NodeTypeId::ProcessingInstruction) => true,
             _ => false
         }
     }
diff --git a/components/script/dom/comment.rs b/components/script/dom/comment.rs
index e55483f39cd..11c7bf68b44 100644
--- a/components/script/dom/comment.rs
+++ b/components/script/dom/comment.rs
@@ -11,8 +11,8 @@ use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::characterdata::CharacterData;
 use dom::document::Document;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
-use dom::node::{CommentNodeTypeId, Node};
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 /// An HTML comment.
@@ -23,14 +23,14 @@ pub struct Comment {
 
 impl CommentDerived for EventTarget {
     fn is_comment(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(CommentNodeTypeId)
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Comment)
     }
 }
 
 impl Comment {
     fn new_inherited(text: DOMString, document: JSRef<Document>) -> Comment {
         Comment {
-            characterdata: CharacterData::new_inherited(CommentNodeTypeId, text, document)
+            characterdata: CharacterData::new_inherited(NodeTypeId::Comment, text, document)
         }
     }
 
diff --git a/components/script/dom/create.rs b/components/script/dom/create.rs
index 59b6bb756bc..1848df54a09 100644
--- a/components/script/dom/create.rs
+++ b/components/script/dom/create.rs
@@ -29,7 +29,7 @@ use dom::htmlformelement::HTMLFormElement;
 use dom::htmlframeelement::HTMLFrameElement;
 use dom::htmlframesetelement::HTMLFrameSetElement;
 use dom::htmlheadelement::HTMLHeadElement;
-use dom::htmlheadingelement::{Heading1, Heading2, Heading3, Heading4, Heading5, Heading6};
+use dom::htmlheadingelement::HeadingLevel::*;
 use dom::htmlheadingelement::HTMLHeadingElement;
 use dom::htmlhrelement::HTMLHRElement;
 use dom::htmlhtmlelement::HTMLHtmlElement;
diff --git a/components/script/dom/customevent.rs b/components/script/dom/customevent.rs
index 0f49f0c7d02..ee047e14c44 100644
--- a/components/script/dom/customevent.rs
+++ b/components/script/dom/customevent.rs
@@ -10,7 +10,7 @@ use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
-use dom::event::{Event, EventTypeId, CustomEventTypeId};
+use dom::event::{Event, EventTypeId};
 use js::jsapi::JSContext;
 use js::jsval::{JSVal, NullValue};
 use servo_util::str::DOMString;
@@ -25,7 +25,7 @@ pub struct CustomEvent {
 
 impl CustomEventDerived for Event {
     fn is_customevent(&self) -> bool {
-        *self.type_id() == CustomEventTypeId
+        *self.type_id() == EventTypeId::CustomEvent
     }
 }
 
@@ -38,7 +38,7 @@ impl CustomEvent {
     }
 
     pub fn new_uninitialized(global: GlobalRef) -> Temporary<CustomEvent> {
-        reflect_dom_object(box CustomEvent::new_inherited(CustomEventTypeId),
+        reflect_dom_object(box CustomEvent::new_inherited(EventTypeId::CustomEvent),
                            global,
                            CustomEventBinding::Wrap)
     }
diff --git a/components/script/dom/dedicatedworkerglobalscope.rs b/components/script/dom/dedicatedworkerglobalscope.rs
index 4a158f3673f..04211e9349d 100644
--- a/components/script/dom/dedicatedworkerglobalscope.rs
+++ b/components/script/dom/dedicatedworkerglobalscope.rs
@@ -7,20 +7,20 @@ use dom::bindings::codegen::Bindings::DedicatedWorkerGlobalScopeBinding::Dedicat
 use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
 use dom::bindings::codegen::InheritTypes::DedicatedWorkerGlobalScopeDerived;
 use dom::bindings::codegen::InheritTypes::{EventTargetCast, WorkerGlobalScopeCast};
-use dom::bindings::error::{ErrorResult, DataClone};
+use dom::bindings::error::ErrorResult;
+use dom::bindings::error::Error::DataClone;
 use dom::bindings::global;
 use dom::bindings::js::{JSRef, Temporary, RootCollection};
 use dom::bindings::utils::{Reflectable, Reflector};
-use dom::eventtarget::{EventTarget, EventTargetHelpers};
-use dom::eventtarget::WorkerGlobalScopeTypeId;
+use dom::eventtarget::{EventTarget, EventTargetHelpers, EventTargetTypeId};
 use dom::messageevent::MessageEvent;
 use dom::worker::{Worker, TrustedWorkerAddress};
-use dom::workerglobalscope::DedicatedGlobalScope;
 use dom::workerglobalscope::{WorkerGlobalScope, WorkerGlobalScopeHelpers};
+use dom::workerglobalscope::WorkerGlobalScopeTypeId;
 use dom::xmlhttprequest::XMLHttpRequest;
-use script_task::{ScriptTask, ScriptChan};
-use script_task::{ScriptMsg, FromWorker,  DOMMessage, FireTimerMsg, XHRProgressMsg, XHRReleaseMsg, WorkerRelease};
-use script_task::WorkerPostMessage;
+use script_task::{ScriptTask, ScriptChan, ScriptMsg, TimerSource};
+use script_task::ScriptMsg::{DOMMessage, FireTimerMsg, XHRProgressMsg};
+use script_task::ScriptMsg::{XHRReleaseMsg, WorkerRelease, WorkerPostMessage};
 use script_task::StackRootTLS;
 
 use servo_net::resource_task::{ResourceTask, load_whole_resource};
@@ -57,8 +57,8 @@ impl DedicatedWorkerGlobalScope {
                          -> DedicatedWorkerGlobalScope {
         DedicatedWorkerGlobalScope {
             workerglobalscope: WorkerGlobalScope::new_inherited(
-                DedicatedGlobalScope, worker_url, cx, resource_task,
-                own_sender),
+                WorkerGlobalScopeTypeId::DedicatedGlobalScope, worker_url, cx,
+                resource_task, own_sender),
             receiver: receiver,
             parent_sender: parent_sender,
             worker: worker,
@@ -145,7 +145,7 @@ impl DedicatedWorkerGlobalScope {
                     Ok(WorkerRelease(addr)) => {
                         Worker::handle_release(addr)
                     },
-                    Ok(FireTimerMsg(FromWorker, timer_id)) => {
+                    Ok(FireTimerMsg(TimerSource::FromWorker, timer_id)) => {
                         scope.handle_fire_timer(timer_id);
                     }
                     Ok(_) => panic!("Unexpected message"),
@@ -197,7 +197,7 @@ impl Reflectable for DedicatedWorkerGlobalScope {
 impl DedicatedWorkerGlobalScopeDerived for EventTarget {
     fn is_dedicatedworkerglobalscope(&self) -> bool {
         match *self.type_id() {
-            WorkerGlobalScopeTypeId(DedicatedGlobalScope) => true,
+            EventTargetTypeId::WorkerGlobalScope(WorkerGlobalScopeTypeId::DedicatedGlobalScope) => true,
             _ => false
         }
     }
diff --git a/components/script/dom/document.rs b/components/script/dom/document.rs
index 4fdb8a9befd..8f6dab404f7 100644
--- a/components/script/dom/document.rs
+++ b/components/script/dom/document.rs
@@ -2,11 +2,10 @@
  * 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::attr::{Attr, AttrHelpers, StringAttrValue};
+use dom::attr::{Attr, AttrHelpers, AttrValue};
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::DocumentBinding;
 use dom::bindings::codegen::Bindings::DocumentBinding::{DocumentMethods, DocumentReadyState};
-use dom::bindings::codegen::Bindings::DocumentBinding::DocumentReadyStateValues;
 use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
 use dom::bindings::codegen::Bindings::EventTargetBinding::EventTargetMethods;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
@@ -20,24 +19,25 @@ use dom::bindings::codegen::InheritTypes::{HTMLAnchorElementDerived, HTMLAppletE
 use dom::bindings::codegen::InheritTypes::{HTMLAreaElementDerived, HTMLEmbedElementDerived};
 use dom::bindings::codegen::InheritTypes::{HTMLFormElementDerived, HTMLImageElementDerived};
 use dom::bindings::codegen::InheritTypes::{HTMLScriptElementDerived};
-use dom::bindings::error::{ErrorResult, Fallible, NotSupported, InvalidCharacter};
-use dom::bindings::error::{HierarchyRequest, NamespaceError};
+use dom::bindings::error::{ErrorResult, Fallible};
+use dom::bindings::error::Error::{NotSupported, InvalidCharacter};
+use dom::bindings::error::Error::{HierarchyRequest, NamespaceError};
 use dom::bindings::global::GlobalRef;
 use dom::bindings::global;
 use dom::bindings::js::{MutNullableJS, JS, JSRef, Temporary, OptionalSettable, TemporaryPushable};
 use dom::bindings::js::OptionalRootable;
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
-use dom::bindings::utils::{xml_name_type, InvalidXMLName, Name, QName};
+use dom::bindings::utils::xml_name_type;
+use dom::bindings::utils::XMLName::{QName, Name, InvalidXMLName};
 use dom::comment::Comment;
 use dom::customevent::CustomEvent;
 use dom::documentfragment::DocumentFragment;
 use dom::documenttype::DocumentType;
 use dom::domimplementation::DOMImplementation;
-use dom::element::{Element, ScriptCreated, AttributeHandlers, get_attribute_parts};
-use dom::element::{HTMLHeadElementTypeId, HTMLTitleElementTypeId};
-use dom::element::{HTMLBodyElementTypeId, HTMLFrameSetElementTypeId};
-use dom::event::{Event, DoesNotBubble, NotCancelable};
-use dom::eventtarget::{EventTarget, NodeTargetTypeId, EventTargetHelpers};
+use dom::element::{Element, ElementCreator, AttributeHandlers, get_attribute_parts};
+use dom::element::ElementTypeId;
+use dom::event::{Event, EventBubbles, EventCancelable};
+use dom::eventtarget::{EventTarget, EventTargetTypeId, EventTargetHelpers};
 use dom::htmlanchorelement::HTMLAnchorElement;
 use dom::htmlcollection::{HTMLCollection, CollectionFilter};
 use dom::htmlelement::HTMLElement;
@@ -48,8 +48,7 @@ use dom::location::Location;
 use dom::mouseevent::MouseEvent;
 use dom::keyboardevent::KeyboardEvent;
 use dom::messageevent::MessageEvent;
-use dom::node::{Node, ElementNodeTypeId, DocumentNodeTypeId, NodeHelpers};
-use dom::node::{CloneChildren, DoNotCloneChildren, NodeDamage, OtherNodeDamage};
+use dom::node::{Node, NodeHelpers, NodeTypeId, CloneChildrenFlag, NodeDamage};
 use dom::nodelist::NodeList;
 use dom::text::Text;
 use dom::processinginstruction::ProcessingInstruction;
@@ -107,7 +106,7 @@ pub struct Document {
 
 impl DocumentDerived for EventTarget {
     fn is_document(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(DocumentNodeTypeId)
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Document)
     }
 }
 
@@ -341,7 +340,8 @@ impl<'a> DocumentHelpers<'a> for JSRef<'a, Document> {
 
         let window = self.window.root();
         let event = Event::new(global::Window(*window), "readystatechange".to_string(),
-                               DoesNotBubble, NotCancelable).root();
+                               EventBubbles::DoesNotBubble,
+                               EventCancelable::NotCancelable).root();
         let target: JSRef<EventTarget> = EventTargetCast::from_ref(self);
         let _ = target.DispatchEvent(*event);
     }
@@ -379,7 +379,7 @@ impl<'a> DocumentHelpers<'a> for JSRef<'a, Document> {
     fn dirty_all_nodes(self) {
         let root: JSRef<Node> = NodeCast::from_ref(self);
         for node in root.traverse_preorder() {
-            node.dirty(OtherNodeDamage)
+            node.dirty(NodeDamage::OtherNodeDamage)
         }
     }
 }
@@ -410,14 +410,14 @@ impl Document {
                      source: DocumentSource) -> Document {
         let url = url.unwrap_or_else(|| Url::parse("about:blank").unwrap());
 
-        let ready_state = if source == FromParser {
-            DocumentReadyStateValues::Loading
+        let ready_state = if source == DocumentSource::FromParser {
+            DocumentReadyState::Loading
         } else {
-            DocumentReadyStateValues::Complete
+            DocumentReadyState::Complete
         };
 
         Document {
-            node: Node::new_without_doc(DocumentNodeTypeId),
+            node: Node::new_without_doc(NodeTypeId::Document),
             window: JS::from_rooted(window),
             idmap: DOMRefCell::new(HashMap::new()),
             implementation: Default::default(),
@@ -425,9 +425,9 @@ impl Document {
                 Some(string) => string.clone(),
                 None => match is_html_document {
                     // http://dom.spec.whatwg.org/#dom-domimplementation-createhtmldocument
-                    HTMLDocument => "text/html".to_string(),
+                    IsHTMLDocument::HTMLDocument => "text/html".to_string(),
                     // http://dom.spec.whatwg.org/#concept-document-content-type
-                    NonHTMLDocument => "application/xml".to_string()
+                    IsHTMLDocument::NonHTMLDocument => "application/xml".to_string()
                 }
             },
             last_modified: DOMRefCell::new(None),
@@ -436,7 +436,7 @@ impl Document {
             quirks_mode: Cell::new(NoQuirks),
             // http://dom.spec.whatwg.org/#concept-document-encoding
             encoding_name: DOMRefCell::new("UTF-8".to_string()),
-            is_html_document: is_html_document == HTMLDocument,
+            is_html_document: is_html_document == IsHTMLDocument::HTMLDocument,
             images: Default::default(),
             embeds: Default::default(),
             links: Default::default(),
@@ -452,7 +452,9 @@ impl Document {
 
     // http://dom.spec.whatwg.org/#dom-document
     pub fn Constructor(global: &GlobalRef) -> Fallible<Temporary<Document>> {
-        Ok(Document::new(global.as_window(), None, NonHTMLDocument, None, NotFromParser))
+        Ok(Document::new(global.as_window(), None,
+                         IsHTMLDocument::NonHTMLDocument, None,
+                         DocumentSource::NotFromParser))
     }
 
     pub fn new(window: JSRef<Window>,
@@ -596,7 +598,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
             local_name
         };
         let name = QualName::new(ns!(HTML), Atom::from_slice(local_name.as_slice()));
-        Ok(Element::create(name, None, self, ScriptCreated))
+        Ok(Element::create(name, None, self, ElementCreator::ScriptCreated))
     }
 
     // http://dom.spec.whatwg.org/#dom-document-createelementns
@@ -641,7 +643,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
 
         let name = QualName::new(ns, Atom::from_slice(local_name_from_qname));
         Ok(Element::create(name, prefix_from_qname.map(|s| s.to_string()), self,
-                           ScriptCreated))
+                           ElementCreator::ScriptCreated))
     }
 
     // http://dom.spec.whatwg.org/#dom-document-createattribute
@@ -655,7 +657,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
         let name = Atom::from_slice(local_name.as_slice());
         // repetition used because string_cache::atom::Atom is non-copyable
         let l_name = Atom::from_slice(local_name.as_slice());
-        let value = StringAttrValue("".to_string());
+        let value = AttrValue::String("".to_string());
 
         Ok(Attr::new(*window, name, value, l_name, ns!(""), None, None))
     }
@@ -702,8 +704,8 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
 
         // Step 2.
         let clone_children = match deep {
-            true => CloneChildren,
-            false => DoNotCloneChildren
+            true => CloneChildrenFlag::CloneChildren,
+            false => CloneChildrenFlag::DoNotCloneChildren
         };
 
         Ok(Node::clone(node, Some(self), clone_children))
@@ -748,7 +750,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
     fn LastModified(self) -> DOMString {
         match *self.last_modified.borrow() {
             Some(ref t) => t.clone(),
-            None => time::now().strftime("%m/%d/%Y %H:%M:%S").unwrap(),
+            None => format!("{}", time::now().strftime("%m/%d/%Y %H:%M:%S").unwrap()),
         }
     }
 
@@ -769,7 +771,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
         self.GetDocumentElement().root().map(|root| {
             let root: JSRef<Node> = NodeCast::from_ref(*root);
             root.traverse_preorder()
-                .find(|node| node.type_id() == ElementNodeTypeId(HTMLTitleElementTypeId))
+                .find(|node| node.type_id() == NodeTypeId::Element(ElementTypeId::HTMLTitleElement))
                 .map(|title_elem| {
                     for text in title_elem.children().filter_map::<JSRef<Text>>(TextCast::to_ref) {
                         title.push_str(text.characterdata().data().as_slice());
@@ -785,11 +787,11 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
         self.GetDocumentElement().root().map(|root| {
             let root: JSRef<Node> = NodeCast::from_ref(*root);
             let head_node = root.traverse_preorder().find(|child| {
-                child.type_id() == ElementNodeTypeId(HTMLHeadElementTypeId)
+                child.type_id() == NodeTypeId::Element(ElementTypeId::HTMLHeadElement)
             });
             head_node.map(|head| {
                 let title_node = head.children().find(|child| {
-                    child.type_id() == ElementNodeTypeId(HTMLTitleElementTypeId)
+                    child.type_id() == NodeTypeId::Element(ElementTypeId::HTMLTitleElement)
                 });
 
                 match title_node {
@@ -834,8 +836,8 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
             let node: JSRef<Node> = NodeCast::from_ref(*root);
             node.children().find(|child| {
                 match child.type_id() {
-                    ElementNodeTypeId(HTMLBodyElementTypeId) |
-                    ElementNodeTypeId(HTMLFrameSetElementTypeId) => true,
+                    NodeTypeId::Element(ElementTypeId::HTMLBodyElement) |
+                    NodeTypeId::Element(ElementTypeId::HTMLFrameSetElement) => true,
                     _ => false
                 }
             }).map(|node| {
@@ -854,8 +856,8 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
 
         let node: JSRef<Node> = NodeCast::from_ref(new_body);
         match node.type_id() {
-            ElementNodeTypeId(HTMLBodyElementTypeId) |
-            ElementNodeTypeId(HTMLFrameSetElementTypeId) => {}
+            NodeTypeId::Element(ElementTypeId::HTMLBodyElement) |
+            NodeTypeId::Element(ElementTypeId::HTMLFrameSetElement) => {}
             _ => return Err(HierarchyRequest)
         }
 
diff --git a/components/script/dom/documentfragment.rs b/components/script/dom/documentfragment.rs
index 65fa818e033..951aac09351 100644
--- a/components/script/dom/documentfragment.rs
+++ b/components/script/dom/documentfragment.rs
@@ -12,9 +12,9 @@ use dom::bindings::global::GlobalRef;
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
 use dom::element::Element;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlcollection::HTMLCollection;
-use dom::node::{DocumentFragmentNodeTypeId, Node, NodeHelpers, window_from_node};
+use dom::node::{Node, NodeHelpers, NodeTypeId, window_from_node};
 use dom::nodelist::NodeList;
 use servo_util::str::DOMString;
 
@@ -25,7 +25,7 @@ pub struct DocumentFragment {
 
 impl DocumentFragmentDerived for EventTarget {
     fn is_documentfragment(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(DocumentFragmentNodeTypeId)
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::DocumentFragment)
     }
 }
 
@@ -33,7 +33,7 @@ impl DocumentFragment {
     /// Creates a new DocumentFragment.
     fn new_inherited(document: JSRef<Document>) -> DocumentFragment {
         DocumentFragment {
-            node: Node::new_inherited(DocumentFragmentNodeTypeId, document),
+            node: Node::new_inherited(NodeTypeId::DocumentFragment, document),
         }
     }
 
diff --git a/components/script/dom/documenttype.rs b/components/script/dom/documenttype.rs
index f293208d1f9..9bd1357553a 100644
--- a/components/script/dom/documenttype.rs
+++ b/components/script/dom/documenttype.rs
@@ -8,8 +8,8 @@ use dom::bindings::codegen::InheritTypes::{DocumentTypeDerived, NodeCast};
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
-use dom::node::{Node, DoctypeNodeTypeId, NodeHelpers};
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
+use dom::node::{Node, NodeHelpers, NodeTypeId};
 use servo_util::str::DOMString;
 
 /// The `DOCTYPE` tag.
@@ -23,7 +23,7 @@ pub struct DocumentType {
 
 impl DocumentTypeDerived for EventTarget {
     fn is_documenttype(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(DoctypeNodeTypeId)
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::DocumentType)
     }
 }
 
@@ -34,7 +34,7 @@ impl DocumentType {
                          document: JSRef<Document>)
             -> DocumentType {
         DocumentType {
-            node: Node::new_inherited(DoctypeNodeTypeId, document),
+            node: Node::new_inherited(NodeTypeId::DocumentType, document),
             name: name,
             public_id: public_id.unwrap_or("".to_string()),
             system_id: system_id.unwrap_or("".to_string())
diff --git a/components/script/dom/domexception.rs b/components/script/dom/domexception.rs
index 50aafb6eedb..1d6906f1be6 100644
--- a/components/script/dom/domexception.rs
+++ b/components/script/dom/domexception.rs
@@ -5,7 +5,6 @@
 use dom::bindings::codegen::Bindings::DOMExceptionBinding;
 use dom::bindings::codegen::Bindings::DOMExceptionBinding::DOMExceptionConstants;
 use dom::bindings::codegen::Bindings::DOMExceptionBinding::DOMExceptionMethods;
-use dom::bindings::error;
 use dom::bindings::error::Error;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JSRef, Temporary};
@@ -42,21 +41,21 @@ pub enum DOMErrorName {
 impl DOMErrorName {
     fn from_error(error: Error) -> DOMErrorName {
         match error {
-            error::IndexSize => IndexSizeError,
-            error::NotFound => NotFoundError,
-            error::HierarchyRequest => HierarchyRequestError,
-            error::InvalidCharacter => InvalidCharacterError,
-            error::NotSupported => NotSupportedError,
-            error::InvalidState => InvalidStateError,
-            error::Syntax => SyntaxError,
-            error::NamespaceError => NamespaceError,
-            error::InvalidAccess => InvalidAccessError,
-            error::Security => SecurityError,
-            error::Network => NetworkError,
-            error::Abort => AbortError,
-            error::Timeout => TimeoutError,
-            error::DataClone => DataCloneError,
-            error::FailureUnknown => panic!(),
+            Error::IndexSize => DOMErrorName::IndexSizeError,
+            Error::NotFound => DOMErrorName::NotFoundError,
+            Error::HierarchyRequest => DOMErrorName::HierarchyRequestError,
+            Error::InvalidCharacter => DOMErrorName::InvalidCharacterError,
+            Error::NotSupported => DOMErrorName::NotSupportedError,
+            Error::InvalidState => DOMErrorName::InvalidStateError,
+            Error::Syntax => DOMErrorName::SyntaxError,
+            Error::NamespaceError => DOMErrorName::NamespaceError,
+            Error::InvalidAccess => DOMErrorName::InvalidAccessError,
+            Error::Security => DOMErrorName::SecurityError,
+            Error::Network => DOMErrorName::NetworkError,
+            Error::Abort => DOMErrorName::AbortError,
+            Error::Timeout => DOMErrorName::TimeoutError,
+            Error::DataClone => DOMErrorName::DataCloneError,
+            Error::FailureUnknown => panic!(),
         }
     }
 }
@@ -95,7 +94,7 @@ impl<'a> DOMExceptionMethods for JSRef<'a, DOMException> {
     fn Code(self) -> u16 {
         match self.code {
             // http://dom.spec.whatwg.org/#concept-throw
-            EncodingError => 0,
+            DOMErrorName::EncodingError => 0,
             code => code as u16
         }
     }
@@ -108,27 +107,27 @@ impl<'a> DOMExceptionMethods for JSRef<'a, DOMException> {
     // http://dom.spec.whatwg.org/#error-names-0
     fn Message(self) -> DOMString {
         let message = match self.code {
-            IndexSizeError => "The index is not in the allowed range.",
-            HierarchyRequestError => "The operation would yield an incorrect node tree.",
-            WrongDocumentError => "The object is in the wrong document.",
-            InvalidCharacterError => "The string contains invalid characters.",
-            NoModificationAllowedError => "The object can not be modified.",
-            NotFoundError => "The object can not be found here.",
-            NotSupportedError => "The operation is not supported.",
-            InvalidStateError => "The object is in an invalid state.",
-            SyntaxError => "The string did not match the expected pattern.",
-            InvalidModificationError => "The object can not be modified in this way.",
-            NamespaceError => "The operation is not allowed by Namespaces in XML.",
-            InvalidAccessError => "The object does not support the operation or argument.",
-            SecurityError => "The operation is insecure.",
-            NetworkError => "A network error occurred.",
-            AbortError => "The operation was aborted.",
-            URLMismatchError => "The given URL does not match another URL.",
-            QuotaExceededError => "The quota has been exceeded.",
-            TimeoutError => "The operation timed out.",
-            InvalidNodeTypeError => "The supplied node is incorrect or has an incorrect ancestor for this operation.",
-            DataCloneError => "The object can not be cloned.",
-            EncodingError => "The encoding operation (either encoded or decoding) failed."
+            DOMErrorName::IndexSizeError => "The index is not in the allowed range.",
+            DOMErrorName::HierarchyRequestError => "The operation would yield an incorrect node tree.",
+            DOMErrorName::WrongDocumentError => "The object is in the wrong document.",
+            DOMErrorName::InvalidCharacterError => "The string contains invalid characters.",
+            DOMErrorName::NoModificationAllowedError => "The object can not be modified.",
+            DOMErrorName::NotFoundError => "The object can not be found here.",
+            DOMErrorName::NotSupportedError => "The operation is not supported.",
+            DOMErrorName::InvalidStateError => "The object is in an invalid state.",
+            DOMErrorName::SyntaxError => "The string did not match the expected pattern.",
+            DOMErrorName::InvalidModificationError => "The object can not be modified in this way.",
+            DOMErrorName::NamespaceError => "The operation is not allowed by Namespaces in XML.",
+            DOMErrorName::InvalidAccessError => "The object does not support the operation or argument.",
+            DOMErrorName::SecurityError => "The operation is insecure.",
+            DOMErrorName::NetworkError => "A network error occurred.",
+            DOMErrorName::AbortError => "The operation was aborted.",
+            DOMErrorName::URLMismatchError => "The given URL does not match another URL.",
+            DOMErrorName::QuotaExceededError => "The quota has been exceeded.",
+            DOMErrorName::TimeoutError => "The operation timed out.",
+            DOMErrorName::InvalidNodeTypeError => "The supplied node is incorrect or has an incorrect ancestor for this operation.",
+            DOMErrorName::DataCloneError => "The object can not be cloned.",
+            DOMErrorName::EncodingError => "The encoding operation (either encoded or decoding) failed."
         };
 
         message.to_string()
diff --git a/components/script/dom/domimplementation.rs b/components/script/dom/domimplementation.rs
index 29e34d48b51..6e84e7a0194 100644
--- a/components/script/dom/domimplementation.rs
+++ b/components/script/dom/domimplementation.rs
@@ -7,13 +7,15 @@ use dom::bindings::codegen::Bindings::DOMImplementationBinding;
 use dom::bindings::codegen::Bindings::DOMImplementationBinding::DOMImplementationMethods;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
 use dom::bindings::codegen::InheritTypes::NodeCast;
-use dom::bindings::error::{Fallible, InvalidCharacter, NamespaceError};
+use dom::bindings::error::Fallible;
+use dom::bindings::error::Error::{InvalidCharacter, NamespaceError};
 use dom::bindings::global::Window;
 use dom::bindings::js::{JS, JSRef, Root, Temporary, OptionalRootable};
 use dom::bindings::utils::{Reflector, Reflectable, reflect_dom_object};
-use dom::bindings::utils::{QName, Name, InvalidXMLName, xml_name_type};
-use dom::document::{Document, DocumentHelpers, HTMLDocument, NonHTMLDocument};
-use dom::document::NotFromParser;
+use dom::bindings::utils::xml_name_type;
+use dom::bindings::utils::XMLName::{QName, Name, InvalidXMLName};
+use dom::document::{Document, DocumentHelpers, IsHTMLDocument};
+use dom::document::DocumentSource;
 use dom::documenttype::DocumentType;
 use dom::htmlbodyelement::HTMLBodyElement;
 use dom::htmlheadelement::HTMLHeadElement;
@@ -75,7 +77,8 @@ impl<'a> DOMImplementationMethods for JSRef<'a, DOMImplementation> {
         let win = doc.window().root();
 
         // Step 1.
-        let doc = Document::new(*win, None, NonHTMLDocument, None, NotFromParser).root();
+        let doc = Document::new(*win, None, IsHTMLDocument::NonHTMLDocument,
+                                None, DocumentSource::NotFromParser).root();
         // Step 2-3.
         let maybe_elem = if qname.is_empty() {
             None
@@ -120,7 +123,8 @@ impl<'a> DOMImplementationMethods for JSRef<'a, DOMImplementation> {
         let win = document.window().root();
 
         // Step 1-2.
-        let doc = Document::new(*win, None, HTMLDocument, None, NotFromParser).root();
+        let doc = Document::new(*win, None, IsHTMLDocument::HTMLDocument, None,
+                                DocumentSource::NotFromParser).root();
         let doc_node: JSRef<Node> = NodeCast::from_ref(*doc);
 
         {
diff --git a/components/script/dom/domparser.rs b/components/script/dom/domparser.rs
index fe543162da8..91d340aa791 100644
--- a/components/script/dom/domparser.rs
+++ b/components/script/dom/domparser.rs
@@ -2,17 +2,18 @@
  * 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::Bindings::DocumentBinding::DocumentReadyStateValues;
+use dom::bindings::codegen::Bindings::DocumentBinding::DocumentReadyState;
 use dom::bindings::codegen::Bindings::DOMParserBinding;
 use dom::bindings::codegen::Bindings::DOMParserBinding::DOMParserMethods;
-use dom::bindings::codegen::Bindings::DOMParserBinding::SupportedTypeValues::{Text_html, Text_xml};
-use dom::bindings::error::{Fallible, FailureUnknown};
+use dom::bindings::codegen::Bindings::DOMParserBinding::SupportedType::{Text_html, Text_xml};
+use dom::bindings::error::Fallible;
+use dom::bindings::error::Error::FailureUnknown;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::global;
 use dom::bindings::js::{JS, JSRef, Temporary};
 use dom::bindings::utils::{Reflector, Reflectable, reflect_dom_object};
-use dom::document::{Document, DocumentHelpers, HTMLDocument, NonHTMLDocument};
-use dom::document::{FromParser, NotFromParser};
+use dom::document::{Document, DocumentHelpers, IsHTMLDocument};
+use dom::document::DocumentSource;
 use dom::servohtmlparser::ServoHTMLParser;
 use dom::window::Window;
 use parse::Parser;
@@ -53,18 +54,22 @@ impl<'a> DOMParserMethods for JSRef<'a, DOMParser> {
         let content_type = DOMParserBinding::SupportedTypeValues::strings[ty as uint].to_string();
         match ty {
             Text_html => {
-                let document = Document::new(window, url.clone(), HTMLDocument,
-                                             Some(content_type), FromParser).root().clone();
+                let document = Document::new(window, url.clone(),
+                                             IsHTMLDocument::HTMLDocument,
+                                             Some(content_type),
+                                             DocumentSource::FromParser).root().clone();
                 let parser = ServoHTMLParser::new(url.clone(), document).root().clone();
                 parser.parse_chunk(s);
                 parser.finish();
-                document.set_ready_state(DocumentReadyStateValues::Complete);
+                document.set_ready_state(DocumentReadyState::Complete);
                 Ok(Temporary::from_rooted(document))
             }
             Text_xml => {
                 //FIXME: this should probably be FromParser when we actually parse the string (#3756).
-                Ok(Document::new(window, url.clone(), NonHTMLDocument, Some(content_type),
-                                 NotFromParser))
+                Ok(Document::new(window, url.clone(),
+                                 IsHTMLDocument::NonHTMLDocument,
+                                 Some(content_type),
+                                 DocumentSource::NotFromParser))
             }
             _ => {
                 Err(FailureUnknown)
diff --git a/components/script/dom/domrect.rs b/components/script/dom/domrect.rs
index e6c7b06ddfd..109e263061b 100644
--- a/components/script/dom/domrect.rs
+++ b/components/script/dom/domrect.rs
@@ -9,6 +9,7 @@ use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
 use dom::window::Window;
 use servo_util::geometry::Au;
+use std::num::Float;
 
 #[dom_struct]
 pub struct DOMRect {
diff --git a/components/script/dom/domtokenlist.rs b/components/script/dom/domtokenlist.rs
index 30318e0bd78..fecccad8fea 100644
--- a/components/script/dom/domtokenlist.rs
+++ b/components/script/dom/domtokenlist.rs
@@ -5,7 +5,8 @@
 use dom::attr::{Attr, AttrHelpers};
 use dom::bindings::codegen::Bindings::DOMTokenListBinding;
 use dom::bindings::codegen::Bindings::DOMTokenListBinding::DOMTokenListMethods;
-use dom::bindings::error::{Fallible, InvalidCharacter, Syntax};
+use dom::bindings::error::Fallible;
+use dom::bindings::error::Error::{InvalidCharacter, Syntax};
 use dom::bindings::global::Window;
 use dom::bindings::js::{JS, JSRef, Temporary, OptionalRootable};
 use dom::bindings::utils::{Reflector, Reflectable, reflect_dom_object};
diff --git a/components/script/dom/element.rs b/components/script/dom/element.rs
index a8beed315fe..ec97ee451e5 100644
--- a/components/script/dom/element.rs
+++ b/components/script/dom/element.rs
@@ -5,8 +5,8 @@
 //! Element nodes.
 
 use dom::activation::Activatable;
-use dom::attr::{Attr, ReplacedAttr, FirstSetAttr, AttrHelpers, AttrHelpersForLayout};
-use dom::attr::{AttrValue, StringAttrValue, UIntAttrValue, AtomAttrValue};
+use dom::attr::{Attr, AttrSettingType, AttrHelpers, AttrHelpersForLayout};
+use dom::attr::AttrValue;
 use dom::namednodemap::NamedNodeMap;
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::AttrBinding::AttrMethods;
@@ -21,18 +21,20 @@ use dom::bindings::codegen::InheritTypes::{HTMLInputElementDerived, HTMLTableEle
 use dom::bindings::codegen::InheritTypes::{HTMLTableElementDerived, HTMLTableCellElementDerived};
 use dom::bindings::codegen::InheritTypes::{HTMLTableRowElementDerived, HTMLTextAreaElementDerived};
 use dom::bindings::codegen::InheritTypes::{HTMLTableSectionElementDerived, NodeCast};
+use dom::bindings::error::{ErrorResult, Fallible};
+use dom::bindings::error::Error::{NamespaceError, InvalidCharacter, Syntax};
 use dom::bindings::js::{MutNullableJS, JS, JSRef, Temporary, TemporaryPushable};
 use dom::bindings::js::{OptionalRootable, Root};
 use dom::bindings::utils::{Reflectable, Reflector};
-use dom::bindings::error::{ErrorResult, Fallible, NamespaceError, InvalidCharacter, Syntax};
-use dom::bindings::utils::{QName, Name, InvalidXMLName, xml_name_type};
+use dom::bindings::utils::xml_name_type;
+use dom::bindings::utils::XMLName::{QName, Name, InvalidXMLName};
 use dom::create::create_element;
 use dom::domrect::DOMRect;
 use dom::domrectlist::DOMRectList;
 use dom::document::{Document, DocumentHelpers, LayoutDocumentHelpers};
 use dom::domtokenlist::DOMTokenList;
 use dom::event::Event;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId, EventTargetHelpers};
+use dom::eventtarget::{EventTarget, EventTargetTypeId, EventTargetHelpers};
 use dom::htmlbodyelement::{HTMLBodyElement, HTMLBodyElementHelpers};
 use dom::htmlcollection::HTMLCollection;
 use dom::htmlinputelement::{HTMLInputElement, RawLayoutHTMLInputElementHelpers, HTMLInputElementHelpers};
@@ -42,16 +44,14 @@ use dom::htmltablecellelement::{HTMLTableCellElement, HTMLTableCellElementHelper
 use dom::htmltablerowelement::{HTMLTableRowElement, HTMLTableRowElementHelpers};
 use dom::htmltablesectionelement::{HTMLTableSectionElement, HTMLTableSectionElementHelpers};
 use dom::htmltextareaelement::{HTMLTextAreaElement, RawLayoutHTMLTextAreaElementHelpers};
-use dom::node::{CLICK_IN_PROGRESS, ElementNodeTypeId, LayoutNodeHelpers, Node, NodeHelpers};
-use dom::node::{NodeIterator, NodeStyleDamaged, OtherNodeDamage, document_from_node};
+use dom::node::{CLICK_IN_PROGRESS, LayoutNodeHelpers, Node, NodeHelpers, NodeTypeId};
+use dom::node::{NodeIterator, document_from_node, NodeDamage};
 use dom::node::{window_from_node};
 use dom::nodelist::NodeList;
 use dom::virtualmethods::{VirtualMethods, vtable_for};
 use devtools_traits::AttrInfo;
-use style::{mod, AuthorOrigin, BgColorSimpleColorAttribute, BorderUnsignedIntegerAttribute};
-use style::{ColSpanUnsignedIntegerAttribute, IntegerAttribute, LengthAttribute, ParserContext};
-use style::{SimpleColorAttribute, SizeIntegerAttribute, ColsIntegerAttribute, RowsIntegerAttribute};
-use style::{UnsignedIntegerAttribute, WidthLengthAttribute, matches};
+use style::{mod, StylesheetOrigin, SimpleColorAttribute, UnsignedIntegerAttribute};
+use style::{IntegerAttribute, LengthAttribute, ParserContext, matches};
 use servo_util::namespace;
 use servo_util::str::{DOMString, LengthOrPercentageOrAuto};
 
@@ -79,7 +79,7 @@ impl ElementDerived for EventTarget {
     #[inline]
     fn is_element(&self) -> bool {
         match *self.type_id() {
-            NodeTargetTypeId(ElementNodeTypeId(_)) => true,
+            EventTargetTypeId::Node(NodeTypeId::Element(_)) => true,
             _ => false
         }
     }
@@ -94,75 +94,75 @@ impl Reflectable for Element {
 #[deriving(PartialEq, Show)]
 #[jstraceable]
 pub enum ElementTypeId {
-    HTMLElementTypeId,
-    HTMLAnchorElementTypeId,
-    HTMLAppletElementTypeId,
-    HTMLAreaElementTypeId,
-    HTMLAudioElementTypeId,
-    HTMLBaseElementTypeId,
-    HTMLBRElementTypeId,
-    HTMLBodyElementTypeId,
-    HTMLButtonElementTypeId,
-    HTMLCanvasElementTypeId,
-    HTMLDataElementTypeId,
-    HTMLDataListElementTypeId,
-    HTMLDirectoryElementTypeId,
-    HTMLDListElementTypeId,
-    HTMLDivElementTypeId,
-    HTMLEmbedElementTypeId,
-    HTMLFieldSetElementTypeId,
-    HTMLFontElementTypeId,
-    HTMLFormElementTypeId,
-    HTMLFrameElementTypeId,
-    HTMLFrameSetElementTypeId,
-    HTMLHRElementTypeId,
-    HTMLHeadElementTypeId,
-    HTMLHeadingElementTypeId,
-    HTMLHtmlElementTypeId,
-    HTMLIFrameElementTypeId,
-    HTMLImageElementTypeId,
-    HTMLInputElementTypeId,
-    HTMLLabelElementTypeId,
-    HTMLLegendElementTypeId,
-    HTMLLinkElementTypeId,
-    HTMLLIElementTypeId,
-    HTMLMapElementTypeId,
-    HTMLMediaElementTypeId,
-    HTMLMetaElementTypeId,
-    HTMLMeterElementTypeId,
-    HTMLModElementTypeId,
-    HTMLObjectElementTypeId,
-    HTMLOListElementTypeId,
-    HTMLOptGroupElementTypeId,
-    HTMLOptionElementTypeId,
-    HTMLOutputElementTypeId,
-    HTMLParagraphElementTypeId,
-    HTMLParamElementTypeId,
-    HTMLPreElementTypeId,
-    HTMLProgressElementTypeId,
-    HTMLQuoteElementTypeId,
-    HTMLScriptElementTypeId,
-    HTMLSelectElementTypeId,
-    HTMLSourceElementTypeId,
-    HTMLSpanElementTypeId,
-    HTMLStyleElementTypeId,
-    HTMLTableElementTypeId,
-    HTMLTableCaptionElementTypeId,
-    HTMLTableDataCellElementTypeId,
-    HTMLTableHeaderCellElementTypeId,
-    HTMLTableColElementTypeId,
-    HTMLTableRowElementTypeId,
-    HTMLTableSectionElementTypeId,
-    HTMLTemplateElementTypeId,
-    HTMLTextAreaElementTypeId,
-    HTMLTimeElementTypeId,
-    HTMLTitleElementTypeId,
-    HTMLTrackElementTypeId,
-    HTMLUListElementTypeId,
-    HTMLVideoElementTypeId,
-    HTMLUnknownElementTypeId,
-
-    ElementTypeId_,
+    HTMLElement,
+    HTMLAnchorElement,
+    HTMLAppletElement,
+    HTMLAreaElement,
+    HTMLAudioElement,
+    HTMLBaseElement,
+    HTMLBRElement,
+    HTMLBodyElement,
+    HTMLButtonElement,
+    HTMLCanvasElement,
+    HTMLDataElement,
+    HTMLDataListElement,
+    HTMLDirectoryElement,
+    HTMLDListElement,
+    HTMLDivElement,
+    HTMLEmbedElement,
+    HTMLFieldSetElement,
+    HTMLFontElement,
+    HTMLFormElement,
+    HTMLFrameElement,
+    HTMLFrameSetElement,
+    HTMLHRElement,
+    HTMLHeadElement,
+    HTMLHeadingElement,
+    HTMLHtmlElement,
+    HTMLIFrameElement,
+    HTMLImageElement,
+    HTMLInputElement,
+    HTMLLabelElement,
+    HTMLLegendElement,
+    HTMLLinkElement,
+    HTMLLIElement,
+    HTMLMapElement,
+    HTMLMediaElement,
+    HTMLMetaElement,
+    HTMLMeterElement,
+    HTMLModElement,
+    HTMLObjectElement,
+    HTMLOListElement,
+    HTMLOptGroupElement,
+    HTMLOptionElement,
+    HTMLOutputElement,
+    HTMLParagraphElement,
+    HTMLParamElement,
+    HTMLPreElement,
+    HTMLProgressElement,
+    HTMLQuoteElement,
+    HTMLScriptElement,
+    HTMLSelectElement,
+    HTMLSourceElement,
+    HTMLSpanElement,
+    HTMLStyleElement,
+    HTMLTableElement,
+    HTMLTableCaptionElement,
+    HTMLTableDataCellElement,
+    HTMLTableHeaderCellElement,
+    HTMLTableColElement,
+    HTMLTableRowElement,
+    HTMLTableSectionElement,
+    HTMLTemplateElement,
+    HTMLTextAreaElement,
+    HTMLTimeElement,
+    HTMLTitleElement,
+    HTMLTrackElement,
+    HTMLUListElement,
+    HTMLVideoElement,
+    HTMLUnknownElement,
+
+    Element,
 }
 
 #[deriving(PartialEq)]
@@ -183,7 +183,7 @@ impl Element {
 
     pub fn new_inherited(type_id: ElementTypeId, local_name: DOMString, namespace: Namespace, prefix: Option<DOMString>, document: JSRef<Document>) -> Element {
         Element {
-            node: Node::new_inherited(ElementNodeTypeId(type_id), document),
+            node: Node::new_inherited(NodeTypeId::Element(type_id), document),
             local_name: Atom::from_slice(local_name.as_slice()),
             namespace: namespace,
             prefix: prefix,
@@ -195,7 +195,7 @@ impl Element {
     }
 
     pub fn new(local_name: DOMString, namespace: Namespace, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<Element> {
-        Node::reflect_node(box Element::new_inherited(ElementTypeId_, local_name, namespace, prefix, document),
+        Node::reflect_node(box Element::new_inherited(ElementTypeId::Element, local_name, namespace, prefix, document),
                            document, ElementBinding::Wrap)
     }
 }
@@ -300,7 +300,7 @@ impl RawLayoutElementHelpers for Element {
     unsafe fn get_length_attribute_for_layout(&self, length_attribute: LengthAttribute)
                                               -> LengthOrPercentageOrAuto {
         match length_attribute {
-            WidthLengthAttribute => {
+            LengthAttribute::Width => {
                 if self.is_htmltableelement() {
                     let this: &HTMLTableElement = mem::transmute(self);
                     this.get_width()
@@ -318,21 +318,21 @@ impl RawLayoutElementHelpers for Element {
     unsafe fn get_integer_attribute_for_layout(&self, integer_attribute: IntegerAttribute)
                                                -> Option<i32> {
         match integer_attribute {
-            SizeIntegerAttribute => {
+            IntegerAttribute::Size => {
                 if !self.is_htmlinputelement() {
                     panic!("I'm not a form input!")
                 }
                 let this: &HTMLInputElement = mem::transmute(self);
                 Some(this.get_size_for_layout() as i32)
             }
-            ColsIntegerAttribute => {
+            IntegerAttribute::Cols => {
                 if !self.is_htmltextareaelement() {
                     panic!("I'm not a textarea element!")
                 }
                 let this: &HTMLTextAreaElement = mem::transmute(self);
                 Some(this.get_cols_for_layout() as i32)
             }
-            RowsIntegerAttribute => {
+            IntegerAttribute::Rows => {
                 if !self.is_htmltextareaelement() {
                     panic!("I'm not a textarea element!")
                 }
@@ -369,7 +369,7 @@ impl RawLayoutElementHelpers for Element {
                                                         attribute: UnsignedIntegerAttribute)
                                                         -> Option<u32> {
         match attribute {
-            BorderUnsignedIntegerAttribute => {
+            UnsignedIntegerAttribute::BorderUnsignedIntegerAttribute => {
                 if self.is_htmltableelement() {
                     let this: &HTMLTableElement = mem::transmute(self);
                     this.get_border()
@@ -379,7 +379,7 @@ impl RawLayoutElementHelpers for Element {
                     None
                 }
             }
-            ColSpanUnsignedIntegerAttribute => {
+            UnsignedIntegerAttribute::ColSpanUnsignedIntegerAttribute => {
                 if self.is_htmltablecellelement() {
                     let this: &HTMLTableCellElement = mem::transmute(self);
                     this.get_colspan()
@@ -397,7 +397,7 @@ impl RawLayoutElementHelpers for Element {
     unsafe fn get_simple_color_attribute_for_layout(&self, attribute: SimpleColorAttribute)
                                                     -> Option<RGBA> {
         match attribute {
-            BgColorSimpleColorAttribute => {
+            SimpleColorAttribute::BgColorSimpleColorAttribute => {
                 if self.is_htmlbodyelement() {
                     let this: &HTMLBodyElement = mem::transmute(self);
                     this.get_background_color()
@@ -612,13 +612,13 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
                                      .map(|attr| attr.root())
                                      .position(|attr| cb(*attr));
         let (idx, set_type) = match idx {
-            Some(idx) => (idx, ReplacedAttr),
+            Some(idx) => (idx, AttrSettingType::ReplacedAttr),
             None => {
                 let window = window_from_node(self).root();
                 let attr = Attr::new(*window, local_name, value.clone(),
                                      name, namespace.clone(), prefix, Some(self));
                 self.attrs.borrow_mut().push_unrooted(&attr);
-                (self.attrs.borrow().len() - 1, FirstSetAttr)
+                (self.attrs.borrow().len() - 1, AttrSettingType::FirstSetAttr)
             }
         };
 
@@ -631,7 +631,7 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
             vtable_for(&NodeCast::from_ref(self))
                 .parse_plain_attribute(local_name, value)
         } else {
-            StringAttrValue(value)
+            AttrValue::String(value)
         }
     }
 
@@ -657,9 +657,9 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
                 if node.is_in_doc() {
                     let document = document_from_node(self).root();
                     if local_name == atom!("style") {
-                        document.content_changed(node, NodeStyleDamaged);
+                        document.content_changed(node, NodeDamage::NodeStyleDamaged);
                     } else {
-                        document.content_changed(node, OtherNodeDamage);
+                        document.content_changed(node, NodeDamage::OtherNodeDamage);
                     }
                 }
             }
@@ -725,7 +725,7 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
     }
     fn set_string_attribute(self, name: &Atom, value: DOMString) {
         assert!(name.as_slice() == name.as_slice().to_ascii_lower().as_slice());
-        self.set_attribute(name, StringAttrValue(value));
+        self.set_attribute(name, AttrValue::String(value));
     }
 
     fn set_tokenlist_attribute(self, name: &Atom, value: DOMString) {
@@ -741,8 +741,8 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
         match attribute {
             Some(attribute) => {
                 match *attribute.value() {
-                    UIntAttrValue(_, value) => value,
-                    _ => panic!("Expected a UIntAttrValue: \
+                    AttrValue::UInt(_, value) => value,
+                    _ => panic!("Expected an AttrValue::UInt: \
                                  implement parse_plain_attribute"),
                 }
             }
@@ -751,7 +751,7 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
     }
     fn set_uint_attribute(self, name: &Atom, value: u32) {
         assert!(name.as_slice() == name.as_slice().to_ascii_lower().as_slice());
-        self.set_attribute(name, UIntAttrValue(value.to_string(), value));
+        self.set_attribute(name, AttrValue::UInt(value.to_string(), value));
     }
 }
 
@@ -1049,7 +1049,7 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
     // http://dom.spec.whatwg.org/#dom-element-matches
     fn Matches(self, selectors: DOMString) -> Fallible<bool> {
         let parser_context = ParserContext {
-            origin: AuthorOrigin,
+            origin: StylesheetOrigin::Author,
         };
         match style::parse_selector_list_from_str(&parser_context, selectors.as_slice()) {
             Err(()) => Err(Syntax),
@@ -1097,7 +1097,7 @@ impl<'a> VirtualMethods for JSRef<'a, Element> {
                 *self.style_attribute.borrow_mut() = style;
 
                 if node.is_in_doc() {
-                    doc.content_changed(node, NodeStyleDamaged);
+                    doc.content_changed(node, NodeDamage::NodeStyleDamaged);
                 }
             }
             &atom!("class") => {
@@ -1105,7 +1105,7 @@ impl<'a> VirtualMethods for JSRef<'a, Element> {
                 let node: JSRef<Node> = NodeCast::from_ref(*self);
                 if node.is_in_doc() {
                     let document = document_from_node(*self).root();
-                    document.content_changed(node, NodeStyleDamaged);
+                    document.content_changed(node, NodeDamage::NodeStyleDamaged);
                 }
             }
             &atom!("id") => {
@@ -1118,7 +1118,7 @@ impl<'a> VirtualMethods for JSRef<'a, Element> {
                         let value = Atom::from_slice(value.as_slice());
                         doc.register_named_element(*self, value);
                     }
-                    doc.content_changed(node, NodeStyleDamaged);
+                    doc.content_changed(node, NodeDamage::NodeStyleDamaged);
                 }
             }
             _ => {
@@ -1126,7 +1126,7 @@ impl<'a> VirtualMethods for JSRef<'a, Element> {
                 let node: JSRef<Node> = NodeCast::from_ref(*self);
                 if node.is_in_doc() {
                     let document = document_from_node(*self).root();
-                    document.content_changed(node, OtherNodeDamage);
+                    document.content_changed(node, NodeDamage::OtherNodeDamage);
                 }
             }
         }
@@ -1146,7 +1146,7 @@ impl<'a> VirtualMethods for JSRef<'a, Element> {
                 let node: JSRef<Node> = NodeCast::from_ref(*self);
                 if node.is_in_doc() {
                     let doc = document_from_node(*self).root();
-                    doc.content_changed(node, NodeStyleDamaged);
+                    doc.content_changed(node, NodeDamage::NodeStyleDamaged);
                 }
             }
             &atom!("id") => {
@@ -1159,7 +1159,7 @@ impl<'a> VirtualMethods for JSRef<'a, Element> {
                         let value = Atom::from_slice(value.as_slice());
                         doc.unregister_named_element(*self, value);
                     }
-                    doc.content_changed(node, NodeStyleDamaged);
+                    doc.content_changed(node, NodeDamage::NodeStyleDamaged);
                 }
             }
             &atom!("class") => {
@@ -1167,7 +1167,7 @@ impl<'a> VirtualMethods for JSRef<'a, Element> {
                 let node: JSRef<Node> = NodeCast::from_ref(*self);
                 if node.is_in_doc() {
                     let document = document_from_node(*self).root();
-                    document.content_changed(node, NodeStyleDamaged);
+                    document.content_changed(node, NodeDamage::NodeStyleDamaged);
                 }
             }
             _ => {
@@ -1175,7 +1175,7 @@ impl<'a> VirtualMethods for JSRef<'a, Element> {
                 let node: JSRef<Node> = NodeCast::from_ref(*self);
                 if node.is_in_doc() {
                     let doc = document_from_node(*self).root();
-                    doc.content_changed(node, OtherNodeDamage);
+                    doc.content_changed(node, NodeDamage::OtherNodeDamage);
                 }
             }
         }
@@ -1251,9 +1251,9 @@ impl<'a> style::TElement<'a> for JSRef<'a, Element> {
         match node.type_id() {
             // http://www.whatwg.org/specs/web-apps/current-work/multipage/selectors.html#
             // selector-link
-            ElementNodeTypeId(HTMLAnchorElementTypeId) |
-            ElementNodeTypeId(HTMLAreaElementTypeId) |
-            ElementNodeTypeId(HTMLLinkElementTypeId) => self.get_attr(&ns!(""), &atom!("href")),
+            NodeTypeId::Element(ElementTypeId::HTMLAnchorElement) |
+            NodeTypeId::Element(ElementTypeId::HTMLAreaElement) |
+            NodeTypeId::Element(ElementTypeId::HTMLLinkElement) => self.get_attr(&ns!(""), &atom!("href")),
             _ => None,
          }
     }
@@ -1283,8 +1283,8 @@ impl<'a> style::TElement<'a> for JSRef<'a, Element> {
         self.get_attribute(ns!(""), &atom!("id")).map(|attr| {
             let attr = attr.root();
             match *attr.value() {
-                AtomAttrValue(ref val) => val.clone(),
-                _ => panic!("`id` attribute should be AtomAttrValue"),
+                AttrValue::Atom(ref val) => val.clone(),
+                _ => panic!("`id` attribute should be AttrValue::Atom"),
             }
         })
     }
@@ -1357,7 +1357,7 @@ impl<'a> ActivationElementHelpers<'a> for JSRef<'a, Element> {
     fn as_maybe_activatable(&'a self) -> Option<&'a Activatable + 'a> {
         let node: JSRef<Node> = NodeCast::from_ref(*self);
         match node.type_id() {
-            ElementNodeTypeId(HTMLInputElementTypeId) => {
+            NodeTypeId::Element(ElementTypeId::HTMLInputElement) => {
                 let element: &'a JSRef<'a, HTMLInputElement> = HTMLInputElementCast::to_borrowed_ref(self).unwrap();
                 Some(element as &'a Activatable + 'a)
             },
diff --git a/components/script/dom/errorevent.rs b/components/script/dom/errorevent.rs
index ce7eb7184a9..01e10003639 100644
--- a/components/script/dom/errorevent.rs
+++ b/components/script/dom/errorevent.rs
@@ -13,7 +13,7 @@ use js::jsapi::JSContext;
 use dom::bindings::trace::JSTraceable;
 
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
-use dom::event::{Event, EventTypeId, ErrorEventTypeId, EventBubbles, Bubbles, DoesNotBubble, EventCancelable, Cancelable, NotCancelable};
+use dom::event::{Event, EventTypeId, EventBubbles, EventCancelable};
 use servo_util::str::DOMString;
 
 use dom::bindings::cell::DOMRefCell;
@@ -32,7 +32,7 @@ pub struct ErrorEvent {
 
 impl ErrorEventDerived for Event {
     fn is_errorevent(&self) -> bool {
-        *self.type_id() == ErrorEventTypeId
+        *self.type_id() == EventTypeId::ErrorEvent
     }
 }
 
@@ -49,7 +49,7 @@ impl ErrorEvent {
     }
 
     pub fn new_uninitialized(global: &GlobalRef) -> Temporary<ErrorEvent> {
-        reflect_dom_object(box ErrorEvent::new_inherited(ErrorEventTypeId),
+        reflect_dom_object(box ErrorEvent::new_inherited(EventTypeId::ErrorEvent),
                            *global,
                            ErrorEventBinding::Wrap)
     }
@@ -65,7 +65,8 @@ impl ErrorEvent {
                error: JSVal) -> Temporary<ErrorEvent> {
         let ev = ErrorEvent::new_uninitialized(global).root();
         let event: JSRef<Event> = EventCast::from_ref(*ev);
-        event.InitEvent(type_, bubbles == Bubbles, cancelable == Cancelable);
+        event.InitEvent(type_, bubbles == EventBubbles::Bubbles,
+                        cancelable == EventCancelable::Cancelable);
         *ev.message.borrow_mut() = message;
         *ev.filename.borrow_mut() = filename;
         ev.lineno.set(lineno);
@@ -91,9 +92,9 @@ impl ErrorEvent {
 
         let col_num = init.colno.unwrap_or(0);
 
-        let bubbles = if init.parent.bubbles { Bubbles } else { DoesNotBubble };
+        let bubbles = if init.parent.bubbles { EventBubbles::Bubbles } else { EventBubbles::DoesNotBubble };
 
-        let cancelable = if init.parent.cancelable { Cancelable } else { NotCancelable };
+        let cancelable = if init.parent.cancelable { EventCancelable::Cancelable } else { EventCancelable::NotCancelable };
 
         let event = ErrorEvent::new(global, type_,
                                 bubbles, cancelable,
diff --git a/components/script/dom/event.rs b/components/script/dom/event.rs
index 6d7ce64bf5e..5224945f086 100644
--- a/components/script/dom/event.rs
+++ b/components/script/dom/event.rs
@@ -18,23 +18,23 @@ use time;
 
 #[jstraceable]
 pub enum EventPhase {
-    PhaseNone      = EventConstants::NONE as int,
-    PhaseCapturing = EventConstants::CAPTURING_PHASE as int,
-    PhaseAtTarget  = EventConstants::AT_TARGET as int,
-    PhaseBubbling  = EventConstants::BUBBLING_PHASE as int,
+    None      = EventConstants::NONE as int,
+    Capturing = EventConstants::CAPTURING_PHASE as int,
+    AtTarget  = EventConstants::AT_TARGET as int,
+    Bubbling  = EventConstants::BUBBLING_PHASE as int,
 }
 
 #[deriving(PartialEq)]
 #[jstraceable]
 pub enum EventTypeId {
-    CustomEventTypeId,
-    HTMLEventTypeId,
-    KeyboardEventTypeId,
-    MessageEventTypeId,
-    MouseEventTypeId,
-    ProgressEventTypeId,
-    UIEventTypeId,
-    ErrorEventTypeId
+    CustomEvent,
+    HTMLEvent,
+    KeyboardEvent,
+    MessageEvent,
+    MouseEvent,
+    ProgressEvent,
+    UIEvent,
+    ErrorEvent
 }
 
 #[deriving(PartialEq)]
@@ -75,7 +75,7 @@ impl Event {
             reflector_: Reflector::new(),
             current_target: Default::default(),
             target: Default::default(),
-            phase: Cell::new(PhaseNone),
+            phase: Cell::new(EventPhase::None),
             type_: DOMRefCell::new("".to_string()),
             canceled: Cell::new(false),
             cancelable: Cell::new(false),
@@ -90,7 +90,7 @@ impl Event {
     }
 
     pub fn new_uninitialized(global: GlobalRef) -> Temporary<Event> {
-        reflect_dom_object(box Event::new_inherited(HTMLEventTypeId),
+        reflect_dom_object(box Event::new_inherited(EventTypeId::HTMLEvent),
                            global,
                            EventBinding::Wrap)
     }
@@ -100,15 +100,15 @@ impl Event {
                bubbles: EventBubbles,
                cancelable: EventCancelable) -> Temporary<Event> {
         let event = Event::new_uninitialized(global).root();
-        event.InitEvent(type_, bubbles == Bubbles, cancelable == Cancelable);
+        event.InitEvent(type_, bubbles == EventBubbles::Bubbles, cancelable == EventCancelable::Cancelable);
         Temporary::from_rooted(*event)
     }
 
     pub fn Constructor(global: &GlobalRef,
                        type_: DOMString,
                        init: &EventBinding::EventInit) -> Fallible<Temporary<Event>> {
-        let bubbles = if init.bubbles { Bubbles } else { DoesNotBubble };
-        let cancelable = if init.cancelable { Cancelable } else { NotCancelable };
+        let bubbles = if init.bubbles { EventBubbles::Bubbles } else { EventBubbles::DoesNotBubble };
+        let cancelable = if init.cancelable { EventCancelable::Cancelable } else { EventCancelable::NotCancelable };
         Ok(Event::new(*global, type_, bubbles, cancelable))
     }
 
diff --git a/components/script/dom/eventdispatcher.rs b/components/script/dom/eventdispatcher.rs
index 74ffc1f5136..412b0cdcb4d 100644
--- a/components/script/dom/eventdispatcher.rs
+++ b/components/script/dom/eventdispatcher.rs
@@ -2,12 +2,12 @@
  * 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::callback::ReportExceptions;
+use dom::bindings::callback::ExceptionHandling::ReportExceptions;
 use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
 use dom::bindings::codegen::InheritTypes::{EventTargetCast, NodeCast, NodeDerived};
 use dom::bindings::js::{JS, JSRef, OptionalRootable, Root};
-use dom::eventtarget::{Capturing, Bubbling, EventTarget};
-use dom::event::{Event, PhaseAtTarget, PhaseNone, PhaseBubbling, PhaseCapturing};
+use dom::eventtarget::{EventTarget, ListenerPhase};
+use dom::event::{Event, EventPhase};
 use dom::node::{Node, NodeHelpers};
 use dom::virtualmethods::vtable_for;
 
@@ -37,13 +37,13 @@ pub fn dispatch_event<'a, 'b>(target: JSRef<'a, EventTarget>,
         vec!()
     };
 
-    event.set_phase(PhaseCapturing);
+    event.set_phase(EventPhase::Capturing);
 
     //FIXME: The "callback this value" should be currentTarget
 
     /* capturing */
     for cur_target in chain.as_slice().iter().rev() {
-        let stopped = match cur_target.get_listeners_for(type_.as_slice(), Capturing) {
+        let stopped = match cur_target.get_listeners_for(type_.as_slice(), ListenerPhase::Capturing) {
             Some(listeners) => {
                 event.set_current_target(cur_target.deref().clone());
                 for listener in listeners.iter() {
@@ -67,7 +67,7 @@ pub fn dispatch_event<'a, 'b>(target: JSRef<'a, EventTarget>,
 
     /* at target */
     if !event.stop_propagation() {
-        event.set_phase(PhaseAtTarget);
+        event.set_phase(EventPhase::AtTarget);
         event.set_current_target(target.clone());
 
         let opt_listeners = target.get_listeners(type_.as_slice());
@@ -85,10 +85,10 @@ pub fn dispatch_event<'a, 'b>(target: JSRef<'a, EventTarget>,
 
     /* bubbling */
     if event.bubbles() && !event.stop_propagation() {
-        event.set_phase(PhaseBubbling);
+        event.set_phase(EventPhase::Bubbling);
 
         for cur_target in chain.iter() {
-            let stopped = match cur_target.get_listeners_for(type_.as_slice(), Bubbling) {
+            let stopped = match cur_target.get_listeners_for(type_.as_slice(), ListenerPhase::Bubbling) {
                 Some(listeners) => {
                     event.set_current_target(cur_target.deref().clone());
                     for listener in listeners.iter() {
@@ -133,7 +133,7 @@ pub fn dispatch_event<'a, 'b>(target: JSRef<'a, EventTarget>,
     }
 
     event.set_dispatching(false);
-    event.set_phase(PhaseNone);
+    event.set_phase(EventPhase::None);
     event.clear_current_target();
 
     !event.DefaultPrevented()
diff --git a/components/script/dom/eventtarget.rs b/components/script/dom/eventtarget.rs
index 394b66e6acc..3b353bf27de 100644
--- a/components/script/dom/eventtarget.rs
+++ b/components/script/dom/eventtarget.rs
@@ -7,14 +7,15 @@ use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
 use dom::bindings::codegen::Bindings::EventListenerBinding::EventListener;
 use dom::bindings::codegen::Bindings::EventTargetBinding::EventTargetMethods;
-use dom::bindings::error::{Fallible, InvalidState, report_pending_exception};
+use dom::bindings::error::{Fallible, report_pending_exception};
+use dom::bindings::error::Error::InvalidState;
 use dom::bindings::js::JSRef;
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::event::Event;
 use dom::eventdispatcher::dispatch_event;
 use dom::node::NodeTypeId;
-use dom::workerglobalscope::WorkerGlobalScopeId;
-use dom::xmlhttprequest::XMLHttpRequestId;
+use dom::workerglobalscope::WorkerGlobalScopeTypeId;
+use dom::xmlhttprequesteventtarget::XMLHttpRequestEventTargetTypeId;
 use dom::virtualmethods::VirtualMethods;
 use js::jsapi::{JS_CompileUCFunction, JS_GetFunctionObject, JS_CloneFunctionObject};
 use js::jsapi::{JSContext, JSObject};
@@ -37,12 +38,12 @@ pub enum ListenerPhase {
 #[deriving(PartialEq)]
 #[jstraceable]
 pub enum EventTargetTypeId {
-    NodeTargetTypeId(NodeTypeId),
-    WebSocketTypeId,
-    WindowTypeId,
-    WorkerTypeId,
-    WorkerGlobalScopeTypeId(WorkerGlobalScopeId),
-    XMLHttpRequestTargetTypeId(XMLHttpRequestId)
+    Node(NodeTypeId),
+    WebSocket,
+    Window,
+    Worker,
+    WorkerGlobalScope(WorkerGlobalScopeTypeId),
+    XMLHttpRequestEventTarget(XMLHttpRequestEventTargetTypeId)
 }
 
 #[deriving(PartialEq)]
@@ -55,7 +56,8 @@ pub enum EventListenerType {
 impl EventListenerType {
     fn get_listener(&self) -> EventListener {
         match *self {
-            Additive(listener) | Inline(listener) => listener
+            EventListenerType::Additive(listener) |
+            EventListenerType::Inline(listener) => listener
         }
     }
 }
@@ -148,7 +150,7 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
 
         let idx = entries.iter().position(|&entry| {
             match entry.listener {
-                Inline(_) => true,
+                EventListenerType::Inline(_) => true,
                 _ => false,
             }
         });
@@ -156,7 +158,7 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
         match idx {
             Some(idx) => {
                 match listener {
-                    Some(listener) => entries[idx].listener = Inline(listener),
+                    Some(listener) => entries[idx].listener = EventListenerType::Inline(listener),
                     None => {
                         entries.remove(idx);
                     }
@@ -165,8 +167,8 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
             None => {
                 if listener.is_some() {
                     entries.push(EventListenerEntry {
-                        phase: Bubbling,
-                        listener: Inline(listener.unwrap()),
+                        phase: ListenerPhase::Bubbling,
+                        listener: EventListenerType::Inline(listener.unwrap()),
                     });
                 }
             }
@@ -178,7 +180,7 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
         let entries = handlers.get(&ty);
         entries.and_then(|entries| entries.iter().find(|entry| {
             match entry.listener {
-                Inline(_) => true,
+                EventListenerType::Inline(_) => true,
                 _ => false,
             }
         }).map(|entry| entry.listener.get_listener()))
@@ -254,10 +256,10 @@ impl<'a> EventTargetMethods for JSRef<'a, EventTarget> {
                     Vacant(entry) => entry.set(vec!()),
                 };
 
-                let phase = if capture { Capturing } else { Bubbling };
+                let phase = if capture { ListenerPhase::Capturing } else { ListenerPhase::Bubbling };
                 let new_entry = EventListenerEntry {
                     phase: phase,
-                    listener: Additive(listener)
+                    listener: EventListenerType::Additive(listener)
                 };
                 if entry.as_slice().position_elem(&new_entry).is_none() {
                     entry.push(new_entry);
@@ -276,10 +278,10 @@ impl<'a> EventTargetMethods for JSRef<'a, EventTarget> {
                 let mut handlers = self.handlers.borrow_mut();
                 let mut entry = handlers.get_mut(&ty);
                 for entry in entry.iter_mut() {
-                    let phase = if capture { Capturing } else { Bubbling };
+                    let phase = if capture { ListenerPhase::Capturing } else { ListenerPhase::Bubbling };
                     let old_entry = EventListenerEntry {
                         phase: phase,
-                        listener: Additive(listener)
+                        listener: EventListenerType::Additive(listener)
                     };
                     let position = entry.as_slice().position_elem(&old_entry);
                     for &position in position.iter() {
diff --git a/components/script/dom/file.rs b/components/script/dom/file.rs
index 985386321c3..f79631c9d52 100644
--- a/components/script/dom/file.rs
+++ b/components/script/dom/file.rs
@@ -7,7 +7,7 @@ use dom::bindings::codegen::Bindings::FileBinding::FileMethods;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
-use dom::blob::{Blob, BlobType, FileTypeId};
+use dom::blob::{Blob, BlobTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -17,7 +17,7 @@ pub struct File {
 }
 
 impl File {
-    fn new_inherited(global: &GlobalRef, type_: BlobType,
+    fn new_inherited(global: &GlobalRef, type_: BlobTypeId,
                      _file_bits: JSRef<Blob>, name: DOMString) -> File {
         File {
             blob: Blob::new_inherited(global, type_, None),
@@ -28,7 +28,7 @@ impl File {
     }
 
     pub fn new(global: &GlobalRef, file_bits: JSRef<Blob>, name: DOMString) -> Temporary<File> {
-        reflect_dom_object(box File::new_inherited(global, FileTypeId, file_bits, name),
+        reflect_dom_object(box File::new_inherited(global, BlobTypeId::File, file_bits, name),
                            *global,
                            FileBinding::Wrap)
     }
diff --git a/components/script/dom/formdata.rs b/components/script/dom/formdata.rs
index 0c9a5e81f8b..5a76dda5511 100644
--- a/components/script/dom/formdata.rs
+++ b/components/script/dom/formdata.rs
@@ -6,7 +6,8 @@ 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::{FileOrString, eFile, eString};
+use dom::bindings::codegen::UnionTypes::FileOrString;
+use dom::bindings::codegen::UnionTypes::FileOrString::{eFile, eString};
 use dom::bindings::error::{Fallible};
 use dom::bindings::global::{GlobalRef, GlobalField};
 use dom::bindings::js::{JS, JSRef, Temporary};
@@ -57,7 +58,7 @@ impl FormData {
 impl<'a> FormDataMethods for JSRef<'a, FormData> {
     #[allow(unrooted_must_root)]
     fn Append(self, name: DOMString, value: JSRef<Blob>, filename: Option<DOMString>) {
-        let file = FileData(JS::from_rooted(self.get_file_from_blob(value, filename)));
+        let file = FormDatum::FileData(JS::from_rooted(self.get_file_from_blob(value, filename)));
         let mut data = self.data.borrow_mut();
         match data.entry(name) {
             Occupied(entry) => entry.into_mut().push(file),
@@ -70,8 +71,8 @@ impl<'a> FormDataMethods for JSRef<'a, FormData> {
     fn Append_(self, name: DOMString, value: DOMString) {
         let mut data = self.data.borrow_mut();
         match data.entry(name) {
-            Occupied(entry) => entry.into_mut().push(StringData(value)),
-            Vacant  (entry) => { entry.set(vec!(StringData(value))); },
+            Occupied(entry) => entry.into_mut().push(FormDatum::StringData(value)),
+            Vacant  (entry) => { entry.set(vec!(FormDatum::StringData(value))); },
         }
     }
 
@@ -82,8 +83,8 @@ impl<'a> FormDataMethods for JSRef<'a, FormData> {
     fn Get(self, name: DOMString) -> Option<FileOrString> {
         if self.data.borrow().contains_key_equiv(&name) {
             match (*self.data.borrow())[name][0].clone() {
-                StringData(ref s) => Some(eString(s.clone())),
-                FileData(ref f) => {
+                FormDatum::StringData(ref s) => Some(eString(s.clone())),
+                FormDatum::FileData(ref f) => {
                     Some(eFile(f.clone()))
                 }
             }
@@ -97,12 +98,12 @@ impl<'a> FormDataMethods for JSRef<'a, FormData> {
     }
     #[allow(unrooted_must_root)]
     fn Set(self, name: DOMString, value: JSRef<Blob>, filename: Option<DOMString>) {
-        let file = FileData(JS::from_rooted(self.get_file_from_blob(value, filename)));
+        let file = FormDatum::FileData(JS::from_rooted(self.get_file_from_blob(value, filename)));
         self.data.borrow_mut().insert(name, vec!(file));
     }
 
     fn Set_(self, name: DOMString, value: DOMString) {
-        self.data.borrow_mut().insert(name, vec!(StringData(value)));
+        self.data.borrow_mut().insert(name, vec!(FormDatum::StringData(value)));
     }
 }
 
diff --git a/components/script/dom/htmlanchorelement.rs b/components/script/dom/htmlanchorelement.rs
index c712ddad60e..10d574672a3 100644
--- a/components/script/dom/htmlanchorelement.rs
+++ b/components/script/dom/htmlanchorelement.rs
@@ -14,11 +14,11 @@ use dom::bindings::js::{MutNullableJS, JSRef, Temporary, OptionalRootable};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::{Document, DocumentHelpers};
 use dom::domtokenlist::DOMTokenList;
-use dom::element::{Element, AttributeHandlers, HTMLAnchorElementTypeId};
+use dom::element::{Element, AttributeHandlers, ElementTypeId};
 use dom::event::Event;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, NodeHelpers, ElementNodeTypeId};
+use dom::node::{Node, NodeHelpers, NodeTypeId};
 use dom::virtualmethods::VirtualMethods;
 
 use std::default::Default;
@@ -33,14 +33,14 @@ pub struct HTMLAnchorElement {
 
 impl HTMLAnchorElementDerived for EventTarget {
     fn is_htmlanchorelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLAnchorElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLAnchorElement))
     }
 }
 
 impl HTMLAnchorElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLAnchorElement {
         HTMLAnchorElement {
-            htmlelement: HTMLElement::new_inherited(HTMLAnchorElementTypeId, localName, prefix, document),
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLAnchorElement, localName, prefix, document),
             rel_list: Default::default(),
         }
     }
diff --git a/components/script/dom/htmlappletelement.rs b/components/script/dom/htmlappletelement.rs
index 4360d288b2c..f54a3f32125 100644
--- a/components/script/dom/htmlappletelement.rs
+++ b/components/script/dom/htmlappletelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLAppletElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLAppletElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLAppletElement {
 
 impl HTMLAppletElementDerived for EventTarget {
     fn is_htmlappletelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLAppletElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLAppletElement))
     }
 }
 
 impl HTMLAppletElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLAppletElement {
         HTMLAppletElement {
-            htmlelement: HTMLElement::new_inherited(HTMLAppletElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLAppletElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmlareaelement.rs b/components/script/dom/htmlareaelement.rs
index fc4c29bc085..1ede87d380d 100644
--- a/components/script/dom/htmlareaelement.rs
+++ b/components/script/dom/htmlareaelement.rs
@@ -11,10 +11,10 @@ use dom::bindings::js::{MutNullableJS, JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
 use dom::domtokenlist::DOMTokenList;
-use dom::element::HTMLAreaElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, NodeHelpers, ElementNodeTypeId};
+use dom::node::{Node, NodeHelpers, NodeTypeId};
 use dom::virtualmethods::VirtualMethods;
 
 use std::default::Default;
@@ -31,14 +31,14 @@ pub struct HTMLAreaElement {
 
 impl HTMLAreaElementDerived for EventTarget {
     fn is_htmlareaelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLAreaElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLAreaElement))
     }
 }
 
 impl HTMLAreaElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLAreaElement {
         HTMLAreaElement {
-            htmlelement: HTMLElement::new_inherited(HTMLAreaElementTypeId, localName, prefix, document),
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLAreaElement, localName, prefix, document),
             rel_list: Default::default(),
         }
     }
diff --git a/components/script/dom/htmlaudioelement.rs b/components/script/dom/htmlaudioelement.rs
index 216b255816a..d850d65a309 100644
--- a/components/script/dom/htmlaudioelement.rs
+++ b/components/script/dom/htmlaudioelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLAudioElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLAudioElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlmediaelement::HTMLMediaElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLAudioElement {
 
 impl HTMLAudioElementDerived for EventTarget {
     fn is_htmlaudioelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLAudioElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLAudioElement))
     }
 }
 
 impl HTMLAudioElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLAudioElement {
         HTMLAudioElement {
-            htmlmediaelement: HTMLMediaElement::new_inherited(HTMLAudioElementTypeId, localName, prefix, document)
+            htmlmediaelement: HTMLMediaElement::new_inherited(ElementTypeId::HTMLAudioElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmlbaseelement.rs b/components/script/dom/htmlbaseelement.rs
index a91b6bd9791..cc72295080c 100644
--- a/components/script/dom/htmlbaseelement.rs
+++ b/components/script/dom/htmlbaseelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLBaseElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLBaseElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLBaseElement {
 
 impl HTMLBaseElementDerived for EventTarget {
     fn is_htmlbaseelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLBaseElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLBaseElement))
     }
 }
 
 impl HTMLBaseElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLBaseElement {
         HTMLBaseElement {
-            htmlelement: HTMLElement::new_inherited(HTMLBaseElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLBaseElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmlbodyelement.rs b/components/script/dom/htmlbodyelement.rs
index 917b02913a7..a692243db2d 100644
--- a/components/script/dom/htmlbodyelement.rs
+++ b/components/script/dom/htmlbodyelement.rs
@@ -11,10 +11,10 @@ use dom::bindings::codegen::InheritTypes::{HTMLBodyElementDerived, HTMLElementCa
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLBodyElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId, EventTargetHelpers};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId, EventTargetHelpers};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId, window_from_node};
+use dom::node::{Node, NodeTypeId, window_from_node};
 use dom::virtualmethods::VirtualMethods;
 
 use cssparser::RGBA;
@@ -29,7 +29,7 @@ pub struct HTMLBodyElement {
 
 impl HTMLBodyElementDerived for EventTarget {
     fn is_htmlbodyelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLBodyElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLBodyElement))
     }
 }
 
@@ -37,7 +37,7 @@ impl HTMLBodyElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>)
                      -> HTMLBodyElement {
         HTMLBodyElement {
-            htmlelement: HTMLElement::new_inherited(HTMLBodyElementTypeId,
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLBodyElement,
                                                     localName,
                                                     prefix,
                                                     document),
diff --git a/components/script/dom/htmlbrelement.rs b/components/script/dom/htmlbrelement.rs
index e2716c39357..fdfe2abd98e 100644
--- a/components/script/dom/htmlbrelement.rs
+++ b/components/script/dom/htmlbrelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLBRElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLBRElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLBRElement {
 
 impl HTMLBRElementDerived for EventTarget {
     fn is_htmlbrelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLBRElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLBRElement))
     }
 }
 
 impl HTMLBRElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLBRElement {
         HTMLBRElement {
-            htmlelement: HTMLElement::new_inherited(HTMLBRElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLBRElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmlbuttonelement.rs b/components/script/dom/htmlbuttonelement.rs
index 58019cbc5f5..d0ca30025d5 100644
--- a/components/script/dom/htmlbuttonelement.rs
+++ b/components/script/dom/htmlbuttonelement.rs
@@ -11,10 +11,10 @@ use dom::bindings::codegen::InheritTypes::{HTMLButtonElementDerived, HTMLFieldSe
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::{AttributeHandlers, Element, HTMLButtonElementTypeId};
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::{AttributeHandlers, Element, ElementTypeId};
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{DisabledStateHelpers, Node, NodeHelpers, ElementNodeTypeId, window_from_node};
+use dom::node::{DisabledStateHelpers, Node, NodeHelpers, NodeTypeId, window_from_node};
 use dom::validitystate::ValidityState;
 use dom::virtualmethods::VirtualMethods;
 
@@ -29,14 +29,14 @@ pub struct HTMLButtonElement {
 
 impl HTMLButtonElementDerived for EventTarget {
     fn is_htmlbuttonelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLButtonElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLButtonElement))
     }
 }
 
 impl HTMLButtonElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLButtonElement {
         HTMLButtonElement {
-            htmlelement: HTMLElement::new_inherited(HTMLButtonElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLButtonElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmlcanvaselement.rs b/components/script/dom/htmlcanvaselement.rs
index 5de1ccd5400..70da494f314 100644
--- a/components/script/dom/htmlcanvaselement.rs
+++ b/components/script/dom/htmlcanvaselement.rs
@@ -13,10 +13,10 @@ use dom::bindings::js::{MutNullableJS, JSRef, Temporary, OptionalSettable};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::canvasrenderingcontext2d::CanvasRenderingContext2D;
 use dom::document::Document;
-use dom::element::{Element, HTMLCanvasElementTypeId, AttributeHandlers};
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::{Element, ElementTypeId, AttributeHandlers};
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId, window_from_node};
+use dom::node::{Node, NodeTypeId, window_from_node};
 use dom::virtualmethods::VirtualMethods;
 
 use servo_util::str::{DOMString, parse_unsigned_integer};
@@ -39,14 +39,14 @@ pub struct HTMLCanvasElement {
 
 impl HTMLCanvasElementDerived for EventTarget {
     fn is_htmlcanvaselement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLCanvasElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLCanvasElement))
     }
 }
 
 impl HTMLCanvasElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLCanvasElement {
         HTMLCanvasElement {
-            htmlelement: HTMLElement::new_inherited(HTMLCanvasElementTypeId, localName, prefix, document),
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLCanvasElement, localName, prefix, document),
             context: Default::default(),
             width: Cell::new(DEFAULT_WIDTH),
             height: Cell::new(DEFAULT_HEIGHT),
diff --git a/components/script/dom/htmlcollection.rs b/components/script/dom/htmlcollection.rs
index 86f977c843a..647b5ee66af 100644
--- a/components/script/dom/htmlcollection.rs
+++ b/components/script/dom/htmlcollection.rs
@@ -53,7 +53,7 @@ impl HTMLCollection {
 impl HTMLCollection {
     pub fn create(window: JSRef<Window>, root: JSRef<Node>,
                   filter: Box<CollectionFilter+'static>) -> Temporary<HTMLCollection> {
-        HTMLCollection::new(window, Live(JS::from_rooted(root), filter))
+        HTMLCollection::new(window, CollectionTypeId::Live(JS::from_rooted(root), filter))
     }
 
     fn all_elements(window: JSRef<Window>, root: JSRef<Node>,
@@ -178,8 +178,8 @@ impl<'a> HTMLCollectionMethods for JSRef<'a, HTMLCollection> {
     // http://dom.spec.whatwg.org/#dom-htmlcollection-length
     fn Length(self) -> u32 {
         match self.collection {
-            Static(ref elems) => elems.len() as u32,
-            Live(ref root, ref filter) => {
+            CollectionTypeId::Static(ref elems) => elems.len() as u32,
+            CollectionTypeId::Live(ref root, ref filter) => {
                 let root = root.root();
                 HTMLCollection::traverse(*root)
                     .filter(|element| filter.filter(*element, *root))
@@ -191,11 +191,11 @@ impl<'a> HTMLCollectionMethods for JSRef<'a, HTMLCollection> {
     // http://dom.spec.whatwg.org/#dom-htmlcollection-item
     fn Item(self, index: u32) -> Option<Temporary<Element>> {
         match self.collection {
-            Static(ref elems) => elems
+            CollectionTypeId::Static(ref elems) => elems
                 .as_slice()
                 .get(index as uint)
                 .map(|elem| Temporary::new(elem.clone())),
-            Live(ref root, ref filter) => {
+            CollectionTypeId::Live(ref root, ref filter) => {
                 let root = root.root();
                 HTMLCollection::traverse(*root)
                     .filter(|element| filter.filter(*element, *root))
@@ -215,13 +215,13 @@ impl<'a> HTMLCollectionMethods for JSRef<'a, HTMLCollection> {
 
         // Step 2.
         match self.collection {
-            Static(ref elems) => elems.iter()
+            CollectionTypeId::Static(ref elems) => elems.iter()
                 .map(|elem| elem.root())
                 .find(|elem| {
                     elem.get_string_attribute(&atom!("name")) == key ||
                     elem.get_string_attribute(&atom!("id")) == key })
                 .map(|maybe_elem| Temporary::from_rooted(*maybe_elem)),
-            Live(ref root, ref filter) => {
+            CollectionTypeId::Live(ref root, ref filter) => {
                 let root = root.root();
                 HTMLCollection::traverse(*root)
                     .filter(|element| filter.filter(*element, *root))
diff --git a/components/script/dom/htmldataelement.rs b/components/script/dom/htmldataelement.rs
index 33dfbfd7bd7..85480e4e41f 100644
--- a/components/script/dom/htmldataelement.rs
+++ b/components/script/dom/htmldataelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLDataElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLDataElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLDataElement {
 
 impl HTMLDataElementDerived for EventTarget {
     fn is_htmldataelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLDataElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLDataElement))
     }
 }
 
 impl HTMLDataElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLDataElement {
         HTMLDataElement {
-            htmlelement: HTMLElement::new_inherited(HTMLDataElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLDataElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmldatalistelement.rs b/components/script/dom/htmldatalistelement.rs
index 210c22b33a3..0083af0cc25 100644
--- a/components/script/dom/htmldatalistelement.rs
+++ b/components/script/dom/htmldatalistelement.rs
@@ -9,11 +9,11 @@ use dom::bindings::codegen::InheritTypes::NodeCast;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::{Element, HTMLDataListElementTypeId};
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::{Element, ElementTypeId};
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlcollection::{HTMLCollection, CollectionFilter};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId, window_from_node};
+use dom::node::{Node, NodeTypeId, window_from_node};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -23,14 +23,14 @@ pub struct HTMLDataListElement {
 
 impl HTMLDataListElementDerived for EventTarget {
     fn is_htmldatalistelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLDataListElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLDataListElement))
     }
 }
 
 impl HTMLDataListElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLDataListElement {
         HTMLDataListElement {
-            htmlelement: HTMLElement::new_inherited(HTMLDataListElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLDataListElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmldirectoryelement.rs b/components/script/dom/htmldirectoryelement.rs
index 21c675458b9..3969c56e886 100644
--- a/components/script/dom/htmldirectoryelement.rs
+++ b/components/script/dom/htmldirectoryelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLDirectoryElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLDirectoryElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLDirectoryElement {
 
 impl HTMLDirectoryElementDerived for EventTarget {
     fn is_htmldirectoryelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLDirectoryElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLDirectoryElement))
     }
 }
 
 impl HTMLDirectoryElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLDirectoryElement {
         HTMLDirectoryElement {
-            htmlelement: HTMLElement::new_inherited(HTMLDirectoryElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLDirectoryElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmldivelement.rs b/components/script/dom/htmldivelement.rs
index 899c35f571a..a5f9eb3238c 100644
--- a/components/script/dom/htmldivelement.rs
+++ b/components/script/dom/htmldivelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLDivElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLDivElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLDivElement {
 
 impl HTMLDivElementDerived for EventTarget {
     fn is_htmldivelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLDivElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLDivElement))
     }
 }
 
 impl HTMLDivElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLDivElement {
         HTMLDivElement {
-            htmlelement: HTMLElement::new_inherited(HTMLDivElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLDivElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmldlistelement.rs b/components/script/dom/htmldlistelement.rs
index 38828fb3957..aeb23b7afb4 100644
--- a/components/script/dom/htmldlistelement.rs
+++ b/components/script/dom/htmldlistelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLDListElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLDListElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLDListElement {
 
 impl HTMLDListElementDerived for EventTarget {
     fn is_htmldlistelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLDListElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLDListElement))
     }
 }
 
 impl HTMLDListElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLDListElement {
         HTMLDListElement {
-            htmlelement: HTMLElement::new_inherited(HTMLDListElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLDListElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmlelement.rs b/components/script/dom/htmlelement.rs
index 010946fabc4..f8a8ea7ce5c 100644
--- a/components/script/dom/htmlelement.rs
+++ b/components/script/dom/htmlelement.rs
@@ -15,9 +15,9 @@ use dom::bindings::codegen::InheritTypes::{HTMLElementDerived, HTMLBodyElementDe
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::{Element, ElementTypeId, ElementTypeId_, HTMLElementTypeId, ActivationElementHelpers};
-use dom::eventtarget::{EventTarget, EventTargetHelpers, NodeTargetTypeId};
-use dom::node::{Node, ElementNodeTypeId, window_from_node};
+use dom::element::{Element, ElementTypeId, ActivationElementHelpers};
+use dom::eventtarget::{EventTarget, EventTargetHelpers, EventTargetTypeId};
+use dom::node::{Node, NodeTypeId, window_from_node};
 use dom::virtualmethods::VirtualMethods;
 
 use servo_util::str::DOMString;
@@ -32,8 +32,8 @@ pub struct HTMLElement {
 impl HTMLElementDerived for EventTarget {
     fn is_htmlelement(&self) -> bool {
         match *self.type_id() {
-            NodeTargetTypeId(ElementNodeTypeId(ElementTypeId_)) => false,
-            NodeTargetTypeId(ElementNodeTypeId(_)) => true,
+            EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::Element)) => false,
+            EventTargetTypeId::Node(NodeTypeId::Element(_)) => true,
             _ => false
         }
     }
@@ -48,7 +48,7 @@ impl HTMLElement {
 
     #[allow(unrooted_must_root)]
     pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLElement> {
-        let element = HTMLElement::new_inherited(HTMLElementTypeId, localName, prefix, document);
+        let element = HTMLElement::new_inherited(ElementTypeId::HTMLElement, localName, prefix, document);
         Node::reflect_node(box element, document, HTMLElementBinding::Wrap)
     }
 }
diff --git a/components/script/dom/htmlembedelement.rs b/components/script/dom/htmlembedelement.rs
index f99d0f821df..fd4945f2ded 100644
--- a/components/script/dom/htmlembedelement.rs
+++ b/components/script/dom/htmlembedelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLEmbedElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLEmbedElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLEmbedElement {
 
 impl HTMLEmbedElementDerived for EventTarget {
     fn is_htmlembedelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLEmbedElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLEmbedElement))
     }
 }
 
 impl HTMLEmbedElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLEmbedElement {
         HTMLEmbedElement {
-            htmlelement: HTMLElement::new_inherited(HTMLEmbedElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLEmbedElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmlfieldsetelement.rs b/components/script/dom/htmlfieldsetelement.rs
index 3ed4a82200c..a2396a847c9 100644
--- a/components/script/dom/htmlfieldsetelement.rs
+++ b/components/script/dom/htmlfieldsetelement.rs
@@ -11,12 +11,11 @@ use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLLegendElementDer
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::{AttributeHandlers, Element, ElementHelpers, HTMLFieldSetElementTypeId, HTMLButtonElementTypeId};
-use dom::element::{HTMLInputElementTypeId, HTMLSelectElementTypeId, HTMLTextAreaElementTypeId};
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::{AttributeHandlers, Element, ElementHelpers, ElementTypeId};
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlcollection::{HTMLCollection, CollectionFilter};
 use dom::htmlelement::HTMLElement;
-use dom::node::{DisabledStateHelpers, Node, NodeHelpers, ElementNodeTypeId, window_from_node};
+use dom::node::{DisabledStateHelpers, Node, NodeHelpers, NodeTypeId, window_from_node};
 use dom::validitystate::ValidityState;
 use dom::virtualmethods::VirtualMethods;
 
@@ -30,14 +29,14 @@ pub struct HTMLFieldSetElement {
 
 impl HTMLFieldSetElementDerived for EventTarget {
     fn is_htmlfieldsetelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLFieldSetElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLFieldSetElement))
     }
 }
 
 impl HTMLFieldSetElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLFieldSetElement {
         HTMLFieldSetElement {
-            htmlelement: HTMLElement::new_inherited(HTMLFieldSetElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLFieldSetElement, localName, prefix, document)
         }
     }
 
@@ -101,10 +100,10 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLFieldSetElement> {
                 }).collect();
                 for descendant in filtered.iter().flat_map(|child| child.traverse_preorder()) {
                     match descendant.type_id() {
-                        ElementNodeTypeId(HTMLButtonElementTypeId) |
-                        ElementNodeTypeId(HTMLInputElementTypeId) |
-                        ElementNodeTypeId(HTMLSelectElementTypeId) |
-                        ElementNodeTypeId(HTMLTextAreaElementTypeId) => {
+                        NodeTypeId::Element(ElementTypeId::HTMLButtonElement) |
+                        NodeTypeId::Element(ElementTypeId::HTMLInputElement) |
+                        NodeTypeId::Element(ElementTypeId::HTMLSelectElement) |
+                        NodeTypeId::Element(ElementTypeId::HTMLTextAreaElement) => {
                             descendant.set_disabled_state(true);
                             descendant.set_enabled_state(false);
                         },
@@ -133,10 +132,10 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLFieldSetElement> {
                 }).collect();
                 for descendant in filtered.iter().flat_map(|child| child.traverse_preorder()) {
                     match descendant.type_id() {
-                        ElementNodeTypeId(HTMLButtonElementTypeId) |
-                        ElementNodeTypeId(HTMLInputElementTypeId) |
-                        ElementNodeTypeId(HTMLSelectElementTypeId) |
-                        ElementNodeTypeId(HTMLTextAreaElementTypeId) => {
+                        NodeTypeId::Element(ElementTypeId::HTMLButtonElement) |
+                        NodeTypeId::Element(ElementTypeId::HTMLInputElement) |
+                        NodeTypeId::Element(ElementTypeId::HTMLSelectElement) |
+                        NodeTypeId::Element(ElementTypeId::HTMLTextAreaElement) => {
                             descendant.check_disabled_attribute();
                             descendant.check_ancestors_disabled_state_for_form_control();
                         },
diff --git a/components/script/dom/htmlfontelement.rs b/components/script/dom/htmlfontelement.rs
index 3edf195f2dc..4303668b0e5 100644
--- a/components/script/dom/htmlfontelement.rs
+++ b/components/script/dom/htmlfontelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLFontElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLFontElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLFontElement {
 
 impl HTMLFontElementDerived for EventTarget {
     fn is_htmlfontelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLFontElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLFontElement))
     }
 }
 
 impl HTMLFontElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLFontElement {
         HTMLFontElement {
-            htmlelement: HTMLElement::new_inherited(HTMLFontElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLFontElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmlformelement.rs b/components/script/dom/htmlformelement.rs
index 62f5e3aa62e..58a0e0e175b 100644
--- a/components/script/dom/htmlformelement.rs
+++ b/components/script/dom/htmlformelement.rs
@@ -14,19 +14,18 @@ use dom::bindings::global::Window;
 use dom::bindings::js::{JSRef, Temporary, OptionalRootable};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::{Document, DocumentHelpers};
-use dom::element::{Element, AttributeHandlers, HTMLFormElementTypeId, HTMLTextAreaElementTypeId, HTMLDataListElementTypeId};
-use dom::element::{HTMLInputElementTypeId, HTMLButtonElementTypeId, HTMLObjectElementTypeId, HTMLSelectElementTypeId};
-use dom::element::{HTMLOutputElementTypeId};
-use dom::event::{Event, EventHelpers, Bubbles, Cancelable};
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::{Element, AttributeHandlers, ElementTypeId};
+use dom::event::{Event, EventHelpers, EventBubbles, EventCancelable};
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
 use dom::htmlinputelement::HTMLInputElement;
 use dom::htmltextareaelement::HTMLTextAreaElement;
-use dom::node::{Node, NodeHelpers, ElementNodeTypeId, document_from_node, window_from_node};
+use dom::node::{Node, NodeHelpers, NodeTypeId, document_from_node, window_from_node};
 use hyper::method::Post;
 use servo_msg::constellation_msg::LoadData;
 use servo_util::str::DOMString;
-use script_task::{ScriptChan, TriggerLoadMsg};
+use script_task::ScriptChan;
+use script_task::ScriptMsg::TriggerLoadMsg;
 use std::ascii::OwnedAsciiExt;
 use url::UrlParser;
 use url::form_urlencoded::serialize;
@@ -42,14 +41,14 @@ pub struct HTMLFormElement {
 
 impl HTMLFormElementDerived for EventTarget {
     fn is_htmlformelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLFormElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLFormElement))
     }
 }
 
 impl HTMLFormElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLFormElement {
         HTMLFormElement {
-            htmlelement: HTMLElement::new_inherited(HTMLFormElementTypeId, localName, prefix, document),
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLFormElement, localName, prefix, document),
             marked_for_reset: Cell::new(false),
         }
     }
@@ -122,12 +121,12 @@ impl<'a> HTMLFormElementMethods for JSRef<'a, HTMLFormElement> {
 
     // https://html.spec.whatwg.org/multipage/forms.html#the-form-element:concept-form-submit
     fn Submit(self) {
-        self.submit(FromFormSubmitMethod, FormElement(self));
+        self.submit(SubmittedFrom::FromFormSubmitMethod, FormSubmitter::FormElement(self));
     }
 
     // https://html.spec.whatwg.org/multipage/forms.html#dom-form-reset
     fn Reset(self) {
-        self.reset(FromFormResetMethod);
+        self.reset(ResetFrom::FromFormResetMethod);
     }
 }
 
@@ -160,7 +159,8 @@ impl<'a> HTMLFormElementHelpers for JSRef<'a, HTMLFormElement> {
         // TODO: Handle validation
         let event = Event::new(Window(*win),
                                "submit".to_string(),
-                               Bubbles, Cancelable).root();
+                               EventBubbles::Bubbles,
+                               EventCancelable::Cancelable).root();
         event.set_trusted(true);
         let target: JSRef<EventTarget> = EventTargetCast::from_ref(self);
         target.DispatchEvent(*event).ok();
@@ -185,23 +185,23 @@ impl<'a> HTMLFormElementHelpers for JSRef<'a, HTMLFormElement> {
         // TODO: Handle browsing contexts, partially loaded documents (step 16-17)
 
         let parsed_data = match enctype {
-            UrlEncoded => serialize(form_data.iter().map(|d| (d.name.as_slice(), d.value.as_slice())), None),
+            FormEncType::UrlEncoded => serialize(form_data.iter().map(|d| (d.name.as_slice(), d.value.as_slice()))),
             _ => "".to_string() // TODO: Add serializers for the other encoding types
         };
 
         let mut load_data = LoadData::new(action_components);
         // Step 18
         match (scheme.as_slice(), method) {
-            (_, FormDialog) => return, // Unimplemented
-            ("http", FormGet) | ("https", FormGet) => {
+            (_, FormMethod::FormDialog) => return, // Unimplemented
+            ("http", FormMethod::FormGet) | ("https", FormMethod::FormGet) => {
                 load_data.url.query = Some(parsed_data);
             },
-            ("http", FormPost) | ("https", FormPost) => {
+            ("http", FormMethod::FormPost) | ("https", FormMethod::FormPost) => {
                 load_data.method = Post;
                 load_data.data = Some(parsed_data.into_bytes());
             },
             // https://html.spec.whatwg.org/multipage/forms.html#submit-get-action
-            ("ftp", _) | ("javascript", _) | ("data", FormGet) => (),
+            ("ftp", _) | ("javascript", _) | ("data", FormMethod::FormGet) => (),
             _ => return // Unimplemented (data and mailto)
         }
 
@@ -250,12 +250,12 @@ impl<'a> HTMLFormElementHelpers for JSRef<'a, HTMLFormElement> {
             if child.get_disabled_state() {
                 return None;
             }
-            if child.ancestors().any(|a| a.type_id() == ElementNodeTypeId(HTMLDataListElementTypeId)) {
+            if child.ancestors().any(|a| a.type_id() == NodeTypeId::Element(ElementTypeId::HTMLDataListElement)) {
                 return None;
             }
             // XXXManishearth don't include it if it is a button but not the submitter
             match child.type_id() {
-                ElementNodeTypeId(HTMLInputElementTypeId) => {
+                NodeTypeId::Element(ElementTypeId::HTMLInputElement) => {
                     let input: JSRef<HTMLInputElement> = HTMLInputElementCast::to_ref(child).unwrap();
                     let ty = input.Type();
                     let name = input.Name();
@@ -275,7 +275,7 @@ impl<'a> HTMLFormElementHelpers for JSRef<'a, HTMLFormElement> {
 
                     let mut value = input.Value();
                     let is_submitter = match submitter {
-                        Some(InputElement(s)) => {
+                        Some(FormSubmitter::InputElement(s)) => {
                             input == s
                         },
                         _ => false
@@ -302,19 +302,19 @@ impl<'a> HTMLFormElementHelpers for JSRef<'a, HTMLFormElement> {
                         })
                     }
                 }
-                ElementNodeTypeId(HTMLButtonElementTypeId) => {
+                NodeTypeId::Element(ElementTypeId::HTMLButtonElement) => {
                     // Unimplemented
                     None
                 }
-                ElementNodeTypeId(HTMLSelectElementTypeId) => {
+                NodeTypeId::Element(ElementTypeId::HTMLSelectElement) => {
                     // Unimplemented
                     None
                 }
-                ElementNodeTypeId(HTMLObjectElementTypeId) => {
+                NodeTypeId::Element(ElementTypeId::HTMLObjectElement) => {
                     // Unimplemented
                     None
                 }
-                ElementNodeTypeId(HTMLTextAreaElementTypeId) => {
+                NodeTypeId::Element(ElementTypeId::HTMLTextAreaElement) => {
                     // Unimplemented
                     None
                 }
@@ -347,7 +347,8 @@ impl<'a> HTMLFormElementHelpers for JSRef<'a, HTMLFormElement> {
         let win = window_from_node(self).root();
         let event = Event::new(Window(*win),
                                "reset".to_string(),
-                               Bubbles, Cancelable).root();
+                               EventBubbles::Bubbles,
+                               EventCancelable::Cancelable).root();
         let target: JSRef<EventTarget> = EventTargetCast::from_ref(self);
         target.DispatchEvent(*event).ok();
         if event.DefaultPrevented() {
@@ -360,26 +361,26 @@ impl<'a> HTMLFormElementHelpers for JSRef<'a, HTMLFormElement> {
         //       by the form, but good enough until html5ever lands
         for child in node.traverse_preorder() {
             match child.type_id() {
-                ElementNodeTypeId(HTMLInputElementTypeId) => {
+                NodeTypeId::Element(ElementTypeId::HTMLInputElement) => {
                     let input: JSRef<HTMLInputElement> = HTMLInputElementCast::to_ref(child)
                                                                                .unwrap();
                     input.reset()
                 }
                 // TODO HTMLKeygenElement unimplemented
-                //ElementNodeTypeID(HTMLKeygenElementTypeId) => {
+                //NodeTypeId::Element(ElementTypeId::HTMLKeygenElement) => {
                 //    // Unimplemented
                 //    {}
                 //}
-                ElementNodeTypeId(HTMLSelectElementTypeId) => {
+                NodeTypeId::Element(ElementTypeId::HTMLSelectElement) => {
                     // Unimplemented
                     {}
                 }
-                ElementNodeTypeId(HTMLTextAreaElementTypeId) => {
+                NodeTypeId::Element(ElementTypeId::HTMLTextAreaElement) => {
                     let textarea: JSRef<HTMLTextAreaElement> = HTMLTextAreaElementCast::to_ref(child)
                                                                                         .unwrap();
                     textarea.reset()
                 }
-                ElementNodeTypeId(HTMLOutputElementTypeId) => {
+                NodeTypeId::Element(ElementTypeId::HTMLOutputElement) => {
                     // Unimplemented
                     {}
                 }
@@ -424,8 +425,8 @@ pub enum FormSubmitter<'a> {
 impl<'a> FormSubmitter<'a> {
     fn action(&self) -> DOMString {
         match *self {
-            FormElement(form) => form.Action(),
-            InputElement(input_element) => {
+            FormSubmitter::FormElement(form) => form.Action(),
+            FormSubmitter::InputElement(input_element) => {
                 // FIXME(pcwalton): Make this a static atom.
                 input_element.get_form_attribute(&Atom::from_slice("formaction"),
                                                  |i| i.FormAction(),
@@ -436,8 +437,8 @@ impl<'a> FormSubmitter<'a> {
 
     fn enctype(&self) -> FormEncType {
         let attr = match *self {
-            FormElement(form) => form.Enctype(),
-            InputElement(input_element) => {
+            FormSubmitter::FormElement(form) => form.Enctype(),
+            FormSubmitter::InputElement(input_element) => {
                 // FIXME(pcwalton): Make this a static atom.
                 input_element.get_form_attribute(&Atom::from_slice("formenctype"),
                                                  |i| i.FormEnctype(),
@@ -445,18 +446,18 @@ impl<'a> FormSubmitter<'a> {
             }
         };
         match attr.as_slice() {
-            "multipart/form-data" => FormDataEncoded,
-            "text/plain" => TextPlainEncoded,
+            "multipart/form-data" => FormEncType::FormDataEncoded,
+            "text/plain" => FormEncType::TextPlainEncoded,
             // https://html.spec.whatwg.org/multipage/forms.html#attr-fs-enctype
             // urlencoded is the default
-            _ => UrlEncoded
+            _ => FormEncType::UrlEncoded
         }
     }
 
     fn method(&self) -> FormMethod {
         let attr = match *self {
-            FormElement(form) => form.Method(),
-            InputElement(input_element) => {
+            FormSubmitter::FormElement(form) => form.Method(),
+            FormSubmitter::InputElement(input_element) => {
                 // FIXME(pcwalton): Make this a static atom.
                 input_element.get_form_attribute(&Atom::from_slice("formmethod"),
                                                  |i| i.FormMethod(),
@@ -464,16 +465,16 @@ impl<'a> FormSubmitter<'a> {
             }
         };
         match attr.as_slice() {
-            "dialog" => FormDialog,
-            "post" => FormPost,
-            _ => FormGet
+            "dialog" => FormMethod::FormDialog,
+            "post" => FormMethod::FormPost,
+            _ => FormMethod::FormGet
         }
     }
 
     fn target(&self) -> DOMString {
         match *self {
-            FormElement(form) => form.Target(),
-            InputElement(input_element) => {
+            FormSubmitter::FormElement(form) => form.Target(),
+            FormSubmitter::InputElement(input_element) => {
                 // FIXME(pcwalton): Make this a static atom.
                 input_element.get_form_attribute(&Atom::from_slice("formtarget"),
                                                  |i| i.FormTarget(),
diff --git a/components/script/dom/htmlframeelement.rs b/components/script/dom/htmlframeelement.rs
index 23448387033..87b286d6094 100644
--- a/components/script/dom/htmlframeelement.rs
+++ b/components/script/dom/htmlframeelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLFrameElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLFrameElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLFrameElement {
 
 impl HTMLFrameElementDerived for EventTarget {
     fn is_htmlframeelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLFrameElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLFrameElement))
     }
 }
 
 impl HTMLFrameElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLFrameElement {
         HTMLFrameElement {
-            htmlelement: HTMLElement::new_inherited(HTMLFrameElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLFrameElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmlframesetelement.rs b/components/script/dom/htmlframesetelement.rs
index 9afa3ca02ef..8b92ced546d 100644
--- a/components/script/dom/htmlframesetelement.rs
+++ b/components/script/dom/htmlframesetelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLFrameSetElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLFrameSetElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLFrameSetElement {
 
 impl HTMLFrameSetElementDerived for EventTarget {
     fn is_htmlframesetelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLFrameSetElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLFrameSetElement))
     }
 }
 
 impl HTMLFrameSetElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLFrameSetElement {
         HTMLFrameSetElement {
-            htmlelement: HTMLElement::new_inherited(HTMLFrameSetElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLFrameSetElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmlheadelement.rs b/components/script/dom/htmlheadelement.rs
index b4bff814681..f37e50c688f 100644
--- a/components/script/dom/htmlheadelement.rs
+++ b/components/script/dom/htmlheadelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLHeadElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLHeadElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLHeadElement {
 
 impl HTMLHeadElementDerived for EventTarget {
     fn is_htmlheadelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLHeadElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLHeadElement))
     }
 }
 
 impl HTMLHeadElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLHeadElement {
         HTMLHeadElement {
-            htmlelement: HTMLElement::new_inherited(HTMLHeadElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLHeadElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmlheadingelement.rs b/components/script/dom/htmlheadingelement.rs
index c52c7cf7c0f..c8deabe4670 100644
--- a/components/script/dom/htmlheadingelement.rs
+++ b/components/script/dom/htmlheadingelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLHeadingElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLHeadingElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[jstraceable]
@@ -31,14 +31,14 @@ pub struct HTMLHeadingElement {
 
 impl HTMLHeadingElementDerived for EventTarget {
     fn is_htmlheadingelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLHeadingElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLHeadingElement))
     }
 }
 
 impl HTMLHeadingElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>, level: HeadingLevel) -> HTMLHeadingElement {
         HTMLHeadingElement {
-            htmlelement: HTMLElement::new_inherited(HTMLHeadingElementTypeId, localName, prefix, document),
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLHeadingElement, localName, prefix, document),
             level: level,
         }
     }
diff --git a/components/script/dom/htmlhrelement.rs b/components/script/dom/htmlhrelement.rs
index ec71ea141bd..e849716e3b5 100644
--- a/components/script/dom/htmlhrelement.rs
+++ b/components/script/dom/htmlhrelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLHRElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLHRElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLHRElement {
 
 impl HTMLHRElementDerived for EventTarget {
     fn is_htmlhrelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLHRElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLHRElement))
     }
 }
 
 impl HTMLHRElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLHRElement {
         HTMLHRElement {
-            htmlelement: HTMLElement::new_inherited(HTMLHRElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLHRElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmlhtmlelement.rs b/components/script/dom/htmlhtmlelement.rs
index dddde174b73..cf60c1e9568 100644
--- a/components/script/dom/htmlhtmlelement.rs
+++ b/components/script/dom/htmlhtmlelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLHtmlElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLHtmlElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLHtmlElement {
 
 impl HTMLHtmlElementDerived for EventTarget {
     fn is_htmlhtmlelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLHtmlElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLHtmlElement))
     }
 }
 
 impl HTMLHtmlElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLHtmlElement {
         HTMLHtmlElement {
-            htmlelement: HTMLElement::new_inherited(HTMLHtmlElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLHtmlElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmliframeelement.rs b/components/script/dom/htmliframeelement.rs
index 59c7011a9c7..8a9bfe572a4 100644
--- a/components/script/dom/htmliframeelement.rs
+++ b/components/script/dom/htmliframeelement.rs
@@ -12,11 +12,11 @@ use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLIFrameElementDer
 use dom::bindings::js::{JSRef, Temporary, OptionalRootable};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::{HTMLIFrameElementTypeId, Element};
+use dom::element::{ElementTypeId, Element};
 use dom::element::AttributeHandlers;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, NodeHelpers, ElementNodeTypeId, window_from_node};
+use dom::node::{Node, NodeHelpers, NodeTypeId, window_from_node};
 use dom::urlhelper::UrlHelper;
 use dom::virtualmethods::VirtualMethods;
 use dom::window::Window;
@@ -50,7 +50,7 @@ pub struct HTMLIFrameElement {
 
 impl HTMLIFrameElementDerived for EventTarget {
     fn is_htmliframeelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLIFrameElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLIFrameElement))
     }
 }
 
@@ -129,7 +129,7 @@ impl<'a> HTMLIFrameElementHelpers for JSRef<'a, HTMLIFrameElement> {
 impl HTMLIFrameElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLIFrameElement {
         HTMLIFrameElement {
-            htmlelement: HTMLElement::new_inherited(HTMLIFrameElementTypeId, localName, prefix, document),
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLIFrameElement, localName, prefix, document),
             size: Cell::new(None),
             sandbox: Cell::new(None),
         }
@@ -214,16 +214,16 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLIFrameElement> {
 
         match attr.local_name() {
             &atom!("sandbox") => {
-                let mut modes = AllowNothing as u8;
+                let mut modes = SandboxAllowance::AllowNothing as u8;
                 for word in attr.value().as_slice().split(' ') {
                     modes |= match word.to_ascii_lower().as_slice() {
-                        "allow-same-origin" => AllowSameOrigin,
-                        "allow-forms" => AllowForms,
-                        "allow-pointer-lock" => AllowPointerLock,
-                        "allow-popups" => AllowPopups,
-                        "allow-scripts" => AllowScripts,
-                        "allow-top-navigation" => AllowTopNavigation,
-                        _ => AllowNothing
+                        "allow-same-origin" => SandboxAllowance::AllowSameOrigin,
+                        "allow-forms" => SandboxAllowance::AllowForms,
+                        "allow-pointer-lock" => SandboxAllowance::AllowPointerLock,
+                        "allow-popups" => SandboxAllowance::AllowPopups,
+                        "allow-scripts" => SandboxAllowance::AllowScripts,
+                        "allow-top-navigation" => SandboxAllowance::AllowTopNavigation,
+                        _ => SandboxAllowance::AllowNothing
                     } as u8;
                 }
                 self.sandbox.set(Some(modes));
diff --git a/components/script/dom/htmlimageelement.rs b/components/script/dom/htmlimageelement.rs
index dc1ef7d6e26..151a5215319 100644
--- a/components/script/dom/htmlimageelement.rs
+++ b/components/script/dom/htmlimageelement.rs
@@ -11,11 +11,11 @@ use dom::bindings::codegen::InheritTypes::{NodeCast, ElementCast, HTMLElementCas
 use dom::bindings::js::{JS, JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::{Document, DocumentHelpers};
-use dom::element::{Element, HTMLImageElementTypeId};
+use dom::element::{Element, ElementTypeId};
 use dom::element::AttributeHandlers;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId, NodeHelpers, OtherNodeDamage, window_from_node};
+use dom::node::{Node, NodeTypeId, NodeHelpers, NodeDamage, window_from_node};
 use dom::virtualmethods::VirtualMethods;
 use servo_net::image_cache_task;
 use servo_util::geometry::to_px;
@@ -32,7 +32,7 @@ pub struct HTMLImageElement {
 
 impl HTMLImageElementDerived for EventTarget {
     fn is_htmlimageelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLImageElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLImageElement))
     }
 }
 
@@ -69,7 +69,7 @@ impl<'a> PrivateHTMLImageElementHelpers for JSRef<'a, HTMLImageElement> {
 impl HTMLImageElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLImageElement {
         HTMLImageElement {
-            htmlelement: HTMLElement::new_inherited(HTMLImageElementTypeId, localName, prefix, document),
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLImageElement, localName, prefix, document),
             image: DOMRefCell::new(None),
         }
     }
@@ -118,7 +118,7 @@ impl<'a> HTMLImageElementMethods for JSRef<'a, HTMLImageElement> {
         // recreate the flow (picking up image changes on the way). The image cache task needs a
         // rewrite to modern Rust.
         let node: JSRef<Node> = NodeCast::from_ref(self);
-        node.dirty(OtherNodeDamage);
+        node.dirty(NodeDamage::OtherNodeDamage);
 
         let rect = node.get_bounding_content_box();
         to_px(rect.size.width) as u32
@@ -136,7 +136,7 @@ impl<'a> HTMLImageElementMethods for JSRef<'a, HTMLImageElement> {
         // recreate the flow (picking up image changes on the way). The image cache task needs a
         // rewrite to modern Rust.
         let node: JSRef<Node> = NodeCast::from_ref(self);
-        node.dirty(OtherNodeDamage);
+        node.dirty(NodeDamage::OtherNodeDamage);
 
         let rect = node.get_bounding_content_box();
         to_px(rect.size.height) as u32
diff --git a/components/script/dom/htmlinputelement.rs b/components/script/dom/htmlinputelement.rs
index 3ea2a38a686..b051a4f8f43 100644
--- a/components/script/dom/htmlinputelement.rs
+++ b/components/script/dom/htmlinputelement.rs
@@ -3,7 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::activation::Activatable;
-use dom::attr::{Attr, AttrValue, UIntAttrValue};
+use dom::attr::{Attr, AttrValue};
 use dom::attr::AttrHelpers;
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::AttrBinding::AttrMethods;
@@ -19,18 +19,20 @@ use dom::bindings::js::{Comparable, JS, JSRef, Root, Temporary, OptionalRootable
 use dom::bindings::js::{ResultRootable, RootedReference, MutNullableJS};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::{Document, DocumentHelpers};
-use dom::element::{AttributeHandlers, Element, HTMLInputElementTypeId};
+use dom::element::{AttributeHandlers, Element, ElementTypeId};
 use dom::element::{RawLayoutElementHelpers, ActivationElementHelpers};
-use dom::event::{Event, Bubbles, NotCancelable, EventHelpers};
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::event::{Event, EventBubbles, EventCancelable, EventHelpers};
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
 use dom::keyboardevent::KeyboardEvent;
-use dom::htmlformelement::{InputElement, FormControl, HTMLFormElement, HTMLFormElementHelpers};
-use dom::htmlformelement::{NotFromFormSubmitMethod, NotFromFormResetMethod};
-use dom::node::{DisabledStateHelpers, Node, NodeHelpers, ElementNodeTypeId, OtherNodeDamage};
+use dom::htmlformelement::{FormSubmitter, FormControl, HTMLFormElement, HTMLFormElementHelpers};
+use dom::htmlformelement::{SubmittedFrom, ResetFrom};
+use dom::node::{DisabledStateHelpers, Node, NodeHelpers, NodeDamage, NodeTypeId};
 use dom::node::{document_from_node, window_from_node};
 use dom::virtualmethods::VirtualMethods;
-use textinput::{Single, TextInput, TriggerDefaultAction, DispatchInput, Nothing};
+use textinput::TextInput;
+use textinput::KeyReaction::{TriggerDefaultAction, DispatchInput, Nothing};
+use textinput::Lines::Single;
 
 use servo_util::str::DOMString;
 use string_cache::Atom;
@@ -91,14 +93,14 @@ impl InputActivationState {
             checked_changed: false,
             checked_radio: Default::default(),
             was_mutable: false,
-            old_type: InputText
+            old_type: InputType::InputText
         }
     }
 }
 
 impl HTMLInputElementDerived for EventTarget {
     fn is_htmlinputelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLInputElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLInputElement))
     }
 }
 
@@ -107,8 +109,8 @@ static DEFAULT_INPUT_SIZE: u32 = 20;
 impl HTMLInputElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLInputElement {
         HTMLInputElement {
-            htmlelement: HTMLElement::new_inherited(HTMLInputElementTypeId, localName, prefix, document),
-            input_type: Cell::new(InputText),
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLInputElement, localName, prefix, document),
+            input_type: Cell::new(InputType::InputText),
             checked: Cell::new(false),
             indeterminate: Cell::new(false),
             checked_changed: Cell::new(false),
@@ -151,12 +153,12 @@ impl LayoutHTMLInputElementHelpers for JS<HTMLInputElement> {
         }
 
         match (*self.unsafe_get()).input_type.get() {
-            InputCheckbox | InputRadio => "".to_string(),
-            InputFile | InputImage => "".to_string(),
-            InputButton => get_raw_attr_value(self).unwrap_or_else(|| "".to_string()),
-            InputSubmit => get_raw_attr_value(self).unwrap_or_else(|| DEFAULT_SUBMIT_VALUE.to_string()),
-            InputReset => get_raw_attr_value(self).unwrap_or_else(|| DEFAULT_RESET_VALUE.to_string()),
-            InputPassword => {
+            InputType::InputCheckbox | InputType::InputRadio => "".to_string(),
+            InputType::InputFile | InputType::InputImage => "".to_string(),
+            InputType::InputButton => get_raw_attr_value(self).unwrap_or_else(|| "".to_string()),
+            InputType::InputSubmit => get_raw_attr_value(self).unwrap_or_else(|| DEFAULT_SUBMIT_VALUE.to_string()),
+            InputType::InputReset => get_raw_attr_value(self).unwrap_or_else(|| DEFAULT_RESET_VALUE.to_string()),
+            InputType::InputPassword => {
                 let raw = get_raw_textinput_value(self);
                 String::from_char(raw.char_len(), '●')
             }
@@ -326,7 +328,7 @@ fn in_same_group<'a,'b>(other: JSRef<'a, HTMLInputElement>,
                         group: Option<&str>) -> bool {
     let other_owner = other.form_owner().root();
     let other_owner = other_owner.root_ref();
-    other.input_type.get() == InputRadio &&
+    other.input_type.get() == InputType::InputRadio &&
     // TODO Both a and b are in the same home subtree.
     other_owner.equals(owner) &&
     // TODO should be a unicode compatibility caseless match
@@ -341,7 +343,7 @@ impl<'a> HTMLInputElementHelpers for JSRef<'a, HTMLInputElement> {
     fn force_relayout(self) {
         let doc = document_from_node(self).root();
         let node: JSRef<Node> = NodeCast::from_ref(self);
-        doc.content_changed(node, OtherNodeDamage)
+        doc.content_changed(node, NodeDamage::OtherNodeDamage)
     }
 
     fn radio_group_updated(self, group: Option<&str>) {
@@ -365,7 +367,7 @@ impl<'a> HTMLInputElementHelpers for JSRef<'a, HTMLInputElement> {
             self.checked_changed.set(true);
         }
 
-        if self.input_type.get() == InputRadio && checked {
+        if self.input_type.get() == InputType::InputRadio && checked {
             broadcast_radio_checked(self,
                                     self.get_radio_group_name()
                                         .as_ref()
@@ -410,24 +412,24 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLInputElement> {
             }
             &atom!("size") => {
                 match *attr.value() {
-                    UIntAttrValue(_, value) => self.size.set(value),
-                    _ => panic!("Expected a UIntAttrValue"),
+                    AttrValue::UInt(_, value) => self.size.set(value),
+                    _ => panic!("Expected an AttrValue::UInt"),
                 }
                 self.force_relayout();
             }
             &atom!("type") => {
                 let value = attr.value();
                 self.input_type.set(match value.as_slice() {
-                    "button" => InputButton,
-                    "submit" => InputSubmit,
-                    "reset" => InputReset,
-                    "file" => InputFile,
-                    "radio" => InputRadio,
-                    "checkbox" => InputCheckbox,
-                    "password" => InputPassword,
-                    _ => InputText,
+                    "button" => InputType::InputButton,
+                    "submit" => InputType::InputSubmit,
+                    "reset" => InputType::InputReset,
+                    "file" => InputType::InputFile,
+                    "radio" => InputType::InputRadio,
+                    "checkbox" => InputType::InputCheckbox,
+                    "password" => InputType::InputPassword,
+                    _ => InputType::InputText,
                 });
-                if self.input_type.get() == InputRadio {
+                if self.input_type.get() == InputType::InputRadio {
                     self.radio_group_updated(self.get_radio_group_name()
                                                  .as_ref()
                                                  .map(|group| group.as_slice()));
@@ -441,7 +443,7 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLInputElement> {
                 }
             }
             &atom!("name") => {
-                if self.input_type.get() == InputRadio {
+                if self.input_type.get() == InputType::InputRadio {
                     let value = attr.value();
                     self.radio_group_updated(Some(value.as_slice()));
                 }
@@ -474,13 +476,13 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLInputElement> {
                 self.force_relayout();
             }
             &atom!("type") => {
-                if self.input_type.get() == InputRadio {
+                if self.input_type.get() == InputType::InputRadio {
                     broadcast_radio_checked(*self,
                                             self.get_radio_group_name()
                                                 .as_ref()
                                                 .map(|group| group.as_slice()));
                 }
-                self.input_type.set(InputText);
+                self.input_type.set(InputType::InputText);
                 self.force_relayout();
             }
             &atom!("value") => {
@@ -490,7 +492,7 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLInputElement> {
                 }
             }
             &atom!("name") => {
-                if self.input_type.get() == InputRadio {
+                if self.input_type.get() == InputType::InputRadio {
                     self.radio_group_updated(None);
                 }
             }
@@ -539,7 +541,7 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLInputElement> {
 
         if "click" == event.Type().as_slice() && !event.DefaultPrevented() {
             match self.input_type.get() {
-                InputRadio => self.update_checked_state(true, true),
+                InputType::InputRadio => self.update_checked_state(true, true),
                 _ => {}
             }
 
@@ -551,7 +553,8 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLInputElement> {
             let doc = document_from_node(*self).root();
             doc.request_focus(ElementCast::from_ref(*self));
         } else if "keydown" == event.Type().as_slice() && !event.DefaultPrevented() &&
-            (self.input_type.get() == InputText || self.input_type.get() == InputPassword) {
+            (self.input_type.get() == InputType::InputText ||
+             self.input_type.get() == InputType::InputPassword) {
                 let keyevent: Option<JSRef<KeyboardEvent>> = KeyboardEventCast::to_ref(event);
                 keyevent.map(|keyevent| {
                     match self.textinput.borrow_mut().handle_keydown(keyevent) {
@@ -589,11 +592,11 @@ impl<'a> FormControl<'a> for JSRef<'a, HTMLInputElement> {
     // https://html.spec.whatwg.org/multipage/forms.html#the-input-element:concept-form-reset-control
     fn reset(self) {
         match self.input_type.get() {
-            InputRadio | InputCheckbox => {
+            InputType::InputRadio | InputType::InputCheckbox => {
                 self.update_checked_state(self.DefaultChecked(), false);
                 self.checked_changed.set(false);
             },
-            InputImage => (),
+            InputType::InputImage => (),
             _ => ()
         }
 
@@ -617,10 +620,10 @@ impl<'a> Activatable for JSRef<'a, HTMLInputElement> {
         if cache.was_mutable {
             match ty {
                 // https://html.spec.whatwg.org/multipage/forms.html#submit-button-state-(type=submit):activation-behavior
-                // InputSubmit => (), // No behavior defined
+                // InputType::InputSubmit => (), // No behavior defined
                 // https://html.spec.whatwg.org/multipage/forms.html#reset-button-state-(type=reset):activation-behavior
-                // InputSubmit => (), // No behavior defined
-                InputCheckbox => {
+                // InputType::InputSubmit => (), // No behavior defined
+                InputType::InputCheckbox => {
                     // https://html.spec.whatwg.org/multipage/forms.html#checkbox-state-(type=checkbox):pre-click-activation-steps
                     // cache current values of `checked` and `indeterminate`
                     // we may need to restore them later
@@ -631,7 +634,7 @@ impl<'a> Activatable for JSRef<'a, HTMLInputElement> {
                     self.SetChecked(!cache.checked);
                 },
                 // https://html.spec.whatwg.org/multipage/forms.html#radio-button-state-(type=radio):pre-click-activation-steps
-                InputRadio => {
+                InputType::InputRadio => {
                     //TODO: if not in document, use root ancestor instead of document
                     let owner = self.form_owner().root();
                     let doc = document_from_node(*self).root();
@@ -666,11 +669,11 @@ impl<'a> Activatable for JSRef<'a, HTMLInputElement> {
         }
         match ty {
             // https://html.spec.whatwg.org/multipage/forms.html#submit-button-state-(type=submit):activation-behavior
-            // InputSubmit => (), // No behavior defined
+            // InputType::InputSubmit => (), // No behavior defined
             // https://html.spec.whatwg.org/multipage/forms.html#reset-button-state-(type=reset):activation-behavior
-            // InputReset => (), // No behavior defined
+            // InputType::InputReset => (), // No behavior defined
             // https://html.spec.whatwg.org/multipage/forms.html#checkbox-state-(type=checkbox):canceled-activation-steps
-            InputCheckbox => {
+            InputType::InputCheckbox => {
                 // We want to restore state only if the element had been changed in the first place
                 if cache.was_mutable {
                     self.SetIndeterminate(cache.indeterminate);
@@ -679,7 +682,7 @@ impl<'a> Activatable for JSRef<'a, HTMLInputElement> {
                 }
             },
             // https://html.spec.whatwg.org/multipage/forms.html#radio-button-state-(type=radio):canceled-activation-steps
-            InputRadio => {
+            InputType::InputRadio => {
                 // We want to restore state only if the element had been changed in the first place
                 if cache.was_mutable {
                     let old_checked: Option<Root<HTMLInputElement>> = cache.checked_radio.get().root();
@@ -691,7 +694,7 @@ impl<'a> Activatable for JSRef<'a, HTMLInputElement> {
                             if name == o.get_radio_group_name() && // TODO should be compatibility caseless
                                self.form_owner() == o.form_owner() &&
                                // TODO Both a and b are in the same home subtree
-                               o.input_type.get() == InputRadio {
+                               o.input_type.get() == InputType::InputRadio {
                                     o.SetChecked(true);
                             } else {
                                 self.SetChecked(false);
@@ -715,39 +718,42 @@ impl<'a> Activatable for JSRef<'a, HTMLInputElement> {
             return;
         }
         match ty {
-            InputSubmit => {
+            InputType::InputSubmit => {
                 // https://html.spec.whatwg.org/multipage/forms.html#submit-button-state-(type=submit):activation-behavior
                 // FIXME (Manishearth): support document owners (needs ability to get parent browsing context)
                 if self.mutable() /* and document owner is fully active */ {
                     self.form_owner().map(|o| {
-                        o.root().submit(NotFromFormSubmitMethod, InputElement(self.clone()))
+                        o.root().submit(SubmittedFrom::NotFromFormSubmitMethod,
+                                        FormSubmitter::InputElement(self.clone()))
                     });
                 }
             },
-            InputReset => {
+            InputType::InputReset => {
                 // https://html.spec.whatwg.org/multipage/forms.html#reset-button-state-(type=reset):activation-behavior
                 // FIXME (Manishearth): support document owners (needs ability to get parent browsing context)
                 if self.mutable() /* and document owner is fully active */ {
                     self.form_owner().map(|o| {
-                        o.root().reset(NotFromFormResetMethod)
+                        o.root().reset(ResetFrom::NotFromFormResetMethod)
                     });
                 }
             },
-            InputCheckbox | InputRadio => {
+            InputType::InputCheckbox | InputType::InputRadio => {
                 // https://html.spec.whatwg.org/multipage/forms.html#checkbox-state-(type=checkbox):activation-behavior
                 // https://html.spec.whatwg.org/multipage/forms.html#radio-button-state-(type=radio):activation-behavior
                 if self.mutable() {
                     let win = window_from_node(*self).root();
                     let event = Event::new(Window(*win),
                                            "input".to_string(),
-                                           Bubbles, NotCancelable).root();
+                                           EventBubbles::Bubbles,
+                                           EventCancelable::NotCancelable).root();
                     event.set_trusted(true);
                     let target: JSRef<EventTarget> = EventTargetCast::from_ref(*self);
                     target.DispatchEvent(*event).ok();
 
                     let event = Event::new(Window(*win),
                                            "change".to_string(),
-                                           Bubbles, NotCancelable).root();
+                                           EventBubbles::Bubbles,
+                                           EventCancelable::NotCancelable).root();
                     event.set_trusted(true);
                     let target: JSRef<EventTarget> = EventTargetCast::from_ref(*self);
                     target.DispatchEvent(*event).ok();
diff --git a/components/script/dom/htmllabelelement.rs b/components/script/dom/htmllabelelement.rs
index f1932dc3ad3..f7b1fa9f08e 100644
--- a/components/script/dom/htmllabelelement.rs
+++ b/components/script/dom/htmllabelelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLLabelElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLLabelElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLLabelElement {
 
 impl HTMLLabelElementDerived for EventTarget {
     fn is_htmllabelelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLLabelElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLLabelElement))
     }
 }
 
 impl HTMLLabelElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLLabelElement {
         HTMLLabelElement {
-            htmlelement: HTMLElement::new_inherited(HTMLLabelElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLLabelElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmllegendelement.rs b/components/script/dom/htmllegendelement.rs
index 5e98fa5b986..5d888bf440c 100644
--- a/components/script/dom/htmllegendelement.rs
+++ b/components/script/dom/htmllegendelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLLegendElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLLegendElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLLegendElement {
 
 impl HTMLLegendElementDerived for EventTarget {
     fn is_htmllegendelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLLegendElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLLegendElement))
     }
 }
 
 impl HTMLLegendElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLLegendElement {
         HTMLLegendElement {
-            htmlelement: HTMLElement::new_inherited(HTMLLegendElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLLegendElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmllielement.rs b/components/script/dom/htmllielement.rs
index 16bbd46833f..022684c5317 100644
--- a/components/script/dom/htmllielement.rs
+++ b/components/script/dom/htmllielement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLLIElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLLIElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLLIElement {
 
 impl HTMLLIElementDerived for EventTarget {
     fn is_htmllielement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLLIElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLLIElement))
     }
 }
 
 impl HTMLLIElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLLIElement {
         HTMLLIElement {
-            htmlelement: HTMLElement::new_inherited(HTMLLIElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLLIElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmllinkelement.rs b/components/script/dom/htmllinkelement.rs
index 2f0a3993815..575c9a459d4 100644
--- a/components/script/dom/htmllinkelement.rs
+++ b/components/script/dom/htmllinkelement.rs
@@ -12,10 +12,10 @@ use dom::bindings::js::{MutNullableJS, JSRef, Temporary, OptionalRootable};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
 use dom::domtokenlist::DOMTokenList;
-use dom::element::{AttributeHandlers, Element, HTMLLinkElementTypeId};
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::{AttributeHandlers, Element, ElementTypeId};
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, NodeHelpers, ElementNodeTypeId, window_from_node};
+use dom::node::{Node, NodeHelpers, NodeTypeId, window_from_node};
 use dom::virtualmethods::VirtualMethods;
 use layout_interface::{LayoutChan, LoadStylesheetMsg};
 use servo_util::str::{DOMString, HTML_SPACE_CHARACTERS};
@@ -33,14 +33,14 @@ pub struct HTMLLinkElement {
 
 impl HTMLLinkElementDerived for EventTarget {
     fn is_htmllinkelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLLinkElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLLinkElement))
     }
 }
 
 impl HTMLLinkElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLLinkElement {
         HTMLLinkElement {
-            htmlelement: HTMLElement::new_inherited(HTMLLinkElementTypeId, localName, prefix, document),
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLLinkElement, localName, prefix, document),
             rel_list: Default::default(),
         }
     }
diff --git a/components/script/dom/htmlmapelement.rs b/components/script/dom/htmlmapelement.rs
index e11c6bdf5c0..8fd64b949e3 100644
--- a/components/script/dom/htmlmapelement.rs
+++ b/components/script/dom/htmlmapelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLMapElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLMapElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLMapElement {
 
 impl HTMLMapElementDerived for EventTarget {
     fn is_htmlmapelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLMapElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLMapElement))
     }
 }
 
 impl HTMLMapElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLMapElement {
         HTMLMapElement {
-            htmlelement: HTMLElement::new_inherited(HTMLMapElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLMapElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmlmediaelement.rs b/components/script/dom/htmlmediaelement.rs
index 3cc03a64d1c..09473d017b5 100644
--- a/components/script/dom/htmlmediaelement.rs
+++ b/components/script/dom/htmlmediaelement.rs
@@ -6,10 +6,10 @@ use dom::bindings::js::{JSRef};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::bindings::codegen::InheritTypes::HTMLMediaElementDerived;
 use dom::document::Document;
-use dom::element::{ElementTypeId, HTMLAudioElementTypeId, HTMLVideoElementTypeId};
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::ElementNodeTypeId;
+use dom::node::NodeTypeId;
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,8 +20,8 @@ pub struct HTMLMediaElement {
 impl HTMLMediaElementDerived for EventTarget {
     fn is_htmlmediaelement(&self) -> bool {
         match *self.type_id() {
-            NodeTargetTypeId(ElementNodeTypeId(HTMLVideoElementTypeId)) |
-            NodeTargetTypeId(ElementNodeTypeId(HTMLAudioElementTypeId)) => true,
+            EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLVideoElement)) |
+            EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLAudioElement)) => true,
             _ => false
         }
     }
diff --git a/components/script/dom/htmlmetaelement.rs b/components/script/dom/htmlmetaelement.rs
index fda51c6d277..a32a738dd1b 100644
--- a/components/script/dom/htmlmetaelement.rs
+++ b/components/script/dom/htmlmetaelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLMetaElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLMetaElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLMetaElement {
 
 impl HTMLMetaElementDerived for EventTarget {
     fn is_htmlmetaelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLMetaElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLMetaElement))
     }
 }
 
 impl HTMLMetaElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLMetaElement {
         HTMLMetaElement {
-            htmlelement: HTMLElement::new_inherited(HTMLMetaElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLMetaElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmlmeterelement.rs b/components/script/dom/htmlmeterelement.rs
index bb88e499444..622d753ee4a 100644
--- a/components/script/dom/htmlmeterelement.rs
+++ b/components/script/dom/htmlmeterelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLMeterElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLMeterElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLMeterElement {
 
 impl HTMLMeterElementDerived for EventTarget {
     fn is_htmlmeterelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLMeterElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLMeterElement))
     }
 }
 
 impl HTMLMeterElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLMeterElement {
         HTMLMeterElement {
-            htmlelement: HTMLElement::new_inherited(HTMLMeterElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLMeterElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmlmodelement.rs b/components/script/dom/htmlmodelement.rs
index e1cc1af706e..746b952d551 100644
--- a/components/script/dom/htmlmodelement.rs
+++ b/components/script/dom/htmlmodelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLModElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLModElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLModElement {
 
 impl HTMLModElementDerived for EventTarget {
     fn is_htmlmodelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLModElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLModElement))
     }
 }
 
 impl HTMLModElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLModElement {
         HTMLModElement {
-            htmlelement: HTMLElement::new_inherited(HTMLModElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLModElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmlobjectelement.rs b/components/script/dom/htmlobjectelement.rs
index 009c67ea42e..411ecfd7b6e 100644
--- a/components/script/dom/htmlobjectelement.rs
+++ b/components/script/dom/htmlobjectelement.rs
@@ -12,11 +12,11 @@ use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast};
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::{Element, HTMLObjectElementTypeId};
+use dom::element::{Element, ElementTypeId};
 use dom::element::AttributeHandlers;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId, NodeHelpers, window_from_node};
+use dom::node::{Node, NodeTypeId, NodeHelpers, window_from_node};
 use dom::validitystate::ValidityState;
 use dom::virtualmethods::VirtualMethods;
 
@@ -34,14 +34,14 @@ pub struct HTMLObjectElement {
 
 impl HTMLObjectElementDerived for EventTarget {
     fn is_htmlobjectelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLObjectElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLObjectElement))
     }
 }
 
 impl HTMLObjectElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLObjectElement {
         HTMLObjectElement {
-            htmlelement: HTMLElement::new_inherited(HTMLObjectElementTypeId, localName, prefix, document),
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLObjectElement, localName, prefix, document),
         }
     }
 
diff --git a/components/script/dom/htmlolistelement.rs b/components/script/dom/htmlolistelement.rs
index 8b1fdbe01d1..a450800b442 100644
--- a/components/script/dom/htmlolistelement.rs
+++ b/components/script/dom/htmlolistelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLOListElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLOListElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLOListElement {
 
 impl HTMLOListElementDerived for EventTarget {
     fn is_htmlolistelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLOListElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLOListElement))
     }
 }
 
 impl HTMLOListElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLOListElement {
         HTMLOListElement {
-            htmlelement: HTMLElement::new_inherited(HTMLOListElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLOListElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmloptgroupelement.rs b/components/script/dom/htmloptgroupelement.rs
index e464fccfaf6..ba954cc035f 100644
--- a/components/script/dom/htmloptgroupelement.rs
+++ b/components/script/dom/htmloptgroupelement.rs
@@ -11,10 +11,10 @@ use dom::bindings::codegen::InheritTypes::{HTMLOptGroupElementDerived, HTMLOptio
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::{AttributeHandlers, HTMLOptGroupElementTypeId};
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::{AttributeHandlers, ElementTypeId};
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{DisabledStateHelpers, Node, NodeHelpers, ElementNodeTypeId};
+use dom::node::{DisabledStateHelpers, Node, NodeHelpers, NodeTypeId};
 use dom::virtualmethods::VirtualMethods;
 
 use servo_util::str::DOMString;
@@ -27,14 +27,14 @@ pub struct HTMLOptGroupElement {
 
 impl HTMLOptGroupElementDerived for EventTarget {
     fn is_htmloptgroupelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLOptGroupElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLOptGroupElement))
     }
 }
 
 impl HTMLOptGroupElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLOptGroupElement {
         HTMLOptGroupElement {
-            htmlelement: HTMLElement::new_inherited(HTMLOptGroupElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLOptGroupElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmloptionelement.rs b/components/script/dom/htmloptionelement.rs
index c97b32c906e..0610ed8c558 100644
--- a/components/script/dom/htmloptionelement.rs
+++ b/components/script/dom/htmloptionelement.rs
@@ -15,10 +15,10 @@ use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::characterdata::CharacterData;
 use dom::document::Document;
-use dom::element::{AttributeHandlers, Element, ElementHelpers, HTMLOptionElementTypeId};
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::{AttributeHandlers, Element, ElementHelpers, ElementTypeId};
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{DisabledStateHelpers, Node, NodeHelpers, ElementNodeTypeId};
+use dom::node::{DisabledStateHelpers, Node, NodeHelpers, NodeTypeId};
 use dom::virtualmethods::VirtualMethods;
 
 use servo_util::str::{DOMString, split_html_space_chars};
@@ -31,14 +31,14 @@ pub struct HTMLOptionElement {
 
 impl HTMLOptionElementDerived for EventTarget {
     fn is_htmloptionelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLOptionElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLOptionElement))
     }
 }
 
 impl HTMLOptionElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLOptionElement {
         HTMLOptionElement {
-            htmlelement: HTMLElement::new_inherited(HTMLOptionElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLOptionElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmloutputelement.rs b/components/script/dom/htmloutputelement.rs
index 4622fe02f98..73e58f31906 100644
--- a/components/script/dom/htmloutputelement.rs
+++ b/components/script/dom/htmloutputelement.rs
@@ -8,10 +8,10 @@ use dom::bindings::codegen::InheritTypes::HTMLOutputElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLOutputElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId, window_from_node};
+use dom::node::{Node, NodeTypeId, window_from_node};
 use dom::validitystate::ValidityState;
 use servo_util::str::DOMString;
 
@@ -22,14 +22,14 @@ pub struct HTMLOutputElement {
 
 impl HTMLOutputElementDerived for EventTarget {
     fn is_htmloutputelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLOutputElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLOutputElement))
     }
 }
 
 impl HTMLOutputElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLOutputElement {
         HTMLOutputElement {
-            htmlelement: HTMLElement::new_inherited(HTMLOutputElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLOutputElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmlparagraphelement.rs b/components/script/dom/htmlparagraphelement.rs
index a6d7b346b3a..5cd07ac1929 100644
--- a/components/script/dom/htmlparagraphelement.rs
+++ b/components/script/dom/htmlparagraphelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLParagraphElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLParagraphElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLParagraphElement {
 
 impl HTMLParagraphElementDerived for EventTarget {
     fn is_htmlparagraphelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLParagraphElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLParagraphElement))
     }
 }
 
 impl HTMLParagraphElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLParagraphElement {
         HTMLParagraphElement {
-            htmlelement: HTMLElement::new_inherited(HTMLParagraphElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLParagraphElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmlparamelement.rs b/components/script/dom/htmlparamelement.rs
index a7ceff0b1b3..9aa5ec02499 100644
--- a/components/script/dom/htmlparamelement.rs
+++ b/components/script/dom/htmlparamelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLParamElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLParamElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLParamElement {
 
 impl HTMLParamElementDerived for EventTarget {
     fn is_htmlparamelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLParamElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLParamElement))
     }
 }
 
 impl HTMLParamElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLParamElement {
         HTMLParamElement {
-            htmlelement: HTMLElement::new_inherited(HTMLParamElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLParamElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmlpreelement.rs b/components/script/dom/htmlpreelement.rs
index 7a25822a569..bc4e840bee3 100644
--- a/components/script/dom/htmlpreelement.rs
+++ b/components/script/dom/htmlpreelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLPreElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLPreElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLPreElement {
 
 impl HTMLPreElementDerived for EventTarget {
     fn is_htmlpreelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLPreElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLPreElement))
     }
 }
 
 impl HTMLPreElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLPreElement {
         HTMLPreElement {
-            htmlelement: HTMLElement::new_inherited(HTMLPreElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLPreElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmlprogresselement.rs b/components/script/dom/htmlprogresselement.rs
index 18bd90869b6..648a9bf2fbb 100644
--- a/components/script/dom/htmlprogresselement.rs
+++ b/components/script/dom/htmlprogresselement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLProgressElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLProgressElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLProgressElement {
 
 impl HTMLProgressElementDerived for EventTarget {
     fn is_htmlprogresselement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLProgressElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLProgressElement))
     }
 }
 
 impl HTMLProgressElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLProgressElement {
         HTMLProgressElement {
-            htmlelement: HTMLElement::new_inherited(HTMLProgressElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLProgressElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmlquoteelement.rs b/components/script/dom/htmlquoteelement.rs
index 5dcdd92250a..3160b705b4f 100644
--- a/components/script/dom/htmlquoteelement.rs
+++ b/components/script/dom/htmlquoteelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLQuoteElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLQuoteElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLQuoteElement {
 
 impl HTMLQuoteElementDerived for EventTarget {
     fn is_htmlquoteelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLQuoteElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLQuoteElement))
     }
 }
 
 impl HTMLQuoteElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLQuoteElement {
         HTMLQuoteElement {
-            htmlelement: HTMLElement::new_inherited(HTMLQuoteElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLQuoteElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmlscriptelement.rs b/components/script/dom/htmlscriptelement.rs
index 48a85f9b022..9432768e816 100644
--- a/components/script/dom/htmlscriptelement.rs
+++ b/components/script/dom/htmlscriptelement.rs
@@ -15,16 +15,15 @@ use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast, NodeCas
 use dom::bindings::js::{JSRef, Temporary, OptionalRootable};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::{HTMLScriptElementTypeId, Element, AttributeHandlers};
-use dom::element::{ElementCreator, ParserCreated};
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::{ElementTypeId, Element, AttributeHandlers, ElementCreator};
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, NodeHelpers, ElementNodeTypeId, window_from_node, CloneChildrenFlag};
+use dom::node::{Node, NodeHelpers, NodeTypeId, window_from_node, CloneChildrenFlag};
 use dom::virtualmethods::VirtualMethods;
 use dom::window::WindowHelpers;
 
 use encoding::all::UTF_8;
-use encoding::types::{Encoding, DecodeReplace};
+use encoding::types::{Encoding, DecoderTrap};
 use servo_net::resource_task::load_whole_resource;
 use servo_util::str::{DOMString, HTML_SPACE_CHARACTERS, StaticStringVec};
 use std::cell::Cell;
@@ -54,7 +53,7 @@ pub struct HTMLScriptElement {
 
 impl HTMLScriptElementDerived for EventTarget {
     fn is_htmlscriptelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLScriptElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLScriptElement))
     }
 }
 
@@ -62,10 +61,10 @@ impl HTMLScriptElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>,
                      creator: ElementCreator) -> HTMLScriptElement {
         HTMLScriptElement {
-            htmlelement: HTMLElement::new_inherited(HTMLScriptElementTypeId, localName, prefix, document),
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLScriptElement, localName, prefix, document),
             already_started: Cell::new(false),
-            parser_inserted: Cell::new(creator == ParserCreated),
-            non_blocking: Cell::new(creator != ParserCreated),
+            parser_inserted: Cell::new(creator == ElementCreator::ParserCreated),
+            non_blocking: Cell::new(creator != ElementCreator::ParserCreated),
             ready_to_be_parser_executed: Cell::new(false),
         }
     }
@@ -187,7 +186,7 @@ impl<'a> HTMLScriptElementHelpers for JSRef<'a, HTMLScriptElement> {
                         match load_whole_resource(&page.resource_task, url) {
                             Ok((metadata, bytes)) => {
                                 // TODO: use the charset from step 13.
-                                let source = UTF_8.decode(bytes.as_slice(), DecodeReplace).unwrap();
+                                let source = UTF_8.decode(bytes.as_slice(), DecoderTrap::Replace).unwrap();
                                 (source, metadata.final_url)
                             }
                             Err(_) => {
diff --git a/components/script/dom/htmlselectelement.rs b/components/script/dom/htmlselectelement.rs
index cc11d0805a7..a249cb8bc26 100644
--- a/components/script/dom/htmlselectelement.rs
+++ b/components/script/dom/htmlselectelement.rs
@@ -8,15 +8,15 @@ use dom::bindings::codegen::Bindings::HTMLSelectElementBinding;
 use dom::bindings::codegen::Bindings::HTMLSelectElementBinding::HTMLSelectElementMethods;
 use dom::bindings::codegen::InheritTypes::{HTMLElementCast, NodeCast};
 use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLSelectElementDerived, HTMLFieldSetElementDerived};
-use dom::bindings::codegen::UnionTypes::HTMLElementOrLong::HTMLElementOrLong;
-use dom::bindings::codegen::UnionTypes::HTMLOptionElementOrHTMLOptGroupElement::HTMLOptionElementOrHTMLOptGroupElement;
+use dom::bindings::codegen::UnionTypes::HTMLElementOrLong;
+use dom::bindings::codegen::UnionTypes::HTMLOptionElementOrHTMLOptGroupElement;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::{AttributeHandlers, Element, HTMLSelectElementTypeId};
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::{AttributeHandlers, Element, ElementTypeId};
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{DisabledStateHelpers, Node, NodeHelpers, ElementNodeTypeId, window_from_node};
+use dom::node::{DisabledStateHelpers, Node, NodeHelpers, NodeTypeId, window_from_node};
 use dom::validitystate::ValidityState;
 use dom::virtualmethods::VirtualMethods;
 
@@ -30,14 +30,14 @@ pub struct HTMLSelectElement {
 
 impl HTMLSelectElementDerived for EventTarget {
     fn is_htmlselectelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLSelectElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLSelectElement))
     }
 }
 
 impl HTMLSelectElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLSelectElement {
         HTMLSelectElement {
-            htmlelement: HTMLElement::new_inherited(HTMLSelectElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLSelectElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmlserializer.rs b/components/script/dom/htmlserializer.rs
index 8a04fa717a1..bc6740658b0 100644
--- a/components/script/dom/htmlserializer.rs
+++ b/components/script/dom/htmlserializer.rs
@@ -11,10 +11,7 @@ use dom::characterdata::CharacterData;
 use dom::comment::Comment;
 use dom::documenttype::DocumentType;
 use dom::element::{Element, ElementHelpers};
-use dom::node::{Node, NodeIterator};
-use dom::node::{DoctypeNodeTypeId, DocumentFragmentNodeTypeId, CommentNodeTypeId};
-use dom::node::{DocumentNodeTypeId, ElementNodeTypeId, ProcessingInstructionNodeTypeId};
-use dom::node::{TextNodeTypeId, NodeHelpers};
+use dom::node::{Node, NodeHelpers, NodeTypeId, NodeIterator};
 use dom::processinginstruction::ProcessingInstruction;
 use dom::text::Text;
 
@@ -30,29 +27,29 @@ pub fn serialize(iterator: &mut NodeIterator) -> String {
             html.push_str(">");
         }
         match node.type_id() {
-            ElementNodeTypeId(..) => {
+            NodeTypeId::Element(..) => {
                 let elem: JSRef<Element> = ElementCast::to_ref(node).unwrap();
                 serialize_elem(elem, &mut open_elements, &mut html)
             }
-            CommentNodeTypeId => {
+            NodeTypeId::Comment => {
                 let comment: JSRef<Comment> = CommentCast::to_ref(node).unwrap();
                 serialize_comment(comment, &mut html)
             }
-            TextNodeTypeId => {
+            NodeTypeId::Text => {
                 let text: JSRef<Text> = TextCast::to_ref(node).unwrap();
                 serialize_text(text, &mut html)
             }
-            DoctypeNodeTypeId => {
+            NodeTypeId::DocumentType => {
                 let doctype: JSRef<DocumentType> = DocumentTypeCast::to_ref(node).unwrap();
                 serialize_doctype(doctype, &mut html)
             }
-            ProcessingInstructionNodeTypeId => {
+            NodeTypeId::ProcessingInstruction => {
                 let processing_instruction: JSRef<ProcessingInstruction> =
                     ProcessingInstructionCast::to_ref(node).unwrap();
                 serialize_processing_instruction(processing_instruction, &mut html)
             }
-            DocumentFragmentNodeTypeId => {}
-            DocumentNodeTypeId => {
+            NodeTypeId::DocumentFragment => {}
+            NodeTypeId::Document => {
                 panic!("It shouldn't be possible to serialize a document node")
             }
         }
diff --git a/components/script/dom/htmlsourceelement.rs b/components/script/dom/htmlsourceelement.rs
index 900b581f358..b53aa3bac45 100644
--- a/components/script/dom/htmlsourceelement.rs
+++ b/components/script/dom/htmlsourceelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLSourceElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLSourceElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLSourceElement {
 
 impl HTMLSourceElementDerived for EventTarget {
     fn is_htmlsourceelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLSourceElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLSourceElement))
     }
 }
 
 impl HTMLSourceElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLSourceElement {
         HTMLSourceElement {
-            htmlelement: HTMLElement::new_inherited(HTMLSourceElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLSourceElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmlspanelement.rs b/components/script/dom/htmlspanelement.rs
index 2a5ff463513..7ca9b960c55 100644
--- a/components/script/dom/htmlspanelement.rs
+++ b/components/script/dom/htmlspanelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLSpanElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLSpanElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLSpanElement {
 
 impl HTMLSpanElementDerived for EventTarget {
     fn is_htmlspanelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLSpanElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLSpanElement))
     }
 }
 
 impl HTMLSpanElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLSpanElement {
         HTMLSpanElement {
-            htmlelement: HTMLElement::new_inherited(HTMLSpanElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLSpanElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmlstyleelement.rs b/components/script/dom/htmlstyleelement.rs
index a989699e7e4..c662d39c8e3 100644
--- a/components/script/dom/htmlstyleelement.rs
+++ b/components/script/dom/htmlstyleelement.rs
@@ -8,14 +8,14 @@ use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLStyleElementDeri
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLStyleElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, NodeHelpers, ElementNodeTypeId, window_from_node};
+use dom::node::{Node, NodeHelpers, NodeTypeId, window_from_node};
 use dom::virtualmethods::VirtualMethods;
 use layout_interface::{AddStylesheetMsg, LayoutChan};
 use servo_util::str::DOMString;
-use style::{AuthorOrigin, Stylesheet};
+use style::{StylesheetOrigin, Stylesheet};
 
 #[dom_struct]
 pub struct HTMLStyleElement {
@@ -24,14 +24,14 @@ pub struct HTMLStyleElement {
 
 impl HTMLStyleElementDerived for EventTarget {
     fn is_htmlstyleelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLStyleElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLStyleElement))
     }
 }
 
 impl HTMLStyleElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLStyleElement {
         HTMLStyleElement {
-            htmlelement: HTMLElement::new_inherited(HTMLStyleElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLStyleElement, localName, prefix, document)
         }
     }
 
@@ -55,7 +55,8 @@ impl<'a> StyleElementHelpers for JSRef<'a, HTMLStyleElement> {
         let url = win.page().get_url();
 
         let data = node.GetTextContent().expect("Element.textContent must be a string");
-        let sheet = Stylesheet::from_str(data.as_slice(), url, AuthorOrigin);
+        let sheet = Stylesheet::from_str(data.as_slice(), url,
+                                         StylesheetOrigin::Author);
         let LayoutChan(ref layout_chan) = win.page().layout_chan;
         layout_chan.send(AddStylesheetMsg(sheet));
     }
diff --git a/components/script/dom/htmltablecaptionelement.rs b/components/script/dom/htmltablecaptionelement.rs
index 90380f37eb9..2a12f2fd01a 100644
--- a/components/script/dom/htmltablecaptionelement.rs
+++ b/components/script/dom/htmltablecaptionelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLTableCaptionElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLTableCaptionElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLTableCaptionElement {
 
 impl HTMLTableCaptionElementDerived for EventTarget {
     fn is_htmltablecaptionelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTableCaptionElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLTableCaptionElement))
     }
 }
 
 impl HTMLTableCaptionElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLTableCaptionElement {
         HTMLTableCaptionElement {
-            htmlelement: HTMLElement::new_inherited(HTMLTableCaptionElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLTableCaptionElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmltablecellelement.rs b/components/script/dom/htmltablecellelement.rs
index 9ca84b0e70f..346da6560d5 100644
--- a/components/script/dom/htmltablecellelement.rs
+++ b/components/script/dom/htmltablecellelement.rs
@@ -7,15 +7,14 @@ use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLTableCellElement
 use dom::bindings::js::JSRef;
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::{ElementTypeId, HTMLTableDataCellElementTypeId};
-use dom::element::{HTMLTableHeaderCellElementTypeId};
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::ElementNodeTypeId;
+use dom::node::NodeTypeId;
 use dom::virtualmethods::VirtualMethods;
 
 use cssparser::RGBA;
-use servo_util::str::{mod, AutoLpa, DOMString, LengthOrPercentageOrAuto};
+use servo_util::str::{mod, DOMString, LengthOrPercentageOrAuto};
 use std::cell::Cell;
 
 #[dom_struct]
@@ -29,8 +28,8 @@ pub struct HTMLTableCellElement {
 impl HTMLTableCellElementDerived for EventTarget {
     fn is_htmltablecellelement(&self) -> bool {
         match *self.type_id() {
-            NodeTargetTypeId(ElementNodeTypeId(HTMLTableDataCellElementTypeId)) |
-            NodeTargetTypeId(ElementNodeTypeId(HTMLTableHeaderCellElementTypeId)) => true,
+            EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLTableDataCellElement)) |
+            EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLTableHeaderCellElement)) => true,
             _ => false
         }
     }
@@ -46,7 +45,7 @@ impl HTMLTableCellElement {
             htmlelement: HTMLElement::new_inherited(type_id, tag_name, prefix, document),
             background_color: Cell::new(None),
             colspan: Cell::new(None),
-            width: Cell::new(AutoLpa),
+            width: Cell::new(LengthOrPercentageOrAuto::Auto),
         }
     }
 
@@ -109,7 +108,7 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLTableCellElement> {
         match attr.local_name() {
             &atom!("bgcolor") => self.background_color.set(None),
             &atom!("colspan") => self.colspan.set(None),
-            &atom!("width") => self.width.set(AutoLpa),
+            &atom!("width") => self.width.set(LengthOrPercentageOrAuto::Auto),
             _ => ()
         }
     }
diff --git a/components/script/dom/htmltablecolelement.rs b/components/script/dom/htmltablecolelement.rs
index f9761151dc1..99771d70918 100644
--- a/components/script/dom/htmltablecolelement.rs
+++ b/components/script/dom/htmltablecolelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLTableColElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLTableColElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLTableColElement {
 
 impl HTMLTableColElementDerived for EventTarget {
     fn is_htmltablecolelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTableColElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLTableColElement))
     }
 }
 
 impl HTMLTableColElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLTableColElement {
         HTMLTableColElement {
-            htmlelement: HTMLElement::new_inherited(HTMLTableColElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLTableColElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmltabledatacellelement.rs b/components/script/dom/htmltabledatacellelement.rs
index a2a73bd86f8..db4a7248b10 100644
--- a/components/script/dom/htmltabledatacellelement.rs
+++ b/components/script/dom/htmltabledatacellelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLTableDataCellElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLTableDataCellElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmltablecellelement::HTMLTableCellElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLTableDataCellElement {
 
 impl HTMLTableDataCellElementDerived for EventTarget {
     fn is_htmltabledatacellelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTableDataCellElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLTableDataCellElement))
     }
 }
 
 impl HTMLTableDataCellElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLTableDataCellElement {
         HTMLTableDataCellElement {
-            htmltablecellelement: HTMLTableCellElement::new_inherited(HTMLTableDataCellElementTypeId, localName, prefix, document)
+            htmltablecellelement: HTMLTableCellElement::new_inherited(ElementTypeId::HTMLTableDataCellElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmltableelement.rs b/components/script/dom/htmltableelement.rs
index d2c9e723b78..b73f0995b8f 100644
--- a/components/script/dom/htmltableelement.rs
+++ b/components/script/dom/htmltableelement.rs
@@ -11,15 +11,15 @@ use dom::bindings::codegen::InheritTypes::{HTMLTableElementDerived, NodeCast};
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLTableElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
 use dom::htmltablecaptionelement::HTMLTableCaptionElement;
-use dom::node::{Node, NodeHelpers, ElementNodeTypeId};
+use dom::node::{Node, NodeHelpers, NodeTypeId};
 use dom::virtualmethods::VirtualMethods;
 
 use cssparser::RGBA;
-use servo_util::str::{mod, AutoLpa, DOMString, LengthOrPercentageOrAuto};
+use servo_util::str::{mod, DOMString, LengthOrPercentageOrAuto};
 use std::cell::Cell;
 
 #[dom_struct]
@@ -32,7 +32,7 @@ pub struct HTMLTableElement {
 
 impl HTMLTableElementDerived for EventTarget {
     fn is_htmltableelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTableElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLTableElement))
     }
 }
 
@@ -40,13 +40,13 @@ impl HTMLTableElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>)
                      -> HTMLTableElement {
         HTMLTableElement {
-            htmlelement: HTMLElement::new_inherited(HTMLTableElementTypeId,
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLTableElement,
                                                     localName,
                                                     prefix,
                                                     document),
             background_color: Cell::new(None),
             border: Cell::new(None),
-            width: Cell::new(AutoLpa),
+            width: Cell::new(LengthOrPercentageOrAuto::Auto),
         }
     }
 
@@ -151,7 +151,7 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLTableElement> {
         match attr.local_name() {
             &atom!("bgcolor") => self.background_color.set(None),
             &atom!("border") => self.border.set(None),
-            &atom!("width") => self.width.set(AutoLpa),
+            &atom!("width") => self.width.set(LengthOrPercentageOrAuto::Auto),
             _ => ()
         }
     }
diff --git a/components/script/dom/htmltableheadercellelement.rs b/components/script/dom/htmltableheadercellelement.rs
index 03ae8a83d7e..f20647069d5 100644
--- a/components/script/dom/htmltableheadercellelement.rs
+++ b/components/script/dom/htmltableheadercellelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLTableHeaderCellElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLTableHeaderCellElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmltablecellelement::HTMLTableCellElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLTableHeaderCellElement {
 
 impl HTMLTableHeaderCellElementDerived for EventTarget {
     fn is_htmltableheadercellelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTableHeaderCellElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLTableHeaderCellElement))
     }
 }
 
 impl HTMLTableHeaderCellElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLTableHeaderCellElement {
         HTMLTableHeaderCellElement {
-            htmltablecellelement: HTMLTableCellElement::new_inherited(HTMLTableHeaderCellElementTypeId, localName, prefix, document)
+            htmltablecellelement: HTMLTableCellElement::new_inherited(ElementTypeId::HTMLTableHeaderCellElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmltablerowelement.rs b/components/script/dom/htmltablerowelement.rs
index 500c7d74472..6f34f290a5d 100644
--- a/components/script/dom/htmltablerowelement.rs
+++ b/components/script/dom/htmltablerowelement.rs
@@ -8,10 +8,10 @@ use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLTableRowElementD
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLTableRowElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use dom::virtualmethods::VirtualMethods;
 
 use cssparser::RGBA;
@@ -26,7 +26,7 @@ pub struct HTMLTableRowElement {
 
 impl HTMLTableRowElementDerived for EventTarget {
     fn is_htmltablerowelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTableRowElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLTableRowElement))
     }
 }
 
@@ -34,7 +34,7 @@ impl HTMLTableRowElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>)
                      -> HTMLTableRowElement {
         HTMLTableRowElement {
-            htmlelement: HTMLElement::new_inherited(HTMLTableRowElementTypeId,
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLTableRowElement,
                                                     localName,
                                                     prefix,
                                                     document),
diff --git a/components/script/dom/htmltablesectionelement.rs b/components/script/dom/htmltablesectionelement.rs
index b191e21bde0..d27fabd2153 100644
--- a/components/script/dom/htmltablesectionelement.rs
+++ b/components/script/dom/htmltablesectionelement.rs
@@ -8,10 +8,10 @@ use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLTableSectionElem
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLTableSectionElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use dom::virtualmethods::VirtualMethods;
 
 use cssparser::RGBA;
@@ -26,7 +26,7 @@ pub struct HTMLTableSectionElement {
 
 impl HTMLTableSectionElementDerived for EventTarget {
     fn is_htmltablesectionelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTableSectionElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLTableSectionElement))
     }
 }
 
@@ -34,7 +34,7 @@ impl HTMLTableSectionElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>)
                      -> HTMLTableSectionElement {
         HTMLTableSectionElement {
-            htmlelement: HTMLElement::new_inherited(HTMLTableSectionElementTypeId,
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLTableSectionElement,
                                                     localName,
                                                     prefix,
                                                     document),
diff --git a/components/script/dom/htmltemplateelement.rs b/components/script/dom/htmltemplateelement.rs
index c0a125109dc..86b2fb3bc4a 100644
--- a/components/script/dom/htmltemplateelement.rs
+++ b/components/script/dom/htmltemplateelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLTemplateElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLTemplateElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLTemplateElement {
 
 impl HTMLTemplateElementDerived for EventTarget {
     fn is_htmltemplateelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTemplateElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLTemplateElement))
     }
 }
 
 impl HTMLTemplateElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLTemplateElement {
         HTMLTemplateElement {
-            htmlelement: HTMLElement::new_inherited(HTMLTemplateElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLTemplateElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmltextareaelement.rs b/components/script/dom/htmltextareaelement.rs
index 969454afc86..8789fcf9fb1 100644
--- a/components/script/dom/htmltextareaelement.rs
+++ b/components/script/dom/htmltextareaelement.rs
@@ -2,7 +2,7 @@
  * 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::attr::{Attr, AttrValue, UIntAttrValue};
+use dom::attr::{Attr, AttrValue};
 use dom::attr::AttrHelpers;
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
@@ -15,15 +15,15 @@ use dom::bindings::codegen::InheritTypes::{KeyboardEventCast, TextDerived};
 use dom::bindings::js::{JS, JSRef, Temporary, OptionalRootable};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::{Document, DocumentHelpers};
-use dom::element::{AttributeHandlers, HTMLTextAreaElementTypeId, Element};
+use dom::element::{Element, AttributeHandlers, ElementTypeId};
 use dom::event::Event;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
 use dom::htmlformelement::FormControl;
 use dom::keyboardevent::KeyboardEvent;
-use dom::node::{DisabledStateHelpers, Node, NodeHelpers, OtherNodeDamage, ElementNodeTypeId};
+use dom::node::{DisabledStateHelpers, Node, NodeHelpers, NodeDamage, NodeTypeId};
 use dom::node::{document_from_node};
-use textinput::{Multiple, TextInput, TriggerDefaultAction, DispatchInput, Nothing};
+use textinput::{TextInput, Lines, KeyReaction};
 use dom::virtualmethods::VirtualMethods;
 
 use servo_util::str::DOMString;
@@ -44,7 +44,7 @@ pub struct HTMLTextAreaElement {
 
 impl HTMLTextAreaElementDerived for EventTarget {
     fn is_htmltextareaelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTextAreaElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLTextAreaElement))
     }
 }
 
@@ -82,8 +82,8 @@ static DEFAULT_ROWS: u32 = 2;
 impl HTMLTextAreaElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLTextAreaElement {
         HTMLTextAreaElement {
-            htmlelement: HTMLElement::new_inherited(HTMLTextAreaElementTypeId, localName, prefix, document),
-            textinput: DOMRefCell::new(TextInput::new(Multiple, "".to_string())),
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLTextAreaElement, localName, prefix, document),
+            textinput: DOMRefCell::new(TextInput::new(Lines::Multiple, "".to_string())),
             cols: Cell::new(DEFAULT_COLS),
             rows: Cell::new(DEFAULT_ROWS),
             value_changed: Cell::new(false),
@@ -194,7 +194,7 @@ impl<'a> PrivateHTMLTextAreaElementHelpers for JSRef<'a, HTMLTextAreaElement> {
     fn force_relayout(self) {
         let doc = document_from_node(self).root();
         let node: JSRef<Node> = NodeCast::from_ref(self);
-        doc.content_changed(node, OtherNodeDamage)
+        doc.content_changed(node, NodeDamage::OtherNodeDamage)
     }
 }
 
@@ -218,14 +218,14 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLTextAreaElement> {
             },
             &atom!("cols") => {
                 match *attr.value() {
-                    UIntAttrValue(_, value) => self.cols.set(value),
-                    _ => panic!("Expected a UIntAttrValue"),
+                    AttrValue::UInt(_, value) => self.cols.set(value),
+                    _ => panic!("Expected an AttrValue::UInt"),
                 }
             },
             &atom!("rows") => {
                 match *attr.value() {
-                    UIntAttrValue(_, value) => self.rows.set(value),
-                    _ => panic!("Expected a UIntAttrValue"),
+                    AttrValue::UInt(_, value) => self.rows.set(value),
+                    _ => panic!("Expected an AttrValue::UInt"),
                 }
             },
             _ => ()
@@ -318,12 +318,12 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLTextAreaElement> {
             let keyevent: Option<JSRef<KeyboardEvent>> = KeyboardEventCast::to_ref(event);
             keyevent.map(|event| {
                 match self.textinput.borrow_mut().handle_keydown(event) {
-                    TriggerDefaultAction => (),
-                    DispatchInput => {
+                    KeyReaction::TriggerDefaultAction => (),
+                    KeyReaction::DispatchInput => {
                         self.force_relayout();
                         self.value_changed.set(true);
                     }
-                    Nothing => (),
+                    KeyReaction::Nothing => (),
                 }
             });
         }
diff --git a/components/script/dom/htmltimeelement.rs b/components/script/dom/htmltimeelement.rs
index 3f21071fd2b..bb31f5021a9 100644
--- a/components/script/dom/htmltimeelement.rs
+++ b/components/script/dom/htmltimeelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLTimeElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLTimeElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLTimeElement {
 
 impl HTMLTimeElementDerived for EventTarget {
     fn is_htmltimeelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTimeElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLTimeElement))
     }
 }
 
 impl HTMLTimeElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLTimeElement {
         HTMLTimeElement {
-            htmlelement: HTMLElement::new_inherited(HTMLTimeElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLTimeElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmltitleelement.rs b/components/script/dom/htmltitleelement.rs
index 4e6e9f7e9bb..ba54a1790ec 100644
--- a/components/script/dom/htmltitleelement.rs
+++ b/components/script/dom/htmltitleelement.rs
@@ -10,10 +10,10 @@ use dom::bindings::codegen::InheritTypes::{TextCast};
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::{Document, DocumentHelpers};
-use dom::element::HTMLTitleElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, NodeHelpers, ElementNodeTypeId};
+use dom::node::{Node, NodeHelpers, NodeTypeId};
 use dom::text::Text;
 use dom::virtualmethods::VirtualMethods;
 use servo_util::str::DOMString;
@@ -25,14 +25,14 @@ pub struct HTMLTitleElement {
 
 impl HTMLTitleElementDerived for EventTarget {
     fn is_htmltitleelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTitleElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLTitleElement))
     }
 }
 
 impl HTMLTitleElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLTitleElement {
         HTMLTitleElement {
-            htmlelement: HTMLElement::new_inherited(HTMLTitleElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLTitleElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmltrackelement.rs b/components/script/dom/htmltrackelement.rs
index ae1a164ad05..6dab96b0ec1 100644
--- a/components/script/dom/htmltrackelement.rs
+++ b/components/script/dom/htmltrackelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLTrackElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLTrackElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLTrackElement {
 
 impl HTMLTrackElementDerived for EventTarget {
     fn is_htmltrackelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTrackElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLTrackElement))
     }
 }
 
 impl HTMLTrackElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLTrackElement {
         HTMLTrackElement {
-            htmlelement: HTMLElement::new_inherited(HTMLTrackElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLTrackElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmlulistelement.rs b/components/script/dom/htmlulistelement.rs
index 5909dbfc3ae..ecf206d89ce 100644
--- a/components/script/dom/htmlulistelement.rs
+++ b/components/script/dom/htmlulistelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLUListElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLUListElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLUListElement {
 
 impl HTMLUListElementDerived for EventTarget {
     fn is_htmlulistelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLUListElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLUListElement))
     }
 }
 
 impl HTMLUListElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLUListElement {
         HTMLUListElement {
-            htmlelement: HTMLElement::new_inherited(HTMLUListElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLUListElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmlunknownelement.rs b/components/script/dom/htmlunknownelement.rs
index d8a338afb82..cc538c2c983 100644
--- a/components/script/dom/htmlunknownelement.rs
+++ b/components/script/dom/htmlunknownelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLUnknownElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLUnknownElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLUnknownElement {
 
 impl HTMLUnknownElementDerived for EventTarget {
     fn is_htmlunknownelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLUnknownElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLUnknownElement))
     }
 }
 
 impl HTMLUnknownElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLUnknownElement {
         HTMLUnknownElement {
-            htmlelement: HTMLElement::new_inherited(HTMLUnknownElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLUnknownElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/htmlvideoelement.rs b/components/script/dom/htmlvideoelement.rs
index 4bec140ecf1..28e9f0c945c 100644
--- a/components/script/dom/htmlvideoelement.rs
+++ b/components/script/dom/htmlvideoelement.rs
@@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLVideoElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
-use dom::element::HTMLVideoElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::ElementTypeId;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlmediaelement::HTMLMediaElement;
-use dom::node::{Node, ElementNodeTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,14 +20,14 @@ pub struct HTMLVideoElement {
 
 impl HTMLVideoElementDerived for EventTarget {
     fn is_htmlvideoelement(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLVideoElementTypeId))
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLVideoElement))
     }
 }
 
 impl HTMLVideoElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLVideoElement {
         HTMLVideoElement {
-            htmlmediaelement: HTMLMediaElement::new_inherited(HTMLVideoElementTypeId, localName, prefix, document)
+            htmlmediaelement: HTMLMediaElement::new_inherited(ElementTypeId::HTMLVideoElement, localName, prefix, document)
         }
     }
 
diff --git a/components/script/dom/keyboardevent.rs b/components/script/dom/keyboardevent.rs
index 57fc3fb413f..20f7b1e518e 100644
--- a/components/script/dom/keyboardevent.rs
+++ b/components/script/dom/keyboardevent.rs
@@ -11,7 +11,7 @@ use dom::bindings::global::GlobalRef;
 use dom::bindings::global;
 use dom::bindings::js::{JSRef, Temporary, RootedReference};
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
-use dom::event::{Event, KeyboardEventTypeId};
+use dom::event::{Event, EventTypeId};
 use dom::uievent::UIEvent;
 use dom::window::Window;
 use servo_msg::constellation_msg;
@@ -37,14 +37,14 @@ pub struct KeyboardEvent {
 
 impl KeyboardEventDerived for Event {
     fn is_keyboardevent(&self) -> bool {
-        *self.type_id() == KeyboardEventTypeId
+        *self.type_id() == EventTypeId::KeyboardEvent
     }
 }
 
 impl KeyboardEvent {
     fn new_inherited() -> KeyboardEvent {
         KeyboardEvent {
-            uievent: UIEvent::new_inherited(KeyboardEventTypeId),
+            uievent: UIEvent::new_inherited(EventTypeId::KeyboardEvent),
             key: RefCell::new("".to_string()),
             code: RefCell::new("".to_string()),
             location: Cell::new(0),
@@ -127,316 +127,316 @@ impl KeyboardEvent {
 fn key_value(key: constellation_msg::Key, mods: constellation_msg::KeyModifiers) -> &'static str {
     let shift = mods.contains(constellation_msg::SHIFT);
     match key {
-        constellation_msg::KeySpace => " ",
-        constellation_msg::KeyApostrophe if shift => "\"",
-        constellation_msg::KeyApostrophe => "'",
-        constellation_msg::KeyComma if shift => "<",
-        constellation_msg::KeyComma => ",",
-        constellation_msg::KeyMinus if shift => "_",
-        constellation_msg::KeyMinus => "-",
-        constellation_msg::KeyPeriod if shift => ">",
-        constellation_msg::KeyPeriod => ".",
-        constellation_msg::KeySlash if shift => "?",
-        constellation_msg::KeySlash => "/",
-        constellation_msg::Key0 if shift => ")",
-        constellation_msg::Key0 => "0",
-        constellation_msg::Key1 if shift => "!",
-        constellation_msg::Key1 => "1",
-        constellation_msg::Key2 if shift => "@",
-        constellation_msg::Key2 => "2",
-        constellation_msg::Key3 if shift => "#",
-        constellation_msg::Key3 => "3",
-        constellation_msg::Key4 if shift => "$",
-        constellation_msg::Key4 => "4",
-        constellation_msg::Key5 if shift => "%",
-        constellation_msg::Key5 => "5",
-        constellation_msg::Key6 if shift => "^",
-        constellation_msg::Key6 => "6",
-        constellation_msg::Key7 if shift => "&",
-        constellation_msg::Key7 => "7",
-        constellation_msg::Key8 if shift => "*",
-        constellation_msg::Key8 => "8",
-        constellation_msg::Key9 if shift => "(",
-        constellation_msg::Key9 => "9",
-        constellation_msg::KeySemicolon if shift => ":",
-        constellation_msg::KeySemicolon => ";",
-        constellation_msg::KeyEqual if shift => "+",
-        constellation_msg::KeyEqual => "=",
-        constellation_msg::KeyA if shift => "A",
-        constellation_msg::KeyA => "a",
-        constellation_msg::KeyB if shift => "B",
-        constellation_msg::KeyB => "b",
-        constellation_msg::KeyC if shift => "C",
-        constellation_msg::KeyC => "c",
-        constellation_msg::KeyD if shift => "D",
-        constellation_msg::KeyD => "d",
-        constellation_msg::KeyE if shift => "E",
-        constellation_msg::KeyE => "e",
-        constellation_msg::KeyF if shift => "F",
-        constellation_msg::KeyF => "f",
-        constellation_msg::KeyG if shift => "G",
-        constellation_msg::KeyG => "g",
-        constellation_msg::KeyH if shift => "H",
-        constellation_msg::KeyH => "h",
-        constellation_msg::KeyI if shift => "I",
-        constellation_msg::KeyI => "i",
-        constellation_msg::KeyJ if shift => "J",
-        constellation_msg::KeyJ => "j",
-        constellation_msg::KeyK if shift => "K",
-        constellation_msg::KeyK => "k",
-        constellation_msg::KeyL if shift => "L",
-        constellation_msg::KeyL => "l",
-        constellation_msg::KeyM if shift => "M",
-        constellation_msg::KeyM => "m",
-        constellation_msg::KeyN if shift => "N",
-        constellation_msg::KeyN => "n",
-        constellation_msg::KeyO if shift => "O",
-        constellation_msg::KeyO => "o",
-        constellation_msg::KeyP if shift => "P",
-        constellation_msg::KeyP => "p",
-        constellation_msg::KeyQ if shift => "Q",
-        constellation_msg::KeyQ => "q",
-        constellation_msg::KeyR if shift => "R",
-        constellation_msg::KeyR => "r",
-        constellation_msg::KeyS if shift => "S",
-        constellation_msg::KeyS => "s",
-        constellation_msg::KeyT if shift => "T",
-        constellation_msg::KeyT => "t",
-        constellation_msg::KeyU if shift => "U",
-        constellation_msg::KeyU => "u",
-        constellation_msg::KeyV if shift => "V",
-        constellation_msg::KeyV => "v",
-        constellation_msg::KeyW if shift => "W",
-        constellation_msg::KeyW => "w",
-        constellation_msg::KeyX if shift => "X",
-        constellation_msg::KeyX => "x",
-        constellation_msg::KeyY if shift => "Y",
-        constellation_msg::KeyY => "y",
-        constellation_msg::KeyZ if shift => "Z",
-        constellation_msg::KeyZ => "z",
-        constellation_msg::KeyLeftBracket if shift => "{",
-        constellation_msg::KeyLeftBracket => "[",
-        constellation_msg::KeyBackslash if shift => "|",
-        constellation_msg::KeyBackslash => "\\",
-        constellation_msg::KeyRightBracket if shift => "}",
-        constellation_msg::KeyRightBracket => "]",
-        constellation_msg::KeyGraveAccent => "Dead",
-        constellation_msg::KeyWorld1 => "Unidentified",
-        constellation_msg::KeyWorld2 => "Unidentified",
-        constellation_msg::KeyEscape => "Escape",
-        constellation_msg::KeyEnter => "Enter",
-        constellation_msg::KeyTab => "Tab",
-        constellation_msg::KeyBackspace => "Backspace",
-        constellation_msg::KeyInsert => "Insert",
-        constellation_msg::KeyDelete => "Delete",
-        constellation_msg::KeyRight => "ArrowRight",
-        constellation_msg::KeyLeft => "ArrowLeft",
-        constellation_msg::KeyDown => "ArrowDown",
-        constellation_msg::KeyUp => "ArrowUp",
-        constellation_msg::KeyPageUp => "PageUp",
-        constellation_msg::KeyPageDown => "PageDown",
-        constellation_msg::KeyHome => "Home",
-        constellation_msg::KeyEnd => "End",
-        constellation_msg::KeyCapsLock => "CapsLock",
-        constellation_msg::KeyScrollLock => "ScrollLock",
-        constellation_msg::KeyNumLock => "NumLock",
-        constellation_msg::KeyPrintScreen => "PrintScreen",
-        constellation_msg::KeyPause => "Pause",
-        constellation_msg::KeyF1 => "F1",
-        constellation_msg::KeyF2 => "F2",
-        constellation_msg::KeyF3 => "F3",
-        constellation_msg::KeyF4 => "F4",
-        constellation_msg::KeyF5 => "F5",
-        constellation_msg::KeyF6 => "F6",
-        constellation_msg::KeyF7 => "F7",
-        constellation_msg::KeyF8 => "F8",
-        constellation_msg::KeyF9 => "F9",
-        constellation_msg::KeyF10 => "F10",
-        constellation_msg::KeyF11 => "F11",
-        constellation_msg::KeyF12 => "F12",
-        constellation_msg::KeyF13 => "F13",
-        constellation_msg::KeyF14 => "F14",
-        constellation_msg::KeyF15 => "F15",
-        constellation_msg::KeyF16 => "F16",
-        constellation_msg::KeyF17 => "F17",
-        constellation_msg::KeyF18 => "F18",
-        constellation_msg::KeyF19 => "F19",
-        constellation_msg::KeyF20 => "F20",
-        constellation_msg::KeyF21 => "F21",
-        constellation_msg::KeyF22 => "F22",
-        constellation_msg::KeyF23 => "F23",
-        constellation_msg::KeyF24 => "F24",
-        constellation_msg::KeyF25 => "F25",
-        constellation_msg::KeyKp0 => "0",
-        constellation_msg::KeyKp1 => "1",
-        constellation_msg::KeyKp2 => "2",
-        constellation_msg::KeyKp3 => "3",
-        constellation_msg::KeyKp4 => "4",
-        constellation_msg::KeyKp5 => "5",
-        constellation_msg::KeyKp6 => "6",
-        constellation_msg::KeyKp7 => "7",
-        constellation_msg::KeyKp8 => "8",
-        constellation_msg::KeyKp9 => "9",
-        constellation_msg::KeyKpDecimal => ".",
-        constellation_msg::KeyKpDivide => "/",
-        constellation_msg::KeyKpMultiply => "*",
-        constellation_msg::KeyKpSubtract => "-",
-        constellation_msg::KeyKpAdd => "+",
-        constellation_msg::KeyKpEnter => "Enter",
-        constellation_msg::KeyKpEqual => "=",
-        constellation_msg::KeyLeftShift => "Shift",
-        constellation_msg::KeyLeftControl => "Control",
-        constellation_msg::KeyLeftAlt => "Alt",
-        constellation_msg::KeyLeftSuper => "Super",
-        constellation_msg::KeyRightShift => "Shift",
-        constellation_msg::KeyRightControl => "Control",
-        constellation_msg::KeyRightAlt => "Alt",
-        constellation_msg::KeyRightSuper => "Super",
-        constellation_msg::KeyMenu => "ContextMenu",
+        constellation_msg::Key::Space => " ",
+        constellation_msg::Key::Apostrophe if shift => "\"",
+        constellation_msg::Key::Apostrophe => "'",
+        constellation_msg::Key::Comma if shift => "<",
+        constellation_msg::Key::Comma => ",",
+        constellation_msg::Key::Minus if shift => "_",
+        constellation_msg::Key::Minus => "-",
+        constellation_msg::Key::Period if shift => ">",
+        constellation_msg::Key::Period => ".",
+        constellation_msg::Key::Slash if shift => "?",
+        constellation_msg::Key::Slash => "/",
+        constellation_msg::Key::Num0 if shift => ")",
+        constellation_msg::Key::Num0 => "0",
+        constellation_msg::Key::Num1 if shift => "!",
+        constellation_msg::Key::Num1 => "1",
+        constellation_msg::Key::Num2 if shift => "@",
+        constellation_msg::Key::Num2 => "2",
+        constellation_msg::Key::Num3 if shift => "#",
+        constellation_msg::Key::Num3 => "3",
+        constellation_msg::Key::Num4 if shift => "$",
+        constellation_msg::Key::Num4 => "4",
+        constellation_msg::Key::Num5 if shift => "%",
+        constellation_msg::Key::Num5 => "5",
+        constellation_msg::Key::Num6 if shift => "^",
+        constellation_msg::Key::Num6 => "6",
+        constellation_msg::Key::Num7 if shift => "&",
+        constellation_msg::Key::Num7 => "7",
+        constellation_msg::Key::Num8 if shift => "*",
+        constellation_msg::Key::Num8 => "8",
+        constellation_msg::Key::Num9 if shift => "(",
+        constellation_msg::Key::Num9 => "9",
+        constellation_msg::Key::Semicolon if shift => ":",
+        constellation_msg::Key::Semicolon => ";",
+        constellation_msg::Key::Equal if shift => "+",
+        constellation_msg::Key::Equal => "=",
+        constellation_msg::Key::A if shift => "A",
+        constellation_msg::Key::A => "a",
+        constellation_msg::Key::B if shift => "B",
+        constellation_msg::Key::B => "b",
+        constellation_msg::Key::C if shift => "C",
+        constellation_msg::Key::C => "c",
+        constellation_msg::Key::D if shift => "D",
+        constellation_msg::Key::D => "d",
+        constellation_msg::Key::E if shift => "E",
+        constellation_msg::Key::E => "e",
+        constellation_msg::Key::F if shift => "F",
+        constellation_msg::Key::F => "f",
+        constellation_msg::Key::G if shift => "G",
+        constellation_msg::Key::G => "g",
+        constellation_msg::Key::H if shift => "H",
+        constellation_msg::Key::H => "h",
+        constellation_msg::Key::I if shift => "I",
+        constellation_msg::Key::I => "i",
+        constellation_msg::Key::J if shift => "J",
+        constellation_msg::Key::J => "j",
+        constellation_msg::Key::K if shift => "K",
+        constellation_msg::Key::K => "k",
+        constellation_msg::Key::L if shift => "L",
+        constellation_msg::Key::L => "l",
+        constellation_msg::Key::M if shift => "M",
+        constellation_msg::Key::M => "m",
+        constellation_msg::Key::N if shift => "N",
+        constellation_msg::Key::N => "n",
+        constellation_msg::Key::O if shift => "O",
+        constellation_msg::Key::O => "o",
+        constellation_msg::Key::P if shift => "P",
+        constellation_msg::Key::P => "p",
+        constellation_msg::Key::Q if shift => "Q",
+        constellation_msg::Key::Q => "q",
+        constellation_msg::Key::R if shift => "R",
+        constellation_msg::Key::R => "r",
+        constellation_msg::Key::S if shift => "S",
+        constellation_msg::Key::S => "s",
+        constellation_msg::Key::T if shift => "T",
+        constellation_msg::Key::T => "t",
+        constellation_msg::Key::U if shift => "U",
+        constellation_msg::Key::U => "u",
+        constellation_msg::Key::V if shift => "V",
+        constellation_msg::Key::V => "v",
+        constellation_msg::Key::W if shift => "W",
+        constellation_msg::Key::W => "w",
+        constellation_msg::Key::X if shift => "X",
+        constellation_msg::Key::X => "x",
+        constellation_msg::Key::Y if shift => "Y",
+        constellation_msg::Key::Y => "y",
+        constellation_msg::Key::Z if shift => "Z",
+        constellation_msg::Key::Z => "z",
+        constellation_msg::Key::LeftBracket if shift => "{",
+        constellation_msg::Key::LeftBracket => "[",
+        constellation_msg::Key::Backslash if shift => "|",
+        constellation_msg::Key::Backslash => "\\",
+        constellation_msg::Key::RightBracket if shift => "}",
+        constellation_msg::Key::RightBracket => "]",
+        constellation_msg::Key::GraveAccent => "Dead",
+        constellation_msg::Key::World1 => "Unidentified",
+        constellation_msg::Key::World2 => "Unidentified",
+        constellation_msg::Key::Escape => "Escape",
+        constellation_msg::Key::Enter => "Enter",
+        constellation_msg::Key::Tab => "Tab",
+        constellation_msg::Key::Backspace => "Backspace",
+        constellation_msg::Key::Insert => "Insert",
+        constellation_msg::Key::Delete => "Delete",
+        constellation_msg::Key::Right => "ArrowRight",
+        constellation_msg::Key::Left => "ArrowLeft",
+        constellation_msg::Key::Down => "ArrowDown",
+        constellation_msg::Key::Up => "ArrowUp",
+        constellation_msg::Key::PageUp => "PageUp",
+        constellation_msg::Key::PageDown => "PageDown",
+        constellation_msg::Key::Home => "Home",
+        constellation_msg::Key::End => "End",
+        constellation_msg::Key::CapsLock => "CapsLock",
+        constellation_msg::Key::ScrollLock => "ScrollLock",
+        constellation_msg::Key::NumLock => "NumLock",
+        constellation_msg::Key::PrintScreen => "PrintScreen",
+        constellation_msg::Key::Pause => "Pause",
+        constellation_msg::Key::F1 => "F1",
+        constellation_msg::Key::F2 => "F2",
+        constellation_msg::Key::F3 => "F3",
+        constellation_msg::Key::F4 => "F4",
+        constellation_msg::Key::F5 => "F5",
+        constellation_msg::Key::F6 => "F6",
+        constellation_msg::Key::F7 => "F7",
+        constellation_msg::Key::F8 => "F8",
+        constellation_msg::Key::F9 => "F9",
+        constellation_msg::Key::F10 => "F10",
+        constellation_msg::Key::F11 => "F11",
+        constellation_msg::Key::F12 => "F12",
+        constellation_msg::Key::F13 => "F13",
+        constellation_msg::Key::F14 => "F14",
+        constellation_msg::Key::F15 => "F15",
+        constellation_msg::Key::F16 => "F16",
+        constellation_msg::Key::F17 => "F17",
+        constellation_msg::Key::F18 => "F18",
+        constellation_msg::Key::F19 => "F19",
+        constellation_msg::Key::F20 => "F20",
+        constellation_msg::Key::F21 => "F21",
+        constellation_msg::Key::F22 => "F22",
+        constellation_msg::Key::F23 => "F23",
+        constellation_msg::Key::F24 => "F24",
+        constellation_msg::Key::F25 => "F25",
+        constellation_msg::Key::Kp0 => "0",
+        constellation_msg::Key::Kp1 => "1",
+        constellation_msg::Key::Kp2 => "2",
+        constellation_msg::Key::Kp3 => "3",
+        constellation_msg::Key::Kp4 => "4",
+        constellation_msg::Key::Kp5 => "5",
+        constellation_msg::Key::Kp6 => "6",
+        constellation_msg::Key::Kp7 => "7",
+        constellation_msg::Key::Kp8 => "8",
+        constellation_msg::Key::Kp9 => "9",
+        constellation_msg::Key::KpDecimal => ".",
+        constellation_msg::Key::KpDivide => "/",
+        constellation_msg::Key::KpMultiply => "*",
+        constellation_msg::Key::KpSubtract => "-",
+        constellation_msg::Key::KpAdd => "+",
+        constellation_msg::Key::KpEnter => "Enter",
+        constellation_msg::Key::KpEqual => "=",
+        constellation_msg::Key::LeftShift => "Shift",
+        constellation_msg::Key::LeftControl => "Control",
+        constellation_msg::Key::LeftAlt => "Alt",
+        constellation_msg::Key::LeftSuper => "Super",
+        constellation_msg::Key::RightShift => "Shift",
+        constellation_msg::Key::RightControl => "Control",
+        constellation_msg::Key::RightAlt => "Alt",
+        constellation_msg::Key::RightSuper => "Super",
+        constellation_msg::Key::Menu => "ContextMenu",
     }
 }
 
 // https://dvcs.w3.org/hg/dom3events/raw-file/tip/html/DOM3Events-code.html
 fn code_value(key: constellation_msg::Key) -> &'static str {
     match key {
-        constellation_msg::KeySpace => "Space",
-        constellation_msg::KeyApostrophe => "Quote",
-        constellation_msg::KeyComma => "Comma",
-        constellation_msg::KeyMinus => "Minus",
-        constellation_msg::KeyPeriod => "Period",
-        constellation_msg::KeySlash => "Slash",
-        constellation_msg::Key0 => "Digit0",
-        constellation_msg::Key1 => "Digit1",
-        constellation_msg::Key2 => "Digit2",
-        constellation_msg::Key3 => "Digit3",
-        constellation_msg::Key4 => "Digit4",
-        constellation_msg::Key5 => "Digit5",
-        constellation_msg::Key6 => "Digit6",
-        constellation_msg::Key7 => "Digit7",
-        constellation_msg::Key8 => "Digit8",
-        constellation_msg::Key9 => "Digit9",
-        constellation_msg::KeySemicolon => "Semicolon",
-        constellation_msg::KeyEqual => "Equals",
-        constellation_msg::KeyA => "KeyA",
-        constellation_msg::KeyB => "KeyB",
-        constellation_msg::KeyC => "KeyC",
-        constellation_msg::KeyD => "KeyD",
-        constellation_msg::KeyE => "KeyE",
-        constellation_msg::KeyF => "KeyF",
-        constellation_msg::KeyG => "KeyG",
-        constellation_msg::KeyH => "KeyH",
-        constellation_msg::KeyI => "KeyI",
-        constellation_msg::KeyJ => "KeyJ",
-        constellation_msg::KeyK => "KeyK",
-        constellation_msg::KeyL => "KeyL",
-        constellation_msg::KeyM => "KeyM",
-        constellation_msg::KeyN => "KeyN",
-        constellation_msg::KeyO => "KeyO",
-        constellation_msg::KeyP => "KeyP",
-        constellation_msg::KeyQ => "KeyQ",
-        constellation_msg::KeyR => "KeyR",
-        constellation_msg::KeyS => "KeyS",
-        constellation_msg::KeyT => "KeyT",
-        constellation_msg::KeyU => "KeyU",
-        constellation_msg::KeyV => "KeyV",
-        constellation_msg::KeyW => "KeyW",
-        constellation_msg::KeyX => "KeyX",
-        constellation_msg::KeyY => "KeyY",
-        constellation_msg::KeyZ => "KeyZ",
-        constellation_msg::KeyLeftBracket => "BracketLeft",
-        constellation_msg::KeyBackslash => "Backslash",
-        constellation_msg::KeyRightBracket => "BracketRight",
-
-        constellation_msg::KeyGraveAccent |
-        constellation_msg::KeyWorld1 |
-        constellation_msg::KeyWorld2 => panic!("unknown char code for {}", key),
-
-        constellation_msg::KeyEscape => "Escape",
-        constellation_msg::KeyEnter => "Enter",
-        constellation_msg::KeyTab => "Tab",
-        constellation_msg::KeyBackspace => "Backspace",
-        constellation_msg::KeyInsert => "Insert",
-        constellation_msg::KeyDelete => "Delete",
-        constellation_msg::KeyRight => "ArrowRight",
-        constellation_msg::KeyLeft => "ArrowLeft",
-        constellation_msg::KeyDown => "ArrowDown",
-        constellation_msg::KeyUp => "ArrowUp",
-        constellation_msg::KeyPageUp => "PageUp",
-        constellation_msg::KeyPageDown => "PageDown",
-        constellation_msg::KeyHome => "Home",
-        constellation_msg::KeyEnd => "End",
-        constellation_msg::KeyCapsLock => "CapsLock",
-        constellation_msg::KeyScrollLock => "ScrollLock",
-        constellation_msg::KeyNumLock => "NumLock",
-        constellation_msg::KeyPrintScreen => "PrintScreen",
-        constellation_msg::KeyPause => "Pause",
-        constellation_msg::KeyF1 => "F1",
-        constellation_msg::KeyF2 => "F2",
-        constellation_msg::KeyF3 => "F3",
-        constellation_msg::KeyF4 => "F4",
-        constellation_msg::KeyF5 => "F5",
-        constellation_msg::KeyF6 => "F6",
-        constellation_msg::KeyF7 => "F7",
-        constellation_msg::KeyF8 => "F8",
-        constellation_msg::KeyF9 => "F9",
-        constellation_msg::KeyF10 => "F10",
-        constellation_msg::KeyF11 => "F11",
-        constellation_msg::KeyF12 => "F12",
-        constellation_msg::KeyF13 => "F13",
-        constellation_msg::KeyF14 => "F14",
-        constellation_msg::KeyF15 => "F15",
-        constellation_msg::KeyF16 => "F16",
-        constellation_msg::KeyF17 => "F17",
-        constellation_msg::KeyF18 => "F18",
-        constellation_msg::KeyF19 => "F19",
-        constellation_msg::KeyF20 => "F20",
-        constellation_msg::KeyF21 => "F21",
-        constellation_msg::KeyF22 => "F22",
-        constellation_msg::KeyF23 => "F23",
-        constellation_msg::KeyF24 => "F24",
-        constellation_msg::KeyF25 => "F25",
-        constellation_msg::KeyKp0 => "Numpad0",
-        constellation_msg::KeyKp1 => "Numpad1",
-        constellation_msg::KeyKp2 => "Numpad2",
-        constellation_msg::KeyKp3 => "Numpad3",
-        constellation_msg::KeyKp4 => "Numpad4",
-        constellation_msg::KeyKp5 => "Numpad5",
-        constellation_msg::KeyKp6 => "Numpad6",
-        constellation_msg::KeyKp7 => "Numpad7",
-        constellation_msg::KeyKp8 => "Numpad8",
-        constellation_msg::KeyKp9 => "Numpad9",
-        constellation_msg::KeyKpDecimal => "NumpadDecimal",
-        constellation_msg::KeyKpDivide => "NumpadDivide",
-        constellation_msg::KeyKpMultiply => "NumpadMultiply",
-        constellation_msg::KeyKpSubtract => "NumpadSubtract",
-        constellation_msg::KeyKpAdd => "NumpadAdd",
-        constellation_msg::KeyKpEnter => "NumpadEnter",
-        constellation_msg::KeyKpEqual => "NumpadEquals",
-        constellation_msg::KeyLeftShift | constellation_msg::KeyRightShift => "Shift",
-        constellation_msg::KeyLeftControl | constellation_msg::KeyRightControl => "Control",
-        constellation_msg::KeyLeftAlt | constellation_msg::KeyRightAlt => "Alt",
-        constellation_msg::KeyLeftSuper | constellation_msg::KeyRightSuper => "Super",
-        constellation_msg::KeyMenu => "Menu",
+        constellation_msg::Key::Space => "Space",
+        constellation_msg::Key::Apostrophe => "Quote",
+        constellation_msg::Key::Comma => "Comma",
+        constellation_msg::Key::Minus => "Minus",
+        constellation_msg::Key::Period => "Period",
+        constellation_msg::Key::Slash => "Slash",
+        constellation_msg::Key::Num0 => "Digit0",
+        constellation_msg::Key::Num1 => "Digit1",
+        constellation_msg::Key::Num2 => "Digit2",
+        constellation_msg::Key::Num3 => "Digit3",
+        constellation_msg::Key::Num4 => "Digit4",
+        constellation_msg::Key::Num5 => "Digit5",
+        constellation_msg::Key::Num6 => "Digit6",
+        constellation_msg::Key::Num7 => "Digit7",
+        constellation_msg::Key::Num8 => "Digit8",
+        constellation_msg::Key::Num9 => "Digit9",
+        constellation_msg::Key::Semicolon => "Semicolon",
+        constellation_msg::Key::Equal => "Equals",
+        constellation_msg::Key::A => "Key::A",
+        constellation_msg::Key::B => "Key::B",
+        constellation_msg::Key::C => "Key::C",
+        constellation_msg::Key::D => "Key::D",
+        constellation_msg::Key::E => "Key::E",
+        constellation_msg::Key::F => "Key::F",
+        constellation_msg::Key::G => "Key::G",
+        constellation_msg::Key::H => "Key::H",
+        constellation_msg::Key::I => "Key::I",
+        constellation_msg::Key::J => "Key::J",
+        constellation_msg::Key::K => "Key::K",
+        constellation_msg::Key::L => "Key::L",
+        constellation_msg::Key::M => "Key::M",
+        constellation_msg::Key::N => "Key::N",
+        constellation_msg::Key::O => "Key::O",
+        constellation_msg::Key::P => "Key::P",
+        constellation_msg::Key::Q => "Key::Q",
+        constellation_msg::Key::R => "Key::R",
+        constellation_msg::Key::S => "Key::S",
+        constellation_msg::Key::T => "Key::T",
+        constellation_msg::Key::U => "Key::U",
+        constellation_msg::Key::V => "Key::V",
+        constellation_msg::Key::W => "Key::W",
+        constellation_msg::Key::X => "Key::X",
+        constellation_msg::Key::Y => "Key::Y",
+        constellation_msg::Key::Z => "Key::Z",
+        constellation_msg::Key::LeftBracket => "BracketLeft",
+        constellation_msg::Key::Backslash => "Backslash",
+        constellation_msg::Key::RightBracket => "BracketRight",
+
+        constellation_msg::Key::GraveAccent |
+        constellation_msg::Key::World1 |
+        constellation_msg::Key::World2 => panic!("unknown char code for {}", key),
+
+        constellation_msg::Key::Escape => "Escape",
+        constellation_msg::Key::Enter => "Enter",
+        constellation_msg::Key::Tab => "Tab",
+        constellation_msg::Key::Backspace => "Backspace",
+        constellation_msg::Key::Insert => "Insert",
+        constellation_msg::Key::Delete => "Delete",
+        constellation_msg::Key::Right => "ArrowRight",
+        constellation_msg::Key::Left => "ArrowLeft",
+        constellation_msg::Key::Down => "ArrowDown",
+        constellation_msg::Key::Up => "ArrowUp",
+        constellation_msg::Key::PageUp => "PageUp",
+        constellation_msg::Key::PageDown => "PageDown",
+        constellation_msg::Key::Home => "Home",
+        constellation_msg::Key::End => "End",
+        constellation_msg::Key::CapsLock => "CapsLock",
+        constellation_msg::Key::ScrollLock => "ScrollLock",
+        constellation_msg::Key::NumLock => "NumLock",
+        constellation_msg::Key::PrintScreen => "PrintScreen",
+        constellation_msg::Key::Pause => "Pause",
+        constellation_msg::Key::F1 => "F1",
+        constellation_msg::Key::F2 => "F2",
+        constellation_msg::Key::F3 => "F3",
+        constellation_msg::Key::F4 => "F4",
+        constellation_msg::Key::F5 => "F5",
+        constellation_msg::Key::F6 => "F6",
+        constellation_msg::Key::F7 => "F7",
+        constellation_msg::Key::F8 => "F8",
+        constellation_msg::Key::F9 => "F9",
+        constellation_msg::Key::F10 => "F10",
+        constellation_msg::Key::F11 => "F11",
+        constellation_msg::Key::F12 => "F12",
+        constellation_msg::Key::F13 => "F13",
+        constellation_msg::Key::F14 => "F14",
+        constellation_msg::Key::F15 => "F15",
+        constellation_msg::Key::F16 => "F16",
+        constellation_msg::Key::F17 => "F17",
+        constellation_msg::Key::F18 => "F18",
+        constellation_msg::Key::F19 => "F19",
+        constellation_msg::Key::F20 => "F20",
+        constellation_msg::Key::F21 => "F21",
+        constellation_msg::Key::F22 => "F22",
+        constellation_msg::Key::F23 => "F23",
+        constellation_msg::Key::F24 => "F24",
+        constellation_msg::Key::F25 => "F25",
+        constellation_msg::Key::Kp0 => "Numpad0",
+        constellation_msg::Key::Kp1 => "Numpad1",
+        constellation_msg::Key::Kp2 => "Numpad2",
+        constellation_msg::Key::Kp3 => "Numpad3",
+        constellation_msg::Key::Kp4 => "Numpad4",
+        constellation_msg::Key::Kp5 => "Numpad5",
+        constellation_msg::Key::Kp6 => "Numpad6",
+        constellation_msg::Key::Kp7 => "Numpad7",
+        constellation_msg::Key::Kp8 => "Numpad8",
+        constellation_msg::Key::Kp9 => "Numpad9",
+        constellation_msg::Key::KpDecimal => "NumpadDecimal",
+        constellation_msg::Key::KpDivide => "NumpadDivide",
+        constellation_msg::Key::KpMultiply => "NumpadMultiply",
+        constellation_msg::Key::KpSubtract => "NumpadSubtract",
+        constellation_msg::Key::KpAdd => "NumpadAdd",
+        constellation_msg::Key::KpEnter => "NumpadEnter",
+        constellation_msg::Key::KpEqual => "NumpadEquals",
+        constellation_msg::Key::LeftShift | constellation_msg::Key::RightShift => "Shift",
+        constellation_msg::Key::LeftControl | constellation_msg::Key::RightControl => "Control",
+        constellation_msg::Key::LeftAlt | constellation_msg::Key::RightAlt => "Alt",
+        constellation_msg::Key::LeftSuper | constellation_msg::Key::RightSuper => "Super",
+        constellation_msg::Key::Menu => "Menu",
     }
 }
 
 fn key_location(key: constellation_msg::Key) -> u32 {
     match key {
-        constellation_msg::KeyKp0 | constellation_msg::KeyKp1 | constellation_msg::KeyKp2 |
-        constellation_msg::KeyKp3 | constellation_msg::KeyKp4 | constellation_msg::KeyKp5 |
-        constellation_msg::KeyKp6 | constellation_msg::KeyKp7 | constellation_msg::KeyKp8 |
-        constellation_msg::KeyKp9 | constellation_msg::KeyKpDecimal |
-        constellation_msg::KeyKpDivide | constellation_msg::KeyKpMultiply |
-        constellation_msg::KeyKpSubtract | constellation_msg::KeyKpAdd |
-        constellation_msg::KeyKpEnter | constellation_msg::KeyKpEqual =>
+        constellation_msg::Key::Kp0 | constellation_msg::Key::Kp1 | constellation_msg::Key::Kp2 |
+        constellation_msg::Key::Kp3 | constellation_msg::Key::Kp4 | constellation_msg::Key::Kp5 |
+        constellation_msg::Key::Kp6 | constellation_msg::Key::Kp7 | constellation_msg::Key::Kp8 |
+        constellation_msg::Key::Kp9 | constellation_msg::Key::KpDecimal |
+        constellation_msg::Key::KpDivide | constellation_msg::Key::KpMultiply |
+        constellation_msg::Key::KpSubtract | constellation_msg::Key::KpAdd |
+        constellation_msg::Key::KpEnter | constellation_msg::Key::KpEqual =>
             KeyboardEventConstants::DOM_KEY_LOCATION_NUMPAD,
 
-        constellation_msg::KeyLeftShift | constellation_msg::KeyLeftAlt |
-        constellation_msg::KeyLeftControl | constellation_msg::KeyLeftSuper =>
+        constellation_msg::Key::LeftShift | constellation_msg::Key::LeftAlt |
+        constellation_msg::Key::LeftControl | constellation_msg::Key::LeftSuper =>
             KeyboardEventConstants::DOM_KEY_LOCATION_LEFT,
 
-        constellation_msg::KeyRightShift | constellation_msg::KeyRightAlt |
-        constellation_msg::KeyRightControl | constellation_msg::KeyRightSuper =>
+        constellation_msg::Key::RightShift | constellation_msg::Key::RightAlt |
+        constellation_msg::Key::RightControl | constellation_msg::Key::RightSuper =>
             KeyboardEventConstants::DOM_KEY_LOCATION_RIGHT,
 
         _ => KeyboardEventConstants::DOM_KEY_LOCATION_STANDARD,
@@ -457,76 +457,76 @@ fn key_charcode(key: constellation_msg::Key, mods: constellation_msg::KeyModifie
 fn key_keycode(key: constellation_msg::Key) -> u32 {
     match key {
         // https://dvcs.w3.org/hg/dom3events/raw-file/tip/html/DOM3-Events.html#legacy-key-models
-        constellation_msg::KeyBackspace => 8,
-        constellation_msg::KeyTab => 9,
-        constellation_msg::KeyEnter => 13,
-        constellation_msg::KeyLeftShift | constellation_msg::KeyRightShift => 16,
-        constellation_msg::KeyLeftControl | constellation_msg::KeyRightControl => 17,
-        constellation_msg::KeyLeftAlt | constellation_msg::KeyRightAlt => 18,
-        constellation_msg::KeyCapsLock => 20,
-        constellation_msg::KeyEscape => 27,
-        constellation_msg::KeySpace => 32,
-        constellation_msg::KeyPageUp => 33,
-        constellation_msg::KeyPageDown => 34,
-        constellation_msg::KeyEnd => 35,
-        constellation_msg::KeyHome => 36,
-        constellation_msg::KeyLeft => 37,
-        constellation_msg::KeyUp => 38,
-        constellation_msg::KeyRight => 39,
-        constellation_msg::KeyDown => 40,
-        constellation_msg::KeyDelete => 46,
+        constellation_msg::Key::Backspace => 8,
+        constellation_msg::Key::Tab => 9,
+        constellation_msg::Key::Enter => 13,
+        constellation_msg::Key::LeftShift | constellation_msg::Key::RightShift => 16,
+        constellation_msg::Key::LeftControl | constellation_msg::Key::RightControl => 17,
+        constellation_msg::Key::LeftAlt | constellation_msg::Key::RightAlt => 18,
+        constellation_msg::Key::CapsLock => 20,
+        constellation_msg::Key::Escape => 27,
+        constellation_msg::Key::Space => 32,
+        constellation_msg::Key::PageUp => 33,
+        constellation_msg::Key::PageDown => 34,
+        constellation_msg::Key::End => 35,
+        constellation_msg::Key::Home => 36,
+        constellation_msg::Key::Left => 37,
+        constellation_msg::Key::Up => 38,
+        constellation_msg::Key::Right => 39,
+        constellation_msg::Key::Down => 40,
+        constellation_msg::Key::Delete => 46,
 
         // https://dvcs.w3.org/hg/dom3events/raw-file/tip/html/DOM3-Events.html#optionally-fixed-virtual-key-codes
-        constellation_msg::KeySemicolon => 186,
-        constellation_msg::KeyEqual => 187,
-        constellation_msg::KeyComma => 188,
-        constellation_msg::KeyMinus => 189,
-        constellation_msg::KeyPeriod => 190,
-        constellation_msg::KeySlash => 191,
-        constellation_msg::KeyLeftBracket => 219,
-        constellation_msg::KeyBackslash => 220,
-        constellation_msg::KeyRightBracket => 221,
-        constellation_msg::KeyApostrophe => 222,
+        constellation_msg::Key::Semicolon => 186,
+        constellation_msg::Key::Equal => 187,
+        constellation_msg::Key::Comma => 188,
+        constellation_msg::Key::Minus => 189,
+        constellation_msg::Key::Period => 190,
+        constellation_msg::Key::Slash => 191,
+        constellation_msg::Key::LeftBracket => 219,
+        constellation_msg::Key::Backslash => 220,
+        constellation_msg::Key::RightBracket => 221,
+        constellation_msg::Key::Apostrophe => 222,
 
         //§ B.2.1.3
-        constellation_msg::Key0 |
-        constellation_msg::Key1 |
-        constellation_msg::Key2 |
-        constellation_msg::Key3 |
-        constellation_msg::Key4 |
-        constellation_msg::Key5 |
-        constellation_msg::Key6 |
-        constellation_msg::Key7 |
-        constellation_msg::Key8 |
-        constellation_msg::Key9 => key as u32 - constellation_msg::Key0 as u32 + '0' as u32,
+        constellation_msg::Key::Num0 |
+        constellation_msg::Key::Num1 |
+        constellation_msg::Key::Num2 |
+        constellation_msg::Key::Num3 |
+        constellation_msg::Key::Num4 |
+        constellation_msg::Key::Num5 |
+        constellation_msg::Key::Num6 |
+        constellation_msg::Key::Num7 |
+        constellation_msg::Key::Num8 |
+        constellation_msg::Key::Num9 => key as u32 - constellation_msg::Key::Num0 as u32 + '0' as u32,
 
         //§ B.2.1.4
-        constellation_msg::KeyA |
-        constellation_msg::KeyB |
-        constellation_msg::KeyC |
-        constellation_msg::KeyD |
-        constellation_msg::KeyE |
-        constellation_msg::KeyF |
-        constellation_msg::KeyG |
-        constellation_msg::KeyH |
-        constellation_msg::KeyI |
-        constellation_msg::KeyJ |
-        constellation_msg::KeyK |
-        constellation_msg::KeyL |
-        constellation_msg::KeyM |
-        constellation_msg::KeyN |
-        constellation_msg::KeyO |
-        constellation_msg::KeyP |
-        constellation_msg::KeyQ |
-        constellation_msg::KeyR |
-        constellation_msg::KeyS |
-        constellation_msg::KeyT |
-        constellation_msg::KeyU |
-        constellation_msg::KeyV |
-        constellation_msg::KeyW |
-        constellation_msg::KeyX |
-        constellation_msg::KeyY |
-        constellation_msg::KeyZ => key as u32 - constellation_msg::KeyA as u32 + 'A' as u32,
+        constellation_msg::Key::A |
+        constellation_msg::Key::B |
+        constellation_msg::Key::C |
+        constellation_msg::Key::D |
+        constellation_msg::Key::E |
+        constellation_msg::Key::F |
+        constellation_msg::Key::G |
+        constellation_msg::Key::H |
+        constellation_msg::Key::I |
+        constellation_msg::Key::J |
+        constellation_msg::Key::K |
+        constellation_msg::Key::L |
+        constellation_msg::Key::M |
+        constellation_msg::Key::N |
+        constellation_msg::Key::O |
+        constellation_msg::Key::P |
+        constellation_msg::Key::Q |
+        constellation_msg::Key::R |
+        constellation_msg::Key::S |
+        constellation_msg::Key::T |
+        constellation_msg::Key::U |
+        constellation_msg::Key::V |
+        constellation_msg::Key::W |
+        constellation_msg::Key::X |
+        constellation_msg::Key::Y |
+        constellation_msg::Key::Z => key as u32 - constellation_msg::Key::A as u32 + 'A' as u32,
 
         //§ B.2.1.8
         _ => 0
diff --git a/components/script/dom/messageevent.rs b/components/script/dom/messageevent.rs
index 9dda3ccc8cc..23ff7083ee8 100644
--- a/components/script/dom/messageevent.rs
+++ b/components/script/dom/messageevent.rs
@@ -10,7 +10,7 @@ use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
-use dom::event::{Event, MessageEventTypeId};
+use dom::event::{Event, EventTypeId};
 use dom::eventtarget::{EventTarget, EventTargetHelpers};
 
 use servo_util::str::DOMString;
@@ -28,7 +28,7 @@ pub struct MessageEvent {
 
 impl MessageEventDerived for Event {
     fn is_messageevent(&self) -> bool {
-        *self.type_id() == MessageEventTypeId
+        *self.type_id() == EventTypeId::MessageEvent
     }
 }
 
@@ -36,7 +36,7 @@ impl MessageEvent {
     fn new_inherited(data: JSVal, origin: DOMString, lastEventId: DOMString)
                          -> MessageEvent {
         MessageEvent {
-            event: Event::new_inherited(MessageEventTypeId),
+            event: Event::new_inherited(EventTypeId::MessageEvent),
             data: data,
             origin: origin,
             lastEventId: lastEventId,
diff --git a/components/script/dom/mouseevent.rs b/components/script/dom/mouseevent.rs
index 45957fecbf8..46cc0a6e706 100644
--- a/components/script/dom/mouseevent.rs
+++ b/components/script/dom/mouseevent.rs
@@ -11,7 +11,7 @@ use dom::bindings::global::GlobalRef;
 use dom::bindings::global;
 use dom::bindings::js::{MutNullableJS, JSRef, RootedReference, Temporary, OptionalSettable};
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
-use dom::event::{Event, MouseEventTypeId};
+use dom::event::{Event, EventTypeId};
 use dom::eventtarget::EventTarget;
 use dom::uievent::UIEvent;
 use dom::window::Window;
@@ -36,14 +36,14 @@ pub struct MouseEvent {
 
 impl MouseEventDerived for Event {
     fn is_mouseevent(&self) -> bool {
-        *self.type_id() == MouseEventTypeId
+        *self.type_id() == EventTypeId::MouseEvent
     }
 }
 
 impl MouseEvent {
     fn new_inherited() -> MouseEvent {
         MouseEvent {
-            uievent: UIEvent::new_inherited(MouseEventTypeId),
+            uievent: UIEvent::new_inherited(EventTypeId::MouseEvent),
             screen_x: Cell::new(0),
             screen_y: Cell::new(0),
             client_x: Cell::new(0),
diff --git a/components/script/dom/node.rs b/components/script/dom/node.rs
index 0871a266df3..50647862007 100644
--- a/components/script/dom/node.rs
+++ b/components/script/dom/node.rs
@@ -19,7 +19,8 @@ use dom::bindings::codegen::InheritTypes::{CharacterDataCast, NodeBase, NodeDeri
 use dom::bindings::codegen::InheritTypes::{ProcessingInstructionCast, EventTargetCast};
 use dom::bindings::codegen::InheritTypes::{HTMLLegendElementDerived, HTMLFieldSetElementDerived};
 use dom::bindings::codegen::InheritTypes::HTMLOptGroupElementDerived;
-use dom::bindings::error::{Fallible, NotFound, HierarchyRequest, Syntax};
+use dom::bindings::error::Fallible;
+use dom::bindings::error::Error::{NotFound, HierarchyRequest, Syntax};
 use dom::bindings::global::GlobalRef;
 use dom::bindings::global;
 use dom::bindings::js::{JS, JSRef, RootedReference, Temporary, Root};
@@ -30,15 +31,12 @@ use dom::bindings::utils;
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
 use dom::characterdata::CharacterData;
 use dom::comment::Comment;
-use dom::document::{Document, DocumentHelpers, HTMLDocument, NonHTMLDocument, NotFromParser};
+use dom::document::{Document, DocumentHelpers, IsHTMLDocument, DocumentSource};
 use dom::documentfragment::DocumentFragment;
 use dom::documenttype::DocumentType;
-use dom::element::{AttributeHandlers, Element, ScriptCreated, ElementTypeId};
-use dom::element::{HTMLAnchorElementTypeId, HTMLButtonElementTypeId, ElementHelpers};
-use dom::element::{HTMLInputElementTypeId, HTMLSelectElementTypeId};
-use dom::element::{HTMLTextAreaElementTypeId, HTMLOptGroupElementTypeId};
-use dom::element::{HTMLOptionElementTypeId, HTMLFieldSetElementTypeId};
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::element::{AttributeHandlers, Element, ElementCreator, ElementTypeId};
+use dom::element::ElementHelpers;
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::nodelist::NodeList;
 use dom::processinginstruction::ProcessingInstruction;
 use dom::text::Text;
@@ -50,7 +48,7 @@ use devtools_traits::NodeInfo;
 use script_traits::UntrustedNodeAddress;
 use servo_util::geometry::Au;
 use servo_util::str::{DOMString, null_str_as_empty};
-use style::{matches, AuthorOrigin, ParserContext, SelectorList};
+use style::{matches, StylesheetOrigin, ParserContext, SelectorList};
 
 use js::jsapi::{JSContext, JSObject, JSTracer, JSRuntime};
 use js::jsfriendapi;
@@ -114,7 +112,7 @@ pub struct Node {
 impl NodeDerived for EventTarget {
     fn is_node(&self) -> bool {
         match *self.type_id() {
-            NodeTargetTypeId(_) => true,
+            EventTargetTypeId::Node(_) => true,
             _ => false
         }
     }
@@ -155,16 +153,16 @@ impl NodeFlags {
     pub fn new(type_id: NodeTypeId) -> NodeFlags {
         let dirty = HAS_CHANGED | IS_DIRTY | HAS_DIRTY_SIBLINGS | HAS_DIRTY_DESCENDANTS;
         match type_id {
-            DocumentNodeTypeId => IS_IN_DOC | dirty,
+            NodeTypeId::Document => IS_IN_DOC | dirty,
             // The following elements are enabled by default.
-            ElementNodeTypeId(HTMLButtonElementTypeId) |
-            ElementNodeTypeId(HTMLInputElementTypeId) |
-            ElementNodeTypeId(HTMLSelectElementTypeId) |
-            ElementNodeTypeId(HTMLTextAreaElementTypeId) |
-            ElementNodeTypeId(HTMLOptGroupElementTypeId) |
-            ElementNodeTypeId(HTMLOptionElementTypeId) |
-            //ElementNodeTypeId(HTMLMenuItemElementTypeId) |
-            ElementNodeTypeId(HTMLFieldSetElementTypeId) => IN_ENABLED_STATE | dirty,
+            NodeTypeId::Element(ElementTypeId::HTMLButtonElement) |
+            NodeTypeId::Element(ElementTypeId::HTMLInputElement) |
+            NodeTypeId::Element(ElementTypeId::HTMLSelectElement) |
+            NodeTypeId::Element(ElementTypeId::HTMLTextAreaElement) |
+            NodeTypeId::Element(ElementTypeId::HTMLOptGroupElement) |
+            NodeTypeId::Element(ElementTypeId::HTMLOptionElement) |
+            //NodeTypeId::Element(ElementTypeId::HTMLMenuItemElement) |
+            NodeTypeId::Element(ElementTypeId::HTMLFieldSetElement) => IN_ENABLED_STATE | dirty,
             _ => dirty,
         }
     }
@@ -257,13 +255,13 @@ impl LayoutDataRef {
 #[deriving(PartialEq, Show)]
 #[jstraceable]
 pub enum NodeTypeId {
-    DoctypeNodeTypeId,
-    DocumentFragmentNodeTypeId,
-    CommentNodeTypeId,
-    DocumentNodeTypeId,
-    ElementNodeTypeId(ElementTypeId),
-    TextNodeTypeId,
-    ProcessingInstructionNodeTypeId,
+    DocumentType,
+    DocumentFragment,
+    Comment,
+    Document,
+    Element(ElementTypeId),
+    Text,
+    ProcessingInstruction,
 }
 
 trait PrivateNodeHelpers {
@@ -286,7 +284,7 @@ impl<'a> PrivateNodeHelpers for JSRef<'a, Node> {
 
         let parent = self.parent_node().root();
         parent.map(|parent| vtable_for(&*parent).child_inserted(self));
-        document.content_and_heritage_changed(self, OtherNodeDamage);
+        document.content_and_heritage_changed(self, NodeDamage::OtherNodeDamage);
     }
 
     // http://dom.spec.whatwg.org/#node-is-removed
@@ -546,29 +544,29 @@ impl<'a> NodeHelpers<'a> for JSRef<'a, Node> {
     #[inline]
     fn is_element(self) -> bool {
         match self.type_id {
-            ElementNodeTypeId(..) => true,
+            NodeTypeId::Element(..) => true,
             _ => false
         }
     }
 
     #[inline]
     fn is_document(self) -> bool {
-        self.type_id == DocumentNodeTypeId
+        self.type_id == NodeTypeId::Document
     }
 
     #[inline]
     fn is_anchor_element(self) -> bool {
-        self.type_id == ElementNodeTypeId(HTMLAnchorElementTypeId)
+        self.type_id == NodeTypeId::Element(ElementTypeId::HTMLAnchorElement)
     }
 
     #[inline]
     fn is_doctype(self) -> bool {
-        self.type_id == DoctypeNodeTypeId
+        self.type_id == NodeTypeId::DocumentType
     }
 
     #[inline]
     fn is_text(self) -> bool {
-        self.type_id == TextNodeTypeId
+        self.type_id == NodeTypeId::Text
     }
 
     fn get_flag(self, flag: NodeFlags) -> bool {
@@ -654,8 +652,8 @@ impl<'a> NodeHelpers<'a> for JSRef<'a, Node> {
     fn dirty_impl(self, damage: NodeDamage, force_ancestors: bool) {
         // 1. Dirty self.
         match damage {
-            NodeStyleDamaged => {}
-            OtherNodeDamage => self.set_has_changed(true),
+            NodeDamage::NodeStyleDamaged => {}
+            NodeDamage::OtherNodeDamage => self.set_has_changed(true),
         }
 
         if self.get_is_dirty() && !force_ancestors {
@@ -741,7 +739,7 @@ impl<'a> NodeHelpers<'a> for JSRef<'a, Node> {
     fn query_selector(self, selectors: DOMString) -> Fallible<Option<Temporary<Element>>> {
         // Step 1.
         let parser_context = ParserContext {
-            origin: AuthorOrigin,
+            origin: StylesheetOrigin::Author,
         };
         match style::parse_selector_list_from_str(&parser_context, selectors.as_slice()) {
             // Step 2.
@@ -766,7 +764,7 @@ impl<'a> NodeHelpers<'a> for JSRef<'a, Node> {
         let nodes;
         let root = self.ancestors().last().unwrap_or(self.clone());
         let parser_context = ParserContext {
-            origin: AuthorOrigin,
+            origin: StylesheetOrigin::Author,
         };
         match style::parse_selector_list_from_str(&parser_context, selectors.as_slice()) {
             // Step 2.
@@ -1176,7 +1174,7 @@ impl Node {
 
     fn new_(type_id: NodeTypeId, doc: Option<JSRef<Document>>) -> Node {
         Node {
-            eventtarget: EventTarget::new_inherited(NodeTargetTypeId(type_id)),
+            eventtarget: EventTarget::new_inherited(EventTargetTypeId::Node(type_id)),
             type_id: type_id,
 
             parent_node: Default::default(),
@@ -1214,7 +1212,7 @@ impl Node {
         // Step 1.
         match node.parent_node().root() {
             Some(parent) => {
-                Node::remove(node, *parent, Unsuppressed);
+                Node::remove(node, *parent, SuppressObserver::Unsuppressed);
             }
             None => (),
         }
@@ -1236,9 +1234,9 @@ impl Node {
                   -> Fallible<Temporary<Node>> {
         // Step 1.
         match parent.type_id() {
-            DocumentNodeTypeId |
-            DocumentFragmentNodeTypeId |
-            ElementNodeTypeId(..) => (),
+            NodeTypeId::Document |
+            NodeTypeId::DocumentFragment |
+            NodeTypeId::Element(..) => (),
             _ => return Err(HierarchyRequest)
         }
 
@@ -1255,29 +1253,29 @@ impl Node {
 
         // Step 4-5.
         match node.type_id() {
-            TextNodeTypeId => {
+            NodeTypeId::Text => {
                 if parent.is_document() {
                     return Err(HierarchyRequest);
                 }
             },
-            DoctypeNodeTypeId => {
+            NodeTypeId::DocumentType => {
                 if !parent.is_document() {
                     return Err(HierarchyRequest);
                 }
             },
-            DocumentFragmentNodeTypeId |
-            ElementNodeTypeId(_) |
-            ProcessingInstructionNodeTypeId |
-            CommentNodeTypeId => (),
-            DocumentNodeTypeId => return Err(HierarchyRequest)
+            NodeTypeId::DocumentFragment |
+            NodeTypeId::Element(_) |
+            NodeTypeId::ProcessingInstruction |
+            NodeTypeId::Comment => (),
+            NodeTypeId::Document => return Err(HierarchyRequest)
         }
 
         // Step 6.
         match parent.type_id() {
-            DocumentNodeTypeId => {
+            NodeTypeId::Document => {
                 match node.type_id() {
                     // Step 6.1
-                    DocumentFragmentNodeTypeId => {
+                    NodeTypeId::DocumentFragment => {
                         // Step 6.1.1(b)
                         if node.children().any(|c| c.is_text()) {
                             return Err(HierarchyRequest);
@@ -1304,7 +1302,7 @@ impl Node {
                         }
                     },
                     // Step 6.2
-                    ElementNodeTypeId(_) => {
+                    NodeTypeId::Element(_) => {
                         if !parent.child_elements().is_empty() {
                             return Err(HierarchyRequest);
                         }
@@ -1319,7 +1317,7 @@ impl Node {
                         }
                     },
                     // Step 6.3
-                    DoctypeNodeTypeId => {
+                    NodeTypeId::DocumentType => {
                         if parent.children().any(|c| c.is_doctype()) {
                             return Err(HierarchyRequest);
                         }
@@ -1338,10 +1336,10 @@ impl Node {
                             },
                         }
                     },
-                    TextNodeTypeId |
-                    ProcessingInstructionNodeTypeId |
-                    CommentNodeTypeId => (),
-                    DocumentNodeTypeId => unreachable!(),
+                    NodeTypeId::Text |
+                    NodeTypeId::ProcessingInstruction |
+                    NodeTypeId::Comment => (),
+                    NodeTypeId::Document => unreachable!(),
                 }
             },
             _ => (),
@@ -1358,7 +1356,7 @@ impl Node {
         Node::adopt(node, *document);
 
         // Step 10.
-        Node::insert(node, parent, referenceChild, Unsuppressed);
+        Node::insert(node, parent, referenceChild, SuppressObserver::Unsuppressed);
 
         // Step 11.
         return Ok(Temporary::from_rooted(node))
@@ -1385,8 +1383,8 @@ impl Node {
 
         fn fire_observer_if_necessary(node: JSRef<Node>, suppress_observers: SuppressObserver) {
             match suppress_observers {
-                Unsuppressed => node.node_inserted(),
-                Suppressed => ()
+                SuppressObserver::Unsuppressed => node.node_inserted(),
+                SuppressObserver::Suppressed => ()
             }
         }
 
@@ -1394,14 +1392,14 @@ impl Node {
         // Step 1-3: ranges.
 
         match node.type_id() {
-            DocumentFragmentNodeTypeId => {
+            NodeTypeId::DocumentFragment => {
                 // Step 4.
                 // Step 5: DocumentFragment, mutation records.
                 // Step 6: DocumentFragment.
                 let mut kids = Vec::new();
                 for kid in node.children() {
                     kids.push(kid.clone());
-                    Node::remove(kid, node, Suppressed);
+                    Node::remove(kid, node, SuppressObserver::Suppressed);
                 }
 
                 // Step 7: mutation records.
@@ -1445,19 +1443,19 @@ impl Node {
         let addedNodes = match node {
             None => vec!(),
             Some(node) => match node.type_id() {
-                DocumentFragmentNodeTypeId => node.children().collect(),
+                NodeTypeId::DocumentFragment => node.children().collect(),
                 _ => vec!(node.clone()),
             },
         };
 
         // Step 4.
         for child in parent.children() {
-            Node::remove(child, parent, Suppressed);
+            Node::remove(child, parent, SuppressObserver::Suppressed);
         }
 
         // Step 5.
         match node {
-            Some(node) => Node::insert(node, parent, None, Suppressed),
+            Some(node) => Node::insert(node, parent, None, SuppressObserver::Suppressed),
             None => (),
         }
 
@@ -1482,7 +1480,7 @@ impl Node {
         }
 
         // Step 2.
-        Node::remove(child, parent, Unsuppressed);
+        Node::remove(child, parent, SuppressObserver::Unsuppressed);
 
         // Step 3.
         Ok(Temporary::from_rooted(child))
@@ -1501,8 +1499,8 @@ impl Node {
 
         // Step 9.
         match suppress_observers {
-            Suppressed => (),
-            Unsuppressed => node.node_removed(parent.is_in_doc()),
+            SuppressObserver::Suppressed => (),
+            SuppressObserver::Unsuppressed => node.node_removed(parent.is_in_doc()),
         }
     }
 
@@ -1519,49 +1517,51 @@ impl Node {
         // Step 2.
         // XXXabinader: clone() for each node as trait?
         let copy: Root<Node> = match node.type_id() {
-            DoctypeNodeTypeId => {
+            NodeTypeId::DocumentType => {
                 let doctype: JSRef<DocumentType> = DocumentTypeCast::to_ref(node).unwrap();
                 let doctype = DocumentType::new(doctype.name().clone(),
                                                 Some(doctype.public_id().clone()),
                                                 Some(doctype.system_id().clone()), *document);
                 NodeCast::from_temporary(doctype)
             },
-            DocumentFragmentNodeTypeId => {
+            NodeTypeId::DocumentFragment => {
                 let doc_fragment = DocumentFragment::new(*document);
                 NodeCast::from_temporary(doc_fragment)
             },
-            CommentNodeTypeId => {
+            NodeTypeId::Comment => {
                 let comment: JSRef<Comment> = CommentCast::to_ref(node).unwrap();
                 let comment = Comment::new(comment.characterdata().data().clone(), *document);
                 NodeCast::from_temporary(comment)
             },
-            DocumentNodeTypeId => {
+            NodeTypeId::Document => {
                 let document: JSRef<Document> = DocumentCast::to_ref(node).unwrap();
                 let is_html_doc = match document.is_html_document() {
-                    true => HTMLDocument,
-                    false => NonHTMLDocument
+                    true => IsHTMLDocument::HTMLDocument,
+                    false => IsHTMLDocument::NonHTMLDocument,
                 };
                 let window = document.window().root();
                 let document = Document::new(*window, Some(document.url().clone()),
-                                             is_html_doc, None, NotFromParser);
+                                             is_html_doc, None,
+                                             DocumentSource::NotFromParser);
                 NodeCast::from_temporary(document)
             },
-            ElementNodeTypeId(..) => {
+            NodeTypeId::Element(..) => {
                 let element: JSRef<Element> = ElementCast::to_ref(node).unwrap();
                 let name = QualName {
                     ns: element.namespace().clone(),
                     local: element.local_name().clone()
                 };
                 let element = Element::create(name,
-                    element.prefix().as_ref().map(|p| p.as_slice().to_string()), *document, ScriptCreated);
+                    element.prefix().as_ref().map(|p| p.as_slice().to_string()),
+                    *document, ElementCreator::ScriptCreated);
                 NodeCast::from_temporary(element)
             },
-            TextNodeTypeId => {
+            NodeTypeId::Text => {
                 let text: JSRef<Text> = TextCast::to_ref(node).unwrap();
                 let text = Text::new(text.characterdata().data().clone(), *document);
                 NodeCast::from_temporary(text)
             },
-            ProcessingInstructionNodeTypeId => {
+            NodeTypeId::ProcessingInstruction => {
                 let pi: JSRef<ProcessingInstruction> = ProcessingInstructionCast::to_ref(node).unwrap();
                 let pi = ProcessingInstruction::new(pi.target().clone(),
                                                     pi.characterdata().data().clone(), *document);
@@ -1578,13 +1578,13 @@ impl Node {
 
         // Step 4 (some data already copied in step 2).
         match node.type_id() {
-            DocumentNodeTypeId => {
+            NodeTypeId::Document => {
                 let node_doc: JSRef<Document> = DocumentCast::to_ref(node).unwrap();
                 let copy_doc: JSRef<Document> = DocumentCast::to_ref(*copy).unwrap();
                 copy_doc.set_encoding_name(node_doc.encoding_name().clone());
                 copy_doc.set_quirks_mode(node_doc.quirks_mode());
             },
-            ElementNodeTypeId(..) => {
+            NodeTypeId::Element(..) => {
                 let node_elem: JSRef<Element> = ElementCast::to_ref(node).unwrap();
                 let copy_elem: JSRef<Element> = ElementCast::to_ref(*copy).unwrap();
 
@@ -1605,7 +1605,7 @@ impl Node {
         vtable_for(&node).cloning_steps(*copy, maybe_doc, clone_children);
 
         // Step 6.
-        if clone_children == CloneChildren {
+        if clone_children == CloneChildrenFlag::CloneChildren {
             for child in node.children() {
                 let child_copy = Node::clone(child, Some(document), clone_children).root();
                 let _inserted_node = Node::pre_insert(*child_copy, *copy, None);
@@ -1648,36 +1648,36 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
     // http://dom.spec.whatwg.org/#dom-node-nodetype
     fn NodeType(self) -> u16 {
         match self.type_id {
-            ElementNodeTypeId(_)            => NodeConstants::ELEMENT_NODE,
-            TextNodeTypeId                  => NodeConstants::TEXT_NODE,
-            ProcessingInstructionNodeTypeId => NodeConstants::PROCESSING_INSTRUCTION_NODE,
-            CommentNodeTypeId               => NodeConstants::COMMENT_NODE,
-            DocumentNodeTypeId              => NodeConstants::DOCUMENT_NODE,
-            DoctypeNodeTypeId               => NodeConstants::DOCUMENT_TYPE_NODE,
-            DocumentFragmentNodeTypeId      => NodeConstants::DOCUMENT_FRAGMENT_NODE,
+            NodeTypeId::Element(_)            => NodeConstants::ELEMENT_NODE,
+            NodeTypeId::Text                  => NodeConstants::TEXT_NODE,
+            NodeTypeId::ProcessingInstruction => NodeConstants::PROCESSING_INSTRUCTION_NODE,
+            NodeTypeId::Comment               => NodeConstants::COMMENT_NODE,
+            NodeTypeId::Document              => NodeConstants::DOCUMENT_NODE,
+            NodeTypeId::DocumentType          => NodeConstants::DOCUMENT_TYPE_NODE,
+            NodeTypeId::DocumentFragment      => NodeConstants::DOCUMENT_FRAGMENT_NODE,
         }
     }
 
     // http://dom.spec.whatwg.org/#dom-node-nodename
     fn NodeName(self) -> DOMString {
         match self.type_id {
-            ElementNodeTypeId(..) => {
+            NodeTypeId::Element(..) => {
                 let elem: JSRef<Element> = ElementCast::to_ref(self).unwrap();
                 elem.TagName()
             }
-            TextNodeTypeId => "#text".to_string(),
-            ProcessingInstructionNodeTypeId => {
+            NodeTypeId::Text => "#text".to_string(),
+            NodeTypeId::ProcessingInstruction => {
                 let processing_instruction: JSRef<ProcessingInstruction> =
                     ProcessingInstructionCast::to_ref(self).unwrap();
                 processing_instruction.Target()
             }
-            CommentNodeTypeId => "#comment".to_string(),
-            DoctypeNodeTypeId => {
+            NodeTypeId::Comment => "#comment".to_string(),
+            NodeTypeId::DocumentType => {
                 let doctype: JSRef<DocumentType> = DocumentTypeCast::to_ref(self).unwrap();
                 doctype.name().clone()
             },
-            DocumentFragmentNodeTypeId => "#document-fragment".to_string(),
-            DocumentNodeTypeId => "#document".to_string()
+            NodeTypeId::DocumentFragment => "#document-fragment".to_string(),
+            NodeTypeId::Document => "#document".to_string()
         }
     }
 
@@ -1690,13 +1690,13 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
     // http://dom.spec.whatwg.org/#dom-node-ownerdocument
     fn GetOwnerDocument(self) -> Option<Temporary<Document>> {
         match self.type_id {
-            ElementNodeTypeId(..) |
-            CommentNodeTypeId |
-            TextNodeTypeId |
-            ProcessingInstructionNodeTypeId |
-            DoctypeNodeTypeId |
-            DocumentFragmentNodeTypeId => Some(self.owner_doc()),
-            DocumentNodeTypeId => None
+            NodeTypeId::Element(..) |
+            NodeTypeId::Comment |
+            NodeTypeId::Text |
+            NodeTypeId::ProcessingInstruction |
+            NodeTypeId::DocumentType |
+            NodeTypeId::DocumentFragment => Some(self.owner_doc()),
+            NodeTypeId::Document => None
         }
     }
 
@@ -1753,9 +1753,9 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
     // http://dom.spec.whatwg.org/#dom-node-nodevalue
     fn GetNodeValue(self) -> Option<DOMString> {
         match self.type_id {
-            CommentNodeTypeId |
-            TextNodeTypeId |
-            ProcessingInstructionNodeTypeId => {
+            NodeTypeId::Comment |
+            NodeTypeId::Text |
+            NodeTypeId::ProcessingInstruction => {
                 let chardata: JSRef<CharacterData> = CharacterDataCast::to_ref(self).unwrap();
                 Some(chardata.Data())
             }
@@ -1768,9 +1768,9 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
     // http://dom.spec.whatwg.org/#dom-node-nodevalue
     fn SetNodeValue(self, val: Option<DOMString>) {
         match self.type_id {
-            CommentNodeTypeId |
-            TextNodeTypeId |
-            ProcessingInstructionNodeTypeId => {
+            NodeTypeId::Comment |
+            NodeTypeId::Text |
+            NodeTypeId::ProcessingInstruction => {
                 self.SetTextContent(val)
             }
             _ => {}
@@ -1780,19 +1780,19 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
     // http://dom.spec.whatwg.org/#dom-node-textcontent
     fn GetTextContent(self) -> Option<DOMString> {
         match self.type_id {
-            DocumentFragmentNodeTypeId |
-            ElementNodeTypeId(..) => {
+            NodeTypeId::DocumentFragment |
+            NodeTypeId::Element(..) => {
                 let content = Node::collect_text_contents(self.traverse_preorder());
                 Some(content)
             }
-            CommentNodeTypeId |
-            TextNodeTypeId |
-            ProcessingInstructionNodeTypeId => {
+            NodeTypeId::Comment |
+            NodeTypeId::Text |
+            NodeTypeId::ProcessingInstruction => {
                 let characterdata: JSRef<CharacterData> = CharacterDataCast::to_ref(self).unwrap();
                 Some(characterdata.Data())
             }
-            DoctypeNodeTypeId |
-            DocumentNodeTypeId => {
+            NodeTypeId::DocumentType |
+            NodeTypeId::Document => {
                 None
             }
         }
@@ -1802,8 +1802,8 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
     fn SetTextContent(self, value: Option<DOMString>) {
         let value = null_str_as_empty(&value);
         match self.type_id {
-            DocumentFragmentNodeTypeId |
-            ElementNodeTypeId(..) => {
+            NodeTypeId::DocumentFragment |
+            NodeTypeId::Element(..) => {
                 // Step 1-2.
                 let node = if value.len() == 0 {
                     None
@@ -1815,18 +1815,18 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
                 // Step 3.
                 Node::replace_all(node.root_ref(), self);
             }
-            CommentNodeTypeId |
-            TextNodeTypeId |
-            ProcessingInstructionNodeTypeId => {
+            NodeTypeId::Comment |
+            NodeTypeId::Text |
+            NodeTypeId::ProcessingInstruction => {
                 let characterdata: JSRef<CharacterData> = CharacterDataCast::to_ref(self).unwrap();
                 characterdata.set_data(value);
 
                 // Notify the document that the content of this node is different
                 let document = self.owner_doc().root();
-                document.content_changed(self, OtherNodeDamage);
+                document.content_changed(self, NodeDamage::OtherNodeDamage);
             }
-            DoctypeNodeTypeId |
-            DocumentNodeTypeId => {}
+            NodeTypeId::DocumentType |
+            NodeTypeId::Document => {}
         }
     }
 
@@ -1845,9 +1845,9 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
 
         // Step 1.
         match self.type_id {
-            DocumentNodeTypeId |
-            DocumentFragmentNodeTypeId |
-            ElementNodeTypeId(..) => (),
+            NodeTypeId::Document |
+            NodeTypeId::DocumentFragment |
+            NodeTypeId::Element(..) => (),
             _ => return Err(HierarchyRequest)
         }
 
@@ -1863,23 +1863,23 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
 
         // Step 4-5.
         match node.type_id() {
-            TextNodeTypeId if self.is_document() => return Err(HierarchyRequest),
-            DoctypeNodeTypeId if !self.is_document() => return Err(HierarchyRequest),
-            DocumentFragmentNodeTypeId |
-            DoctypeNodeTypeId |
-            ElementNodeTypeId(..) |
-            TextNodeTypeId |
-            ProcessingInstructionNodeTypeId |
-            CommentNodeTypeId => (),
-            DocumentNodeTypeId => return Err(HierarchyRequest)
+            NodeTypeId::Text if self.is_document() => return Err(HierarchyRequest),
+            NodeTypeId::DocumentType if !self.is_document() => return Err(HierarchyRequest),
+            NodeTypeId::DocumentFragment |
+            NodeTypeId::DocumentType |
+            NodeTypeId::Element(..) |
+            NodeTypeId::Text |
+            NodeTypeId::ProcessingInstruction |
+            NodeTypeId::Comment => (),
+            NodeTypeId::Document => return Err(HierarchyRequest)
         }
 
         // Step 6.
         match self.type_id {
-            DocumentNodeTypeId => {
+            NodeTypeId::Document => {
                 match node.type_id() {
                     // Step 6.1
-                    DocumentFragmentNodeTypeId => {
+                    NodeTypeId::DocumentFragment => {
                         // Step 6.1.1(b)
                         if node.children().any(|c| c.is_text()) {
                             return Err(HierarchyRequest);
@@ -1901,7 +1901,7 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
                         }
                     },
                     // Step 6.2
-                    ElementNodeTypeId(..) => {
+                    NodeTypeId::Element(..) => {
                         if self.child_elements().any(|c| NodeCast::from_ref(c) != child) {
                             return Err(HierarchyRequest);
                         }
@@ -1911,7 +1911,7 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
                         }
                     },
                     // Step 6.3
-                    DoctypeNodeTypeId => {
+                    NodeTypeId::DocumentType => {
                         if self.children().any(|c| c.is_doctype() && c != child) {
                             return Err(HierarchyRequest);
                         }
@@ -1921,10 +1921,10 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
                             return Err(HierarchyRequest);
                         }
                     },
-                    TextNodeTypeId |
-                    ProcessingInstructionNodeTypeId |
-                    CommentNodeTypeId => (),
-                    DocumentNodeTypeId => unreachable!()
+                    NodeTypeId::Text |
+                    NodeTypeId::ProcessingInstruction |
+                    NodeTypeId::Comment => (),
+                    NodeTypeId::Document => unreachable!()
                 }
             },
             _ => ()
@@ -1948,16 +1948,16 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
 
         {
             // Step 10.
-            Node::remove(child, self, Suppressed);
+            Node::remove(child, self, SuppressObserver::Suppressed);
 
             // Step 11.
-            Node::insert(node, self, reference_child, Suppressed);
+            Node::insert(node, self, reference_child, SuppressObserver::Suppressed);
         }
 
         // Step 12-14.
         // Step 13: mutation records.
         child.node_removed(self.is_in_doc());
-        if node.type_id() == DocumentFragmentNodeTypeId {
+        if node.type_id() == NodeTypeId::DocumentFragment {
             for child_node in node.children() {
                 child_node.node_inserted();
             }
@@ -2005,7 +2005,11 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
 
     // http://dom.spec.whatwg.org/#dom-node-clonenode
     fn CloneNode(self, deep: bool) -> Temporary<Node> {
-        Node::clone(self, None, if deep { CloneChildren } else { DoNotCloneChildren })
+        Node::clone(self, None, if deep {
+            CloneChildrenFlag::CloneChildren
+        } else {
+            CloneChildrenFlag::DoNotCloneChildren
+        })
     }
 
     // http://dom.spec.whatwg.org/#dom-node-isequalnode
@@ -2056,13 +2060,13 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
 
             match node.type_id() {
                 // Step 3.
-                DoctypeNodeTypeId if !is_equal_doctype(this, node) => return false,
-                ElementNodeTypeId(..) if !is_equal_element(this, node) => return false,
-                ProcessingInstructionNodeTypeId if !is_equal_processinginstruction(this, node) => return false,
-                TextNodeTypeId |
-                CommentNodeTypeId if !is_equal_characterdata(this, node) => return false,
+                NodeTypeId::DocumentType if !is_equal_doctype(this, node) => return false,
+                NodeTypeId::Element(..) if !is_equal_element(this, node) => return false,
+                NodeTypeId::ProcessingInstruction if !is_equal_processinginstruction(this, node) => return false,
+                NodeTypeId::Text |
+                NodeTypeId::Comment if !is_equal_characterdata(this, node) => return false,
                 // Step 4.
-                ElementNodeTypeId(..) if !is_equal_element_attrs(this, node) => return false,
+                NodeTypeId::Element(..) if !is_equal_element_attrs(this, node) => return false,
                 _ => ()
             }
 
@@ -2280,11 +2284,11 @@ impl<'a> style::TNode<'a, JSRef<'a, Element>> for JSRef<'a, Node> {
             }
         };
         match attr.namespace {
-            style::SpecificNamespace(ref ns) => {
+            style::NamespaceConstraint::Specific(ref ns) => {
                 self.as_element().get_attribute(ns.clone(), name).root()
                     .map_or(false, |attr| test(attr.value().as_slice()))
             },
-            style::AnyNamespace => {
+            style::NamespaceConstraint::Any => {
                 self.as_element().get_attributes(name).iter()
                     .map(|attr| attr.root())
                     .any(|attr| test(attr.value().as_slice()))
diff --git a/components/script/dom/nodelist.rs b/components/script/dom/nodelist.rs
index d30f0ffc6b3..e2b09985146 100644
--- a/components/script/dom/nodelist.rs
+++ b/components/script/dom/nodelist.rs
@@ -38,19 +38,19 @@ impl NodeList {
     }
 
     pub fn new_simple_list(window: JSRef<Window>, elements: Vec<JSRef<Node>>) -> Temporary<NodeList> {
-        NodeList::new(window, Simple(elements.iter().map(|element| JS::from_rooted(*element)).collect()))
+        NodeList::new(window, NodeListType::Simple(elements.iter().map(|element| JS::from_rooted(*element)).collect()))
     }
 
     pub fn new_child_list(window: JSRef<Window>, node: JSRef<Node>) -> Temporary<NodeList> {
-        NodeList::new(window, Children(JS::from_rooted(node)))
+        NodeList::new(window, NodeListType::Children(JS::from_rooted(node)))
     }
 }
 
 impl<'a> NodeListMethods for JSRef<'a, NodeList> {
     fn Length(self) -> u32 {
         match self.list_type {
-            Simple(ref elems) => elems.len() as u32,
-            Children(ref node) => {
+            NodeListType::Simple(ref elems) => elems.len() as u32,
+            NodeListType::Children(ref node) => {
                 let node = node.root();
                 node.children().count() as u32
             }
@@ -60,8 +60,8 @@ impl<'a> NodeListMethods for JSRef<'a, NodeList> {
     fn Item(self, index: u32) -> Option<Temporary<Node>> {
         match self.list_type {
             _ if index >= self.Length() => None,
-            Simple(ref elems) => Some(Temporary::new(elems[index as uint].clone())),
-            Children(ref node) => {
+            NodeListType::Simple(ref elems) => Some(Temporary::new(elems[index as uint].clone())),
+            NodeListType::Children(ref node) => {
                 let node = node.root();
                 node.children().nth(index as uint)
                                        .map(|child| Temporary::from_rooted(child))
diff --git a/components/script/dom/processinginstruction.rs b/components/script/dom/processinginstruction.rs
index 7b2c5f22ba6..99c904817a4 100644
--- a/components/script/dom/processinginstruction.rs
+++ b/components/script/dom/processinginstruction.rs
@@ -9,8 +9,8 @@ use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::characterdata::CharacterData;
 use dom::document::Document;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
-use dom::node::{Node, ProcessingInstructionNodeTypeId};
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 /// An HTML processing instruction node.
@@ -22,14 +22,14 @@ pub struct ProcessingInstruction {
 
 impl ProcessingInstructionDerived for EventTarget {
     fn is_processinginstruction(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(ProcessingInstructionNodeTypeId)
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::ProcessingInstruction)
     }
 }
 
 impl ProcessingInstruction {
     fn new_inherited(target: DOMString, data: DOMString, document: JSRef<Document>) -> ProcessingInstruction {
         ProcessingInstruction {
-            characterdata: CharacterData::new_inherited(ProcessingInstructionNodeTypeId, data, document),
+            characterdata: CharacterData::new_inherited(NodeTypeId::ProcessingInstruction, data, document),
             target: target
         }
     }
diff --git a/components/script/dom/progressevent.rs b/components/script/dom/progressevent.rs
index 31b125f8634..f3b4d5f29db 100644
--- a/components/script/dom/progressevent.rs
+++ b/components/script/dom/progressevent.rs
@@ -10,7 +10,7 @@ use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
-use dom::event::{Event, ProgressEventTypeId};
+use dom::event::{Event, EventTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -23,14 +23,14 @@ pub struct ProgressEvent {
 
 impl ProgressEventDerived for Event {
     fn is_progressevent(&self) -> bool {
-        *self.type_id() == ProgressEventTypeId
+        *self.type_id() == EventTypeId::ProgressEvent
     }
 }
 
 impl ProgressEvent {
     fn new_inherited(length_computable: bool, loaded: u64, total: u64) -> ProgressEvent {
         ProgressEvent {
-            event: Event::new_inherited(ProgressEventTypeId),
+            event: Event::new_inherited(EventTypeId::ProgressEvent),
             length_computable: length_computable,
             loaded: loaded,
             total: total
diff --git a/components/script/dom/testbinding.rs b/components/script/dom/testbinding.rs
index 0184cbc99c2..8c4ea8d7817 100644
--- a/components/script/dom/testbinding.rs
+++ b/components/script/dom/testbinding.rs
@@ -4,12 +4,14 @@
 
 use dom::bindings::codegen::Bindings::TestBindingBinding::TestBindingMethods;
 use dom::bindings::codegen::Bindings::TestBindingBinding::TestEnum;
-use dom::bindings::codegen::Bindings::TestBindingBinding::TestEnumValues::_empty;
+use dom::bindings::codegen::Bindings::TestBindingBinding::TestEnum::_empty;
 use dom::bindings::codegen::Bindings::EventListenerBinding::EventListener;
 use dom::bindings::codegen::Bindings::FunctionBinding::Function;
-use dom::bindings::codegen::UnionTypes::BlobOrString::BlobOrString;
-use dom::bindings::codegen::UnionTypes::EventOrString::{EventOrString, eString};
-use dom::bindings::codegen::UnionTypes::HTMLElementOrLong::{HTMLElementOrLong, eLong};
+use dom::bindings::codegen::UnionTypes::BlobOrString;
+use dom::bindings::codegen::UnionTypes::EventOrString;
+use dom::bindings::codegen::UnionTypes::EventOrString::eString;
+use dom::bindings::codegen::UnionTypes::HTMLElementOrLong;
+use dom::bindings::codegen::UnionTypes::HTMLElementOrLong::eLong;
 use dom::bindings::global::GlobalField;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::str::ByteString;
diff --git a/components/script/dom/text.rs b/components/script/dom/text.rs
index 1843bf58d21..368b1373fa7 100644
--- a/components/script/dom/text.rs
+++ b/components/script/dom/text.rs
@@ -11,8 +11,8 @@ use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::characterdata::CharacterData;
 use dom::document::Document;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
-use dom::node::{Node, TextNodeTypeId};
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
+use dom::node::{Node, NodeTypeId};
 use servo_util::str::DOMString;
 
 /// An HTML text node.
@@ -23,14 +23,14 @@ pub struct Text {
 
 impl TextDerived for EventTarget {
     fn is_text(&self) -> bool {
-        *self.type_id() == NodeTargetTypeId(TextNodeTypeId)
+        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Text)
     }
 }
 
 impl Text {
     fn new_inherited(text: DOMString, document: JSRef<Document>) -> Text {
         Text {
-            characterdata: CharacterData::new_inherited(TextNodeTypeId, text, document)
+            characterdata: CharacterData::new_inherited(NodeTypeId::Text, text, document)
         }
     }
 
diff --git a/components/script/dom/treewalker.rs b/components/script/dom/treewalker.rs
index bac939062ee..d9037788c85 100644
--- a/components/script/dom/treewalker.rs
+++ b/components/script/dom/treewalker.rs
@@ -2,7 +2,7 @@
  * 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::callback::RethrowExceptions;
+use dom::bindings::callback::ExceptionHandling::RethrowExceptions;
 use dom::bindings::codegen::Bindings::TreeWalkerBinding;
 use dom::bindings::codegen::Bindings::TreeWalkerBinding::TreeWalkerMethods;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
@@ -58,8 +58,8 @@ impl TreeWalker {
                what_to_show: u32,
                node_filter: Option<NodeFilter>) -> Temporary<TreeWalker> {
         let filter = match node_filter {
-            None => FilterNone,
-            Some(jsfilter) => FilterJS(jsfilter)
+            None => Filter::None,
+            Some(jsfilter) => Filter::JS(jsfilter)
         };
         TreeWalker::new_with_filter(document, root_node, what_to_show, filter)
     }
@@ -76,9 +76,9 @@ impl<'a> TreeWalkerMethods for JSRef<'a, TreeWalker> {
 
     fn GetFilter(self) -> Option<NodeFilter> {
         match self.filter {
-            FilterNone => None,
-            FilterJS(nf) => Some(nf),
-            FilterNative(_) => panic!("Cannot convert native node filter to DOM NodeFilter")
+            Filter::None => None,
+            Filter::JS(nf) => Some(nf),
+            Filter::Native(_) => panic!("Cannot convert native node filter to DOM NodeFilter")
         }
     }
 
@@ -331,9 +331,9 @@ impl<'a> PrivateTreeWalkerHelpers<'a> for JSRef<'a, TreeWalker> {
         // "5. If an exception was thrown, re-throw the exception."
         // "6. Return result."
         match self.filter {
-            FilterNone => Ok(NodeFilterConstants::FILTER_ACCEPT),
-            FilterNative(f) => Ok((f)(node)),
-            FilterJS(callback) => callback.AcceptNode_(self, node, RethrowExceptions)
+            Filter::None => Ok(NodeFilterConstants::FILTER_ACCEPT),
+            Filter::Native(f) => Ok((f)(node)),
+            Filter::JS(callback) => callback.AcceptNode_(self, node, RethrowExceptions)
         }
     }
 
@@ -551,9 +551,9 @@ impl<'a> Iterator<JSRef<'a, Node>> for JSRef<'a, TreeWalker> {
 
 #[jstraceable]
 pub enum Filter {
-    FilterNone,
-    FilterNative(fn (node: JSRef<Node>) -> u16),
-    FilterJS(NodeFilter)
+    None,
+    Native(fn (node: JSRef<Node>) -> u16),
+    JS(NodeFilter)
 }
 
 // FIXME: NodeFilterConstants will be defined in NodeFilterBindings.rs
diff --git a/components/script/dom/uievent.rs b/components/script/dom/uievent.rs
index f0c2dddf23a..eca5ababb22 100644
--- a/components/script/dom/uievent.rs
+++ b/components/script/dom/uievent.rs
@@ -12,7 +12,7 @@ use dom::bindings::global;
 use dom::bindings::js::{MutNullableJS, JSRef, RootedReference, Temporary, OptionalSettable};
 
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
-use dom::event::{Event, EventTypeId, UIEventTypeId};
+use dom::event::{Event, EventTypeId};
 use dom::window::Window;
 use servo_util::str::DOMString;
 
@@ -28,7 +28,7 @@ pub struct UIEvent {
 
 impl UIEventDerived for Event {
     fn is_uievent(&self) -> bool {
-        *self.type_id() == UIEventTypeId
+        *self.type_id() == EventTypeId::UIEvent
     }
 }
 
@@ -42,7 +42,7 @@ impl UIEvent {
     }
 
     pub fn new_uninitialized(window: JSRef<Window>) -> Temporary<UIEvent> {
-        reflect_dom_object(box UIEvent::new_inherited(UIEventTypeId),
+        reflect_dom_object(box UIEvent::new_inherited(EventTypeId::UIEvent),
                            global::Window(window),
                            UIEventBinding::Wrap)
     }
diff --git a/components/script/dom/urlsearchparams.rs b/components/script/dom/urlsearchparams.rs
index 11b827be41b..c71a28cc3d1 100644
--- a/components/script/dom/urlsearchparams.rs
+++ b/components/script/dom/urlsearchparams.rs
@@ -5,7 +5,8 @@
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::URLSearchParamsBinding;
 use dom::bindings::codegen::Bindings::URLSearchParamsBinding::URLSearchParamsMethods;
-use dom::bindings::codegen::UnionTypes::StringOrURLSearchParams::{StringOrURLSearchParams, eURLSearchParams, eString};
+use dom::bindings::codegen::UnionTypes::StringOrURLSearchParams;
+use dom::bindings::codegen::UnionTypes::StringOrURLSearchParams::{eURLSearchParams, eString};
 use dom::bindings::error::{Fallible};
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JSRef, Temporary};
@@ -14,7 +15,7 @@ use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
 use servo_util::str::DOMString;
 
 use encoding::all::UTF_8;
-use encoding::types::{EncodingRef, EncodeReplace};
+use encoding::types::{EncodingRef, EncoderTrap};
 
 use std::collections::HashMap;
 use std::collections::hash_map::{Occupied, Vacant};
@@ -111,7 +112,7 @@ impl URLSearchParamsHelpers for URLSearchParams {
 
             let value = value.as_slice();
             // XXXManishearth should this be a strict encoding? Can unwrap()ing the result fail?
-            let value = encoding.encode(value, EncodeReplace).unwrap();
+            let value = encoding.encode(value, EncoderTrap::Replace).unwrap();
             let mut buf = vec!();
             for i in value.iter() {
                 let append = match *i {
diff --git a/components/script/dom/virtualmethods.rs b/components/script/dom/virtualmethods.rs
index 94a74124eca..ff78a7beaa6 100644
--- a/components/script/dom/virtualmethods.rs
+++ b/components/script/dom/virtualmethods.rs
@@ -2,8 +2,7 @@
  * 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::attr::Attr;
-use dom::attr::{AttrValue, StringAttrValue};
+use dom::attr::{Attr, AttrValue};
 use dom::bindings::codegen::InheritTypes::ElementCast;
 use dom::bindings::codegen::InheritTypes::HTMLAnchorElementCast;
 use dom::bindings::codegen::InheritTypes::HTMLAreaElementCast;
@@ -31,30 +30,7 @@ use dom::bindings::codegen::InheritTypes::HTMLTitleElementCast;
 use dom::bindings::js::JSRef;
 use dom::document::Document;
 use dom::element::Element;
-use dom::element::ElementTypeId_;
-use dom::element::HTMLAnchorElementTypeId;
-use dom::element::HTMLAreaElementTypeId;
-use dom::element::HTMLBodyElementTypeId;
-use dom::element::HTMLButtonElementTypeId;
-use dom::element::HTMLCanvasElementTypeId;
-use dom::element::HTMLFieldSetElementTypeId;
-use dom::element::HTMLIFrameElementTypeId;
-use dom::element::HTMLImageElementTypeId;
-use dom::element::HTMLInputElementTypeId;
-use dom::element::HTMLLinkElementTypeId;
-use dom::element::HTMLObjectElementTypeId;
-use dom::element::HTMLOptGroupElementTypeId;
-use dom::element::HTMLOptionElementTypeId;
-use dom::element::HTMLScriptElementTypeId;
-use dom::element::HTMLSelectElementTypeId;
-use dom::element::HTMLStyleElementTypeId;
-use dom::element::HTMLTableDataCellElementTypeId;
-use dom::element::HTMLTableElementTypeId;
-use dom::element::HTMLTableHeaderCellElementTypeId;
-use dom::element::HTMLTableRowElementTypeId;
-use dom::element::HTMLTableSectionElementTypeId;
-use dom::element::HTMLTextAreaElementTypeId;
-use dom::element::HTMLTitleElementTypeId;
+use dom::element::ElementTypeId;
 use dom::event::Event;
 use dom::htmlanchorelement::HTMLAnchorElement;
 use dom::htmlareaelement::HTMLAreaElement;
@@ -79,7 +55,7 @@ use dom::htmltablerowelement::HTMLTableRowElement;
 use dom::htmltablesectionelement::HTMLTableSectionElement;
 use dom::htmltextareaelement::HTMLTextAreaElement;
 use dom::htmltitleelement::HTMLTitleElement;
-use dom::node::{Node, NodeHelpers, ElementNodeTypeId, CloneChildrenFlag};
+use dom::node::{Node, NodeHelpers, NodeTypeId, CloneChildrenFlag};
 
 use servo_util::str::DOMString;
 
@@ -115,7 +91,7 @@ pub trait VirtualMethods {
     fn parse_plain_attribute(&self, name: &Atom, value: DOMString) -> AttrValue {
         match self.super_type() {
             Some(ref s) => s.parse_plain_attribute(name, value),
-            _ => StringAttrValue(value),
+            _ => AttrValue::String(value),
         }
     }
 
@@ -171,105 +147,105 @@ pub trait VirtualMethods {
 /// interrupted.
 pub fn vtable_for<'a>(node: &'a JSRef<'a, Node>) -> &'a VirtualMethods + 'a {
     match node.type_id() {
-        ElementNodeTypeId(HTMLAnchorElementTypeId) => {
+        NodeTypeId::Element(ElementTypeId::HTMLAnchorElement) => {
             let element: &'a JSRef<'a, HTMLAnchorElement> = HTMLAnchorElementCast::to_borrowed_ref(node).unwrap();
             element as &'a VirtualMethods + 'a
         }
-        ElementNodeTypeId(HTMLAreaElementTypeId) => {
+        NodeTypeId::Element(ElementTypeId::HTMLAreaElement) => {
             let element: &'a JSRef<'a, HTMLAreaElement> = HTMLAreaElementCast::to_borrowed_ref(node).unwrap();
             element as &'a VirtualMethods + 'a
         }
-        ElementNodeTypeId(HTMLBodyElementTypeId) => {
+        NodeTypeId::Element(ElementTypeId::HTMLBodyElement) => {
             let element: &'a JSRef<'a, HTMLBodyElement> = HTMLBodyElementCast::to_borrowed_ref(node).unwrap();
             element as &'a VirtualMethods + 'a
         }
-        ElementNodeTypeId(HTMLButtonElementTypeId) => {
+        NodeTypeId::Element(ElementTypeId::HTMLButtonElement) => {
             let element: &'a JSRef<'a, HTMLButtonElement> = HTMLButtonElementCast::to_borrowed_ref(node).unwrap();
             element as &'a VirtualMethods + 'a
         }
-        ElementNodeTypeId(HTMLCanvasElementTypeId) => {
+        NodeTypeId::Element(ElementTypeId::HTMLCanvasElement) => {
             let element: &'a JSRef<'a, HTMLCanvasElement> = HTMLCanvasElementCast::to_borrowed_ref(node).unwrap();
             element as &'a VirtualMethods + 'a
         }
-        ElementNodeTypeId(HTMLFieldSetElementTypeId) => {
+        NodeTypeId::Element(ElementTypeId::HTMLFieldSetElement) => {
             let element: &'a JSRef<'a, HTMLFieldSetElement> = HTMLFieldSetElementCast::to_borrowed_ref(node).unwrap();
             element as &'a VirtualMethods + 'a
         }
-        ElementNodeTypeId(HTMLImageElementTypeId) => {
+        NodeTypeId::Element(ElementTypeId::HTMLImageElement) => {
             let element: &'a JSRef<'a, HTMLImageElement> = HTMLImageElementCast::to_borrowed_ref(node).unwrap();
             element as &'a VirtualMethods + 'a
         }
-        ElementNodeTypeId(HTMLIFrameElementTypeId) => {
+        NodeTypeId::Element(ElementTypeId::HTMLIFrameElement) => {
             let element: &'a JSRef<'a, HTMLIFrameElement> = HTMLIFrameElementCast::to_borrowed_ref(node).unwrap();
             element as &'a VirtualMethods + 'a
         }
-        ElementNodeTypeId(HTMLInputElementTypeId) => {
+        NodeTypeId::Element(ElementTypeId::HTMLInputElement) => {
             let element: &'a JSRef<'a, HTMLInputElement> = HTMLInputElementCast::to_borrowed_ref(node).unwrap();
             element as &'a VirtualMethods + 'a
         }
-        ElementNodeTypeId(HTMLLinkElementTypeId) => {
+        NodeTypeId::Element(ElementTypeId::HTMLLinkElement) => {
             let element: &'a JSRef<'a, HTMLLinkElement> = HTMLLinkElementCast::to_borrowed_ref(node).unwrap();
             element as &'a VirtualMethods + 'a
         }
-        ElementNodeTypeId(HTMLObjectElementTypeId) => {
+        NodeTypeId::Element(ElementTypeId::HTMLObjectElement) => {
             let element: &'a JSRef<'a, HTMLObjectElement> = HTMLObjectElementCast::to_borrowed_ref(node).unwrap();
             element as &'a VirtualMethods + 'a
         }
-        ElementNodeTypeId(HTMLOptGroupElementTypeId) => {
+        NodeTypeId::Element(ElementTypeId::HTMLOptGroupElement) => {
             let element: &'a JSRef<'a, HTMLOptGroupElement> = HTMLOptGroupElementCast::to_borrowed_ref(node).unwrap();
             element as &'a VirtualMethods + 'a
         }
-        ElementNodeTypeId(HTMLOptionElementTypeId) => {
+        NodeTypeId::Element(ElementTypeId::HTMLOptionElement) => {
             let element: &'a JSRef<'a, HTMLOptionElement> = HTMLOptionElementCast::to_borrowed_ref(node).unwrap();
             element as &'a VirtualMethods + 'a
         }
-        ElementNodeTypeId(HTMLScriptElementTypeId) => {
+        NodeTypeId::Element(ElementTypeId::HTMLScriptElement) => {
             let element: &'a JSRef<'a, HTMLScriptElement> = HTMLScriptElementCast::to_borrowed_ref(node).unwrap();
             element as &'a VirtualMethods + 'a
         }
-        ElementNodeTypeId(HTMLSelectElementTypeId) => {
+        NodeTypeId::Element(ElementTypeId::HTMLSelectElement) => {
             let element: &'a JSRef<'a, HTMLSelectElement> = HTMLSelectElementCast::to_borrowed_ref(node).unwrap();
             element as &'a VirtualMethods + 'a
         }
-        ElementNodeTypeId(HTMLStyleElementTypeId) => {
+        NodeTypeId::Element(ElementTypeId::HTMLStyleElement) => {
             let element: &'a JSRef<'a, HTMLStyleElement> = HTMLStyleElementCast::to_borrowed_ref(node).unwrap();
             element as &'a VirtualMethods + 'a
         }
-        ElementNodeTypeId(HTMLTableElementTypeId) => {
+        NodeTypeId::Element(ElementTypeId::HTMLTableElement) => {
             let element: &'a JSRef<'a, HTMLTableElement> =
                 HTMLTableElementCast::to_borrowed_ref(node).unwrap();
             element as &'a VirtualMethods + 'a
         }
-        ElementNodeTypeId(HTMLTableDataCellElementTypeId) |
-        ElementNodeTypeId(HTMLTableHeaderCellElementTypeId) => {
+        NodeTypeId::Element(ElementTypeId::HTMLTableDataCellElement) |
+        NodeTypeId::Element(ElementTypeId::HTMLTableHeaderCellElement) => {
             let element: &'a JSRef<'a, HTMLTableCellElement> =
                 HTMLTableCellElementCast::to_borrowed_ref(node).unwrap();
             element as &'a VirtualMethods + 'a
         }
-        ElementNodeTypeId(HTMLTableRowElementTypeId) => {
+        NodeTypeId::Element(ElementTypeId::HTMLTableRowElement) => {
             let element: &'a JSRef<'a, HTMLTableRowElement> =
                 HTMLTableRowElementCast::to_borrowed_ref(node).unwrap();
             element as &'a VirtualMethods + 'a
         }
-        ElementNodeTypeId(HTMLTableSectionElementTypeId) => {
+        NodeTypeId::Element(ElementTypeId::HTMLTableSectionElement) => {
             let element: &'a JSRef<'a, HTMLTableSectionElement> =
                 HTMLTableSectionElementCast::to_borrowed_ref(node).unwrap();
             element as &'a VirtualMethods + 'a
         }
-        ElementNodeTypeId(HTMLTextAreaElementTypeId) => {
+        NodeTypeId::Element(ElementTypeId::HTMLTextAreaElement) => {
             let element: &'a JSRef<'a, HTMLTextAreaElement> = HTMLTextAreaElementCast::to_borrowed_ref(node).unwrap();
             element as &'a VirtualMethods + 'a
         }
-        ElementNodeTypeId(HTMLTitleElementTypeId) => {
+        NodeTypeId::Element(ElementTypeId::HTMLTitleElement) => {
             let element: &'a JSRef<'a, HTMLTitleElement> =
                 HTMLTitleElementCast::to_borrowed_ref(node).unwrap();
             element as &'a VirtualMethods + 'a
         }
-        ElementNodeTypeId(ElementTypeId_) => {
+        NodeTypeId::Element(ElementTypeId::Element) => {
             let element: &'a JSRef<'a, Element> = ElementCast::to_borrowed_ref(node).unwrap();
             element as &'a VirtualMethods + 'a
         }
-        ElementNodeTypeId(_) => {
+        NodeTypeId::Element(_) => {
             let element: &'a JSRef<'a, HTMLElement> = HTMLElementCast::to_borrowed_ref(node).unwrap();
             element as &'a VirtualMethods + 'a
         }
diff --git a/components/script/dom/websocket.rs b/components/script/dom/websocket.rs
index c40ac560f49..3e565bfd367 100644
--- a/components/script/dom/websocket.rs
+++ b/components/script/dom/websocket.rs
@@ -8,7 +8,7 @@ use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{Temporary, JSRef};
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
-use dom::eventtarget::{EventTarget, WebSocketTypeId};
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use servo_util::str::DOMString;
 
 #[dom_struct]
@@ -20,7 +20,7 @@ pub struct WebSocket {
 impl WebSocket {
     pub fn new_inherited(url: DOMString) -> WebSocket {
         WebSocket {
-            eventtarget: EventTarget::new_inherited(WebSocketTypeId),
+            eventtarget: EventTarget::new_inherited(EventTargetTypeId::WebSocket),
             url: url
         }
     }
diff --git a/components/script/dom/window.rs b/components/script/dom/window.rs
index be5d8ad35b2..8142b455f99 100644
--- a/components/script/dom/window.rs
+++ b/components/script/dom/window.rs
@@ -8,14 +8,15 @@ use dom::bindings::codegen::Bindings::FunctionBinding::Function;
 use dom::bindings::codegen::Bindings::WindowBinding;
 use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
 use dom::bindings::codegen::InheritTypes::EventTargetCast;
-use dom::bindings::error::{Fallible, InvalidCharacter};
+use dom::bindings::error::Fallible;
+use dom::bindings::error::Error::InvalidCharacter;
 use dom::bindings::global;
 use dom::bindings::js::{MutNullableJS, JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::browsercontext::BrowserContext;
 use dom::console::Console;
 use dom::document::Document;
-use dom::eventtarget::{EventTarget, WindowTypeId, EventTargetHelpers};
+use dom::eventtarget::{EventTarget, EventTargetHelpers, EventTargetTypeId};
 use dom::location::Location;
 use dom::navigator::Navigator;
 use dom::performance::Performance;
@@ -23,10 +24,10 @@ use dom::screen::Screen;
 use dom::storage::Storage;
 use layout_interface::{NoQuery, ReflowForDisplay, ReflowGoal, ReflowQueryType};
 use page::Page;
-use script_task::{ExitWindowMsg, ScriptChan, TriggerLoadMsg, TriggerFragmentMsg};
-use script_task::FromWindow;
+use script_task::{TimerSource, ScriptChan};
+use script_task::ScriptMsg::{ExitWindowMsg, TriggerLoadMsg, TriggerFragmentMsg};
 use script_traits::ScriptControlChan;
-use timers::{Interval, NonInterval, TimerId, TimerManager};
+use timers::{IsInterval, TimerId, TimerManager};
 
 use servo_msg::compositor_msg::ScriptListener;
 use servo_msg::constellation_msg::LoadData;
@@ -218,8 +219,8 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
         self.timers.set_timeout_or_interval(callback,
                                             args,
                                             timeout,
-                                            NonInterval,
-                                            FromWindow(self.page.id.clone()),
+                                            IsInterval::NonInterval,
+                                            TimerSource::FromWindow(self.page.id.clone()),
                                             self.script_chan.clone())
     }
 
@@ -231,8 +232,8 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
         self.timers.set_timeout_or_interval(callback,
                                             args,
                                             timeout,
-                                            Interval,
-                                            FromWindow(self.page.id.clone()),
+                                            IsInterval::Interval,
+                                            TimerSource::FromWindow(self.page.id.clone()),
                                             self.script_chan.clone())
     }
 
@@ -370,7 +371,7 @@ impl Window {
                image_cache_task: ImageCacheTask)
                -> Temporary<Window> {
         let win = box Window {
-            eventtarget: EventTarget::new_inherited(WindowTypeId),
+            eventtarget: EventTarget::new_inherited(EventTargetTypeId::Window),
             script_chan: script_chan,
             control_chan: control_chan,
             console: Default::default(),
diff --git a/components/script/dom/worker.rs b/components/script/dom/worker.rs
index ae7af114d7a..ed90118d1fd 100644
--- a/components/script/dom/worker.rs
+++ b/components/script/dom/worker.rs
@@ -6,15 +6,17 @@ use dom::bindings::codegen::Bindings::WorkerBinding;
 use dom::bindings::codegen::Bindings::WorkerBinding::WorkerMethods;
 use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
 use dom::bindings::codegen::InheritTypes::EventTargetCast;
-use dom::bindings::error::{Fallible, Syntax, ErrorResult, DataClone};
+use dom::bindings::error::{Fallible, ErrorResult};
+use dom::bindings::error::Error::{Syntax, DataClone};
 use dom::bindings::global::{GlobalRef, GlobalField};
 use dom::bindings::js::{JS, JSRef, Temporary};
 use dom::bindings::trace::JSTraceable;
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
 use dom::dedicatedworkerglobalscope::DedicatedWorkerGlobalScope;
-use dom::eventtarget::{EventTarget, EventTargetHelpers, WorkerTypeId};
+use dom::eventtarget::{EventTarget, EventTargetHelpers, EventTargetTypeId};
 use dom::messageevent::MessageEvent;
-use script_task::{ScriptChan, DOMMessage};
+use script_task::ScriptChan;
+use script_task::ScriptMsg::DOMMessage;
 
 use servo_util::str::DOMString;
 
@@ -44,7 +46,7 @@ pub struct Worker {
 impl Worker {
     fn new_inherited(global: &GlobalRef, sender: ScriptChan) -> Worker {
         Worker {
-            eventtarget: EventTarget::new_inherited(WorkerTypeId),
+            eventtarget: EventTarget::new_inherited(EventTargetTypeId::Worker),
             refcount: Cell::new(0),
             global: GlobalField::from_rooted(global),
             sender: sender,
diff --git a/components/script/dom/workerglobalscope.rs b/components/script/dom/workerglobalscope.rs
index c5e87e90a83..f1dcbd5adfd 100644
--- a/components/script/dom/workerglobalscope.rs
+++ b/components/script/dom/workerglobalscope.rs
@@ -4,17 +4,18 @@
 
 use dom::bindings::codegen::Bindings::WorkerGlobalScopeBinding::WorkerGlobalScopeMethods;
 use dom::bindings::codegen::Bindings::FunctionBinding::Function;
-use dom::bindings::error::{ErrorResult, Fallible, Syntax, Network, FailureUnknown};
+use dom::bindings::error::{ErrorResult, Fallible};
+use dom::bindings::error::Error::{Syntax, Network, FailureUnknown};
 use dom::bindings::global;
 use dom::bindings::js::{MutNullableJS, JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::console::Console;
-use dom::eventtarget::{EventTarget, WorkerGlobalScopeTypeId};
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::workerlocation::WorkerLocation;
 use dom::workernavigator::WorkerNavigator;
 use dom::window::{base64_atob, base64_btoa};
-use script_task::{ScriptChan, FromWorker};
-use timers::{Interval, NonInterval, TimerId, TimerManager};
+use script_task::{ScriptChan, TimerSource};
+use timers::{IsInterval, TimerId, TimerManager};
 
 use servo_net::resource_task::{ResourceTask, load_whole_resource};
 use servo_util::str::DOMString;
@@ -29,7 +30,7 @@ use url::{Url, UrlParser};
 
 #[deriving(PartialEq)]
 #[jstraceable]
-pub enum WorkerGlobalScopeId {
+pub enum WorkerGlobalScopeTypeId {
     DedicatedGlobalScope,
 }
 
@@ -47,13 +48,13 @@ pub struct WorkerGlobalScope {
 }
 
 impl WorkerGlobalScope {
-    pub fn new_inherited(type_id: WorkerGlobalScopeId,
+    pub fn new_inherited(type_id: WorkerGlobalScopeTypeId,
                          worker_url: Url,
                          cx: Rc<Cx>,
                          resource_task: ResourceTask,
                          script_chan: ScriptChan) -> WorkerGlobalScope {
         WorkerGlobalScope {
-            eventtarget: EventTarget::new_inherited(WorkerGlobalScopeTypeId(type_id)),
+            eventtarget: EventTarget::new_inherited(EventTargetTypeId::WorkerGlobalScope(type_id)),
             worker_url: worker_url,
             js_context: cx,
             resource_task: resource_task,
@@ -150,8 +151,8 @@ impl<'a> WorkerGlobalScopeMethods for JSRef<'a, WorkerGlobalScope> {
         self.timers.set_timeout_or_interval(callback,
                                             args,
                                             timeout,
-                                            NonInterval,
-                                            FromWorker,
+                                            IsInterval::NonInterval,
+                                            TimerSource::FromWorker,
                                             self.script_chan.clone())
     }
 
@@ -163,8 +164,8 @@ impl<'a> WorkerGlobalScopeMethods for JSRef<'a, WorkerGlobalScope> {
         self.timers.set_timeout_or_interval(callback,
                                             args,
                                             timeout,
-                                            Interval,
-                                            FromWorker,
+                                            IsInterval::Interval,
+                                            TimerSource::FromWorker,
                                             self.script_chan.clone())
     }
 
diff --git a/components/script/dom/xmlhttprequest.rs b/components/script/dom/xmlhttprequest.rs
index b5f580fc6a5..451c3ab8079 100644
--- a/components/script/dom/xmlhttprequest.rs
+++ b/components/script/dom/xmlhttprequest.rs
@@ -2,32 +2,40 @@
  * 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 self::SyncOrAsync::*;
+use self::TerminateReason::*;
+use self::XHRProgress::*;
+use self::XMLHttpRequestState::*;
+
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
 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::XMLHttpRequestResponseTypeValues;
-use dom::bindings::codegen::Bindings::XMLHttpRequestBinding::XMLHttpRequestResponseTypeValues::{_empty, Json, Text};
+use dom::bindings::codegen::Bindings::XMLHttpRequestBinding::XMLHttpRequestResponseType::{_empty, Json, Text};
 use dom::bindings::codegen::InheritTypes::{EventCast, EventTargetCast, XMLHttpRequestDerived};
 use dom::bindings::conversions::ToJSValConvertible;
-use dom::bindings::error::{Error, ErrorResult, Fallible, InvalidState, InvalidAccess};
-use dom::bindings::error::{Network, Syntax, Security, Abort, Timeout};
+use dom::bindings::error::{Error, ErrorResult, Fallible};
+use dom::bindings::error::Error::{InvalidState, InvalidAccess};
+use dom::bindings::error::Error::{Network, Syntax, Security, Abort, Timeout};
 use dom::bindings::global::{GlobalField, GlobalRef, WorkerRoot};
 use dom::bindings::js::{MutNullableJS, JS, JSRef, Temporary, OptionalRootedRootable};
 use dom::bindings::str::ByteString;
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
 use dom::document::Document;
-use dom::event::{Event, DoesNotBubble, Cancelable};
-use dom::eventtarget::{EventTarget, EventTargetHelpers, XMLHttpRequestTargetTypeId};
+use dom::event::{Event, EventBubbles, EventCancelable};
+use dom::eventtarget::{EventTarget, EventTargetHelpers, EventTargetTypeId};
 use dom::progressevent::ProgressEvent;
 use dom::urlsearchparams::URLSearchParamsHelpers;
 use dom::xmlhttprequesteventtarget::XMLHttpRequestEventTarget;
+use dom::xmlhttprequesteventtarget::XMLHttpRequestEventTargetTypeId;
 use dom::xmlhttprequestupload::XMLHttpRequestUpload;
+use script_task::ScriptChan;
+use script_task::ScriptMsg::{XHRProgressMsg, XHRReleaseMsg};
 
 use encoding::all::UTF_8;
 use encoding::label::encoding_from_whatwg_label;
-use encoding::types::{DecodeReplace, Encoding, EncodingRef, EncodeReplace};
+use encoding::types::{DecoderTrap, Encoding, EncodingRef, EncoderTrap};
 
 use hyper::header::Headers;
 use hyper::header::common::{Accept, ContentLength, ContentType};
@@ -43,8 +51,7 @@ use libc;
 use libc::c_void;
 
 use net::resource_task::{ResourceTask, ResourceCORSData, Load, LoadData, LoadResponse, Payload, Done};
-use cors::{allow_cross_origin_request, CORSRequest, CORSMode, ForcedPreflightMode};
-use script_task::{ScriptChan, XHRProgressMsg, XHRReleaseMsg};
+use cors::{allow_cross_origin_request, CORSRequest, RequestMode};
 use servo_util::str::DOMString;
 use servo_util::task::spawn_named;
 
@@ -53,23 +60,15 @@ use std::cell::Cell;
 use std::comm::{Sender, Receiver, channel};
 use std::default::Default;
 use std::io::Timer;
-use std::from_str::FromStr;
+use std::str::FromStr;
 use std::time::duration::Duration;
-use std::num::Zero;
 use time;
 use url::{Url, UrlParser};
 
-use dom::bindings::codegen::UnionTypes::StringOrURLSearchParams::{eString, eURLSearchParams, StringOrURLSearchParams};
+use dom::bindings::codegen::UnionTypes::StringOrURLSearchParams;
+use dom::bindings::codegen::UnionTypes::StringOrURLSearchParams::{eString, eURLSearchParams};
 pub type SendParam = StringOrURLSearchParams;
 
-
-#[deriving(PartialEq)]
-#[jstraceable]
-pub enum XMLHttpRequestId {
-    XMLHttpRequestTypeId,
-    XMLHttpRequestUploadTypeId
-}
-
 #[deriving(PartialEq)]
 #[jstraceable]
 enum XMLHttpRequestState {
@@ -152,7 +151,7 @@ pub struct XMLHttpRequest {
 impl XMLHttpRequest {
     fn new_inherited(global: &GlobalRef) -> XMLHttpRequest {
         XMLHttpRequest {
-            eventtarget: XMLHttpRequestEventTarget::new_inherited(XMLHttpRequestTypeId),
+            eventtarget: XMLHttpRequestEventTarget::new_inherited(XMLHttpRequestEventTargetTypeId::XMLHttpRequest),
             ready_state: Cell::new(Unsent),
             timeout: Cell::new(0u32),
             with_credentials: Cell::new(false),
@@ -570,7 +569,7 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
 
             if !request_headers.has::<Accept>() {
                 request_headers.set(
-                    Accept(vec![Mime(mime::TopStar, mime::SubStar, vec![])]));
+                    Accept(vec![Mime(mime::TopLevel::Star, mime::SubLevel::Star, vec![])]));
             }
         } // drops the borrow_mut
 
@@ -582,9 +581,9 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
         // CORS stuff
         let referer_url = self.global.root().root_ref().get_url();
         let mode = if self.upload_events.get() {
-            ForcedPreflightMode
+            RequestMode::ForcedPreflight
         } else {
-            CORSMode
+            RequestMode::CORS
         };
         let cors_request = CORSRequest::maybe_new(referer_url.clone(), load_data.url.clone(), mode,
                                                   load_data.method.clone(), load_data.headers.clone());
@@ -681,7 +680,7 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
     }
     fn SetResponseType(self, response_type: XMLHttpRequestResponseType) -> ErrorResult {
         match self.global.root() {
-            WorkerRoot(_) if response_type == XMLHttpRequestResponseTypeValues::Document
+            WorkerRoot(_) if response_type == XMLHttpRequestResponseType::Document
             => return Ok(()),
             _ => {}
         }
@@ -706,7 +705,7 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
             },
             _ if self.ready_state.get() != XHRDone => NullValue(),
             Json => {
-                let decoded = UTF_8.decode(self.response.borrow().as_slice(), DecodeReplace).unwrap().to_string();
+                let decoded = UTF_8.decode(self.response.borrow().as_slice(), DecoderTrap::Replace).unwrap().to_string();
                 let decoded: Vec<u16> = decoded.as_slice().utf16_units().collect();
                 let mut vp = UndefinedValue();
                 unsafe {
@@ -748,7 +747,7 @@ impl Reflectable for XMLHttpRequest {
 impl XMLHttpRequestDerived for EventTarget {
     fn is_xmlhttprequest(&self) -> bool {
         match *self.type_id() {
-            XMLHttpRequestTargetTypeId(XMLHttpRequestTypeId) => true,
+            EventTargetTypeId::XMLHttpRequestEventTarget(XMLHttpRequestEventTargetTypeId::XMLHttpRequest) => true,
             _ => false
         }
     }
@@ -815,7 +814,8 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
         let global = self.global.root();
         let event = Event::new(global.root_ref(),
                                "readystatechange".to_string(),
-                               DoesNotBubble, Cancelable).root();
+                               EventBubbles::DoesNotBubble,
+                               EventCancelable::Cancelable).root();
         let target: JSRef<EventTarget> = EventTargetCast::from_ref(self);
         target.dispatch_event(*event);
     }
@@ -859,7 +859,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
                 // Substep 2
                 status.map(|RawStatus(code, reason)| {
                     self.status.set(code);
-                    *self.status_text.borrow_mut() = ByteString::new(reason.into_bytes());
+                    *self.status_text.borrow_mut() = ByteString::new(format!("{}", reason).into_bytes());
                 });
                 headers.as_ref().map(|h| *self.response_headers.borrow_mut() = h.clone());
 
@@ -995,7 +995,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
 
     fn cancel_timeout(self) {
         // oneshot() closes the previous channel, canceling the timeout
-        self.timer.borrow_mut().oneshot(Zero::zero());
+        self.timer.borrow_mut().oneshot(Duration::zero());
     }
 
     fn text_response(self) -> DOMString {
@@ -1013,7 +1013,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
 
         // According to Simon, decode() should never return an error, so unwrap()ing
         // the result should be fine. XXXManishearth have a closer look at this later
-        encoding.decode(self.response.borrow().as_slice(), DecodeReplace).unwrap().to_string()
+        encoding.decode(self.response.borrow().as_slice(), DecoderTrap::Replace).unwrap().to_string()
     }
     fn filter_response_headers(self) -> Headers {
         // http://fetch.spec.whatwg.org/#concept-response-header-list
@@ -1055,7 +1055,7 @@ impl Extractable for SendParam {
         // http://fetch.spec.whatwg.org/#concept-fetchbodyinit-extract
         let encoding = UTF_8 as EncodingRef;
         match *self {
-            eString(ref s) => encoding.encode(s.as_slice(), EncodeReplace).unwrap(),
+            eString(ref s) => encoding.encode(s.as_slice(), EncoderTrap::Replace).unwrap(),
             eURLSearchParams(ref usp) => usp.root().serialize(None) // Default encoding is UTF8
         }
     }
diff --git a/components/script/dom/xmlhttprequesteventtarget.rs b/components/script/dom/xmlhttprequesteventtarget.rs
index 0510a37bfbb..231cf1e0d4a 100644
--- a/components/script/dom/xmlhttprequesteventtarget.rs
+++ b/components/script/dom/xmlhttprequesteventtarget.rs
@@ -8,8 +8,14 @@ use dom::bindings::codegen::InheritTypes::EventTargetCast;
 use dom::bindings::codegen::InheritTypes::XMLHttpRequestEventTargetDerived;
 use dom::bindings::js::JSRef;
 use dom::bindings::utils::{Reflectable, Reflector};
-use dom::eventtarget::{EventTarget, EventTargetHelpers, XMLHttpRequestTargetTypeId};
-use dom::xmlhttprequest::XMLHttpRequestId;
+use dom::eventtarget::{EventTarget, EventTargetHelpers, EventTargetTypeId};
+
+#[deriving(PartialEq)]
+#[jstraceable]
+pub enum XMLHttpRequestEventTargetTypeId {
+    XMLHttpRequest,
+    XMLHttpRequestUpload,
+}
 
 #[dom_struct]
 pub struct XMLHttpRequestEventTarget {
@@ -17,9 +23,9 @@ pub struct XMLHttpRequestEventTarget {
 }
 
 impl XMLHttpRequestEventTarget {
-    pub fn new_inherited(type_id: XMLHttpRequestId) -> XMLHttpRequestEventTarget {
+    pub fn new_inherited(type_id: XMLHttpRequestEventTargetTypeId) -> XMLHttpRequestEventTarget {
         XMLHttpRequestEventTarget {
-            eventtarget: EventTarget::new_inherited(XMLHttpRequestTargetTypeId(type_id))
+            eventtarget: EventTarget::new_inherited(EventTargetTypeId::XMLHttpRequestEventTarget(type_id))
         }
     }
 
@@ -31,7 +37,7 @@ impl XMLHttpRequestEventTarget {
 impl XMLHttpRequestEventTargetDerived for EventTarget {
     fn is_xmlhttprequesteventtarget(&self) -> bool {
         match *self.type_id() {
-            XMLHttpRequestTargetTypeId(_) => true,
+            EventTargetTypeId::XMLHttpRequestEventTarget(_) => true,
             _ => false
         }
     }
diff --git a/components/script/dom/xmlhttprequestupload.rs b/components/script/dom/xmlhttprequestupload.rs
index 1b21eb35548..2af3245689a 100644
--- a/components/script/dom/xmlhttprequestupload.rs
+++ b/components/script/dom/xmlhttprequestupload.rs
@@ -7,9 +7,9 @@ use dom::bindings::codegen::Bindings::XMLHttpRequestUploadBinding;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Temporary;
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
-use dom::eventtarget::{EventTarget, XMLHttpRequestTargetTypeId};
-use dom::xmlhttprequest::{XMLHttpRequestUploadTypeId};
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::xmlhttprequesteventtarget::XMLHttpRequestEventTarget;
+use dom::xmlhttprequesteventtarget::XMLHttpRequestEventTargetTypeId;
 
 #[dom_struct]
 pub struct XMLHttpRequestUpload {
@@ -19,7 +19,7 @@ pub struct XMLHttpRequestUpload {
 impl XMLHttpRequestUpload {
     fn new_inherited() -> XMLHttpRequestUpload {
         XMLHttpRequestUpload {
-            eventtarget:XMLHttpRequestEventTarget::new_inherited(XMLHttpRequestUploadTypeId)
+            eventtarget: XMLHttpRequestEventTarget::new_inherited(XMLHttpRequestEventTargetTypeId::XMLHttpRequestUpload)
         }
     }
     pub fn new(global: GlobalRef) -> Temporary<XMLHttpRequestUpload> {
@@ -36,6 +36,6 @@ impl Reflectable for XMLHttpRequestUpload {
 
 impl XMLHttpRequestUploadDerived for EventTarget {
     fn is_xmlhttprequestupload(&self) -> bool {
-        *self.type_id() == XMLHttpRequestTargetTypeId(XMLHttpRequestUploadTypeId)
+        *self.type_id() == EventTargetTypeId::XMLHttpRequestEventTarget(XMLHttpRequestEventTargetTypeId::XMLHttpRequestUpload)
     }
 }