Generate all Derived implementations in codegen

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

@@ -5880,6 +5880,20 @@ impl %(name)sCast {
                 hierarchy[descriptor.getParentName()].append(name)
                 # Define a `FooDerived` trait for superclasses to implement,
                 # as well as the `FooCast::to_*` methods that use it.
+                baseName = descriptor.prototypeChain[0]
+                typeIdPat = descriptor.prototypeChain[-1]
+                if upcast:
+                    typeIdPat += "(_)"
+                for base in reversed(descriptor.prototypeChain[1:-1]):
+                    typeIdPat = "%s(%sTypeId::%s)" % (base, base, typeIdPat)
+                typeIdPat = "%sTypeId::%s" % (baseName, typeIdPat)
+                args = {
+                    'baseName': baseName,
+                    'derivedTrait': name + 'Derived',
+                    'methodName': 'is_' + name.lower(),
+                    'name': name,
+                    'typeIdPat': typeIdPat,
+                }
                 allprotos.append(CGGeneric("""\
 /// Types which `%(name)s` derives from
 pub trait %(derivedTrait)s: Sized {
@@ -5917,7 +5931,16 @@ impl %(name)sCast {
     }
 }
 
-""" % {'derivedTrait': name + 'Derived', 'name': name, 'methodName': 'is_' + name.lower()}))
+impl %(derivedTrait)s for %(baseName)s {
+    fn %(methodName)s(&self) -> bool {
+        match *self.type_id() {
+            %(typeIdPat)s => true,
+            _ => false,
+        }
+    }
+}
+
+""" % args))
 
             # Implement the `FooDerived` trait for non-root superclasses by deferring to
             # the direct superclass. This leaves the implementation of the `FooDerived`

components/script/dom/blob.rs

@@ -4,7 +4,6 @@
 
 use dom::bindings::codegen::Bindings::BlobBinding;
 use dom::bindings::codegen::Bindings::BlobBinding::BlobMethods;
-use dom::bindings::codegen::InheritTypes::{BlobTypeId, FileDerived};
 use dom::bindings::error::Fallible;
 use dom::bindings::global::{GlobalField, GlobalRef};
 use dom::bindings::js::Root;
@@ -157,9 +156,3 @@ impl BlobMethods for Blob {
 
     }
 }
-
-impl FileDerived for Blob {
-    fn is_file(&self) -> bool {
-        *self.type_id() == BlobTypeId::File
-    }
-}

components/script/dom/characterdata.rs

@@ -6,15 +6,13 @@
 
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::CharacterDataBinding::CharacterDataMethods;
-use dom::bindings::codegen::InheritTypes::{CharacterDataDerived, CharacterDataTypeId};
+use dom::bindings::codegen::InheritTypes::{CharacterDataTypeId, ElementCast};
-use dom::bindings::codegen::InheritTypes::{ElementCast, EventTargetTypeId};
 use dom::bindings::codegen::InheritTypes::{NodeCast, NodeTypeId};
 use dom::bindings::codegen::UnionTypes::NodeOrString;
 use dom::bindings::error::{Error, ErrorResult, Fallible};
 use dom::bindings::js::{LayoutJS, Root};
 use dom::document::Document;
 use dom::element::Element;
-use dom::eventtarget::EventTarget;
 use dom::node::{Node, NodeDamage};
 use std::borrow::ToOwned;
 use std::cell::Ref;
@@ -27,15 +25,6 @@ pub struct CharacterData {
     data: DOMRefCell<DOMString>,
 }
 
-impl CharacterDataDerived for EventTarget {
-    fn is_characterdata(&self) -> bool {
-        match *self.type_id() {
-            EventTargetTypeId::Node(NodeTypeId::CharacterData(_)) => true,
-            _ => false
-        }
-    }
-}
-
 impl CharacterData {
     pub fn new_inherited(id: CharacterDataTypeId, data: DOMString, document: &Document) -> CharacterData {
         CharacterData {

components/script/dom/comment.rs

@@ -4,14 +4,12 @@
 
 use dom::bindings::codegen::Bindings::CommentBinding;
 use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
-use dom::bindings::codegen::InheritTypes::{CharacterDataTypeId, CommentDerived};
+use dom::bindings::codegen::InheritTypes::CharacterDataTypeId;
-use dom::bindings::codegen::InheritTypes::{EventTargetTypeId, NodeTypeId};
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::characterdata::CharacterData;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::node::Node;
 use util::str::DOMString;
 
@@ -21,12 +19,6 @@ pub struct Comment {
     characterdata: CharacterData,
 }
 
-impl CommentDerived for EventTarget {
-    fn is_comment(&self) -> bool {
-        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::CharacterData(CharacterDataTypeId::Comment))
-    }
-}
-
 impl Comment {
     fn new_inherited(text: DOMString, document: &Document) -> Comment {
         Comment {

components/script/dom/customevent.rs

@@ -5,7 +5,7 @@
 use dom::bindings::codegen::Bindings::CustomEventBinding;
 use dom::bindings::codegen::Bindings::CustomEventBinding::CustomEventMethods;
 use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
-use dom::bindings::codegen::InheritTypes::{CustomEventDerived, EventCast, EventTypeId};
+use dom::bindings::codegen::InheritTypes::EventCast;
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{MutHeapJSVal, Root};
@@ -23,12 +23,6 @@ pub struct CustomEvent {
     detail: MutHeapJSVal,
 }
 
-impl CustomEventDerived for Event {
-    fn is_customevent(&self) -> bool {
-        *self.type_id() == EventTypeId::CustomEvent
-    }
-}
-
 impl CustomEvent {
     fn new_inherited() -> CustomEvent {
         CustomEvent {

components/script/dom/dedicatedworkerglobalscope.rs

@@ -8,16 +8,13 @@ use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::DedicatedWorkerGlobalScopeBinding;
 use dom::bindings::codegen::Bindings::DedicatedWorkerGlobalScopeBinding::DedicatedWorkerGlobalScopeMethods;
 use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
-use dom::bindings::codegen::InheritTypes::DedicatedWorkerGlobalScopeDerived;
+use dom::bindings::codegen::InheritTypes::{EventTargetCast, WorkerGlobalScopeCast};
-use dom::bindings::codegen::InheritTypes::{EventTargetCast, EventTargetTypeId};
-use dom::bindings::codegen::InheritTypes::{WorkerGlobalScopeCast, WorkerGlobalScopeTypeId};
 use dom::bindings::error::ErrorResult;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{Root, RootCollection};
 use dom::bindings::refcounted::LiveDOMReferences;
 use dom::bindings::structuredclone::StructuredCloneData;
 use dom::bindings::utils::Reflectable;
-use dom::eventtarget::EventTarget;
 use dom::messageevent::MessageEvent;
 use dom::worker::{SimpleWorkerErrorHandler, TrustedWorkerAddress, WorkerMessageHandler};
 use dom::workerglobalscope::WorkerGlobalScope;
@@ -357,12 +354,3 @@ impl DedicatedWorkerGlobalScopeMethods for DedicatedWorkerGlobalScope {
     // https://html.spec.whatwg.org/multipage/#handler-dedicatedworkerglobalscope-onmessage
     event_handler!(message, GetOnmessage, SetOnmessage);
 }
-
-impl DedicatedWorkerGlobalScopeDerived for EventTarget {
-    fn is_dedicatedworkerglobalscope(&self) -> bool {
-        match *self.type_id() {
-            EventTargetTypeId::WorkerGlobalScope(WorkerGlobalScopeTypeId::DedicatedWorkerGlobalScope) => true,
-            _ => false
-        }
-    }
-}

components/script/dom/document.rs

@@ -16,7 +16,7 @@ use dom::bindings::codegen::Bindings::PerformanceBinding::PerformanceMethods;
 use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
 use dom::bindings::codegen::InheritTypes::{DocumentDerived, DocumentTypeCast, ElementCast};
 use dom::bindings::codegen::InheritTypes::{ElementDerived, ElementTypeId};
-use dom::bindings::codegen::InheritTypes::{EventCast, EventTargetCast, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::{EventCast, EventTargetCast};
 use dom::bindings::codegen::InheritTypes::{HTMLAnchorElementCast, HTMLAnchorElementDerived};
 use dom::bindings::codegen::InheritTypes::{HTMLAppletElementDerived, HTMLAreaElementDerived};
 use dom::bindings::codegen::InheritTypes::{HTMLBaseElementCast, HTMLBodyElementCast};
@@ -163,12 +163,6 @@ impl PartialEq for Document {
     }
 }
 
-impl DocumentDerived for EventTarget {
-    fn is_document(&self) -> bool {
-        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Document)
-    }
-}
-
 #[derive(JSTraceable, HeapSizeOf)]
 struct ImagesFilter;
 impl CollectionFilter for ImagesFilter {

components/script/dom/documentfragment.rs

@@ -5,15 +5,13 @@
 use dom::bindings::codegen::Bindings::DocumentFragmentBinding;
 use dom::bindings::codegen::Bindings::DocumentFragmentBinding::DocumentFragmentMethods;
 use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
-use dom::bindings::codegen::InheritTypes::{DocumentFragmentDerived, ElementCast};
+use dom::bindings::codegen::InheritTypes::{ElementCast, NodeCast, NodeTypeId};
-use dom::bindings::codegen::InheritTypes::{EventTargetTypeId, NodeCast, NodeTypeId};
 use dom::bindings::codegen::UnionTypes::NodeOrString;
 use dom::bindings::error::{ErrorResult, Fallible};
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::document::Document;
 use dom::element::Element;
-use dom::eventtarget::EventTarget;
 use dom::htmlcollection::HTMLCollection;
 use dom::node::{Node, window_from_node};
 use dom::nodelist::NodeList;
@@ -26,12 +24,6 @@ pub struct DocumentFragment {
     node: Node,
 }
 
-impl DocumentFragmentDerived for EventTarget {
-    fn is_documentfragment(&self) -> bool {
-        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::DocumentFragment)
-    }
-}
-
 impl DocumentFragment {
     /// Creates a new DocumentFragment.
     fn new_inherited(document: &Document) -> DocumentFragment {

components/script/dom/documenttype.rs

@@ -4,13 +4,11 @@
 
 use dom::bindings::codegen::Bindings::DocumentTypeBinding;
 use dom::bindings::codegen::Bindings::DocumentTypeBinding::DocumentTypeMethods;
-use dom::bindings::codegen::InheritTypes::{DocumentTypeDerived, EventTargetTypeId};
 use dom::bindings::codegen::InheritTypes::{NodeCast, NodeTypeId};
 use dom::bindings::codegen::UnionTypes::NodeOrString;
 use dom::bindings::error::ErrorResult;
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::node::Node;
 use std::borrow::ToOwned;
 use util::str::DOMString;
@@ -25,12 +23,6 @@ pub struct DocumentType {
     system_id: DOMString,
 }
 
-impl DocumentTypeDerived for EventTarget {
-    fn is_documenttype(&self) -> bool {
-        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::DocumentType)
-    }
-}
-
 impl DocumentType {
     fn new_inherited(name: DOMString,
                          public_id: Option<DOMString>,

components/script/dom/element.rs

@@ -20,8 +20,7 @@ use dom::bindings::codegen::Bindings::HTMLTemplateElementBinding::HTMLTemplateEl
 use dom::bindings::codegen::Bindings::NamedNodeMapBinding::NamedNodeMapMethods;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
 use dom::bindings::codegen::InheritTypes::{CharacterDataCast, DocumentDerived, ElementCast};
-use dom::bindings::codegen::InheritTypes::{ElementDerived, ElementTypeId};
+use dom::bindings::codegen::InheritTypes::{ElementDerived, ElementTypeId, EventTargetCast};
-use dom::bindings::codegen::InheritTypes::{EventTargetCast, EventTargetTypeId};
 use dom::bindings::codegen::InheritTypes::{HTMLAnchorElementCast, HTMLBodyElementCast};
 use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, HTMLFontElementCast};
 use dom::bindings::codegen::InheritTypes::{HTMLIFrameElementCast, HTMLInputElementCast};
@@ -41,7 +40,6 @@ use dom::domrect::DOMRect;
 use dom::domrectlist::DOMRectList;
 use dom::domtokenlist::DOMTokenList;
 use dom::event::Event;
-use dom::eventtarget::EventTarget;
 use dom::htmlcollection::HTMLCollection;
 use dom::htmlinputelement::{HTMLInputElement, RawLayoutHTMLInputElementHelpers};
 use dom::htmltablecellelement::HTMLTableCellElementLayoutHelpers;
@@ -91,16 +89,6 @@ pub struct Element {
     class_list: MutNullableHeap<JS<DOMTokenList>>,
 }
 
-impl ElementDerived for EventTarget {
-    #[inline]
-    fn is_element(&self) -> bool {
-        match *self.type_id() {
-            EventTargetTypeId::Node(NodeTypeId::Element(_)) => true,
-            _ => false
-        }
-    }
-}
-
 impl PartialEq for Element {
     fn eq(&self, other: &Element) -> bool {
         self as *const Element == &*other

components/script/dom/errorevent.rs

@@ -6,7 +6,7 @@ use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::ErrorEventBinding;
 use dom::bindings::codegen::Bindings::ErrorEventBinding::ErrorEventMethods;
 use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
-use dom::bindings::codegen::InheritTypes::{ErrorEventDerived, EventCast, EventTypeId};
+use dom::bindings::codegen::InheritTypes::EventCast;
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{MutHeapJSVal, Root};
@@ -30,12 +30,6 @@ pub struct ErrorEvent {
     error: MutHeapJSVal,
 }
 
-impl ErrorEventDerived for Event {
-    fn is_errorevent(&self) -> bool {
-        *self.type_id() == EventTypeId::ErrorEvent
-    }
-}
-
 impl ErrorEvent {
     fn new_inherited() -> ErrorEvent {
         ErrorEvent {

components/script/dom/htmlanchorelement.rs

@@ -10,10 +10,9 @@ use dom::bindings::codegen::Bindings::HTMLAnchorElementBinding;
 use dom::bindings::codegen::Bindings::HTMLAnchorElementBinding::HTMLAnchorElementMethods;
 use dom::bindings::codegen::Bindings::MouseEventBinding::MouseEventMethods;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, ElementTypeId, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLAnchorElementDerived, HTMLElementCast};
 use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, HTMLImageElementDerived};
-use dom::bindings::codegen::InheritTypes::{MouseEventCast, NodeCast, NodeTypeId};
+use dom::bindings::codegen::InheritTypes::{MouseEventCast, NodeCast};
 use dom::bindings::js::{JS, MutNullableHeap, Root};
 use dom::document::Document;
 use dom::domtokenlist::DOMTokenList;
@@ -35,14 +34,6 @@ pub struct HTMLAnchorElement {
     rel_list: MutNullableHeap<JS<DOMTokenList>>,
 }
 
-impl HTMLAnchorElementDerived for EventTarget {
-    fn is_htmlanchorelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLAnchorElement)))
-    }
-}
-
 impl HTMLAnchorElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmlappletelement.rs

@@ -5,12 +5,9 @@
 use dom::attr::AttrValue;
 use dom::bindings::codegen::Bindings::HTMLAppletElementBinding;
 use dom::bindings::codegen::Bindings::HTMLAppletElementBinding::HTMLAppletElementMethods;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLElementTypeId};
-use dom::bindings::codegen::InheritTypes::{HTMLAppletElementDerived, HTMLElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use dom::virtualmethods::VirtualMethods;
@@ -22,14 +19,6 @@ pub struct HTMLAppletElement {
     htmlelement: HTMLElement
 }
 
-impl HTMLAppletElementDerived for EventTarget {
-    fn is_htmlappletelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLAppletElement)))
-    }
-}
-
 impl HTMLAppletElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmlareaelement.rs

@@ -5,14 +5,11 @@
 use dom::attr::AttrValue;
 use dom::bindings::codegen::Bindings::HTMLAreaElementBinding;
 use dom::bindings::codegen::Bindings::HTMLAreaElementBinding::HTMLAreaElementMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, ElementTypeId, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast, HTMLElementTypeId};
-use dom::bindings::codegen::InheritTypes::{HTMLAreaElementDerived, HTMLElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, NodeTypeId};
 use dom::bindings::js::{JS, MutNullableHeap, Root};
 use dom::bindings::utils::Reflectable;
 use dom::document::Document;
 use dom::domtokenlist::DOMTokenList;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use dom::virtualmethods::VirtualMethods;
@@ -26,14 +23,6 @@ pub struct HTMLAreaElement {
     rel_list: MutNullableHeap<JS<DOMTokenList>>,
 }
 
-impl HTMLAreaElementDerived for EventTarget {
-    fn is_htmlareaelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLAreaElement)))
-    }
-}
-
 impl HTMLAreaElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: &Document) -> HTMLAreaElement {
         HTMLAreaElement {

components/script/dom/htmlaudioelement.rs

@@ -3,12 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLAudioElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLMediaElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLAudioElementDerived, HTMLElementTypeId};
-use dom::bindings::codegen::InheritTypes::{HTMLMediaElementTypeId, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlmediaelement::HTMLMediaElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -18,15 +15,6 @@ pub struct HTMLAudioElement {
     htmlmediaelement: HTMLMediaElement
 }
 
-impl HTMLAudioElementDerived for EventTarget {
-    fn is_htmlaudioelement(&self) -> bool {
-        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(
-                                                   ElementTypeId::HTMLElement(
-                                                   HTMLElementTypeId::HTMLMediaElement(
-                                                   HTMLMediaElementTypeId::HTMLAudioElement))))
-    }
-}
-
 impl HTMLAudioElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmlbaseelement.rs

@@ -4,13 +4,10 @@
 
 use dom::attr::Attr;
 use dom::bindings::codegen::Bindings::HTMLBaseElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementCast, ElementTypeId, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast, HTMLElementTypeId};
-use dom::bindings::codegen::InheritTypes::{HTMLBaseElementDerived, HTMLElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
 use dom::element::AttributeMutation;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::{Node, document_from_node};
 use dom::virtualmethods::VirtualMethods;
@@ -22,14 +19,6 @@ pub struct HTMLBaseElement {
     htmlelement: HTMLElement
 }
 
-impl HTMLBaseElementDerived for EventTarget {
-    fn is_htmlbaseelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLBaseElement)))
-    }
-}
-
 impl HTMLBaseElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: &Document) -> HTMLBaseElement {
         HTMLBaseElement {

components/script/dom/htmlbodyelement.rs

@@ -8,15 +8,12 @@ use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
 use dom::bindings::codegen::Bindings::HTMLBodyElementBinding::{self, HTMLBodyElementMethods};
 use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, ElementTypeId};
+use dom::bindings::codegen::InheritTypes::{ElementCast, EventTargetCast};
-use dom::bindings::codegen::InheritTypes::{EventTargetCast, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLElementTypeId};
-use dom::bindings::codegen::InheritTypes::{HTMLBodyElementDerived, HTMLElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::bindings::utils::Reflectable;
 use dom::document::Document;
 use dom::element::{AttributeMutation, RawLayoutElementHelpers};
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::{Node, document_from_node, window_from_node};
 use dom::virtualmethods::VirtualMethods;
@@ -41,13 +38,6 @@ pub struct HTMLBodyElement {
     background: DOMRefCell<Option<Url>>
 }
 
-impl HTMLBodyElementDerived for EventTarget {
-    fn is_htmlbodyelement(&self) -> bool {
-        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(
-                    HTMLElementTypeId::HTMLBodyElement)))
-    }
-}
-
 impl HTMLBodyElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: &Document)
                      -> HTMLBodyElement {

components/script/dom/htmlbrelement.rs

@@ -3,11 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLBRElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLBRElementDerived, HTMLElementTypeId, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -17,14 +15,6 @@ pub struct HTMLBRElement {
     htmlelement: HTMLElement,
 }
 
-impl HTMLBRElementDerived for EventTarget {
-    fn is_htmlbrelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLBRElement)))
-    }
-}
-
 impl HTMLBRElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: &Document) -> HTMLBRElement {
         HTMLBRElement {

components/script/dom/htmlbuttonelement.rs

@@ -6,10 +6,9 @@ use dom::activation::Activatable;
 use dom::attr::Attr;
 use dom::bindings::codegen::Bindings::HTMLButtonElementBinding;
 use dom::bindings::codegen::Bindings::HTMLButtonElementBinding::HTMLButtonElementMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, ElementTypeId, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLButtonElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLButtonElementCast, HTMLButtonElementDerived};
 use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLElementTypeId};
-use dom::bindings::codegen::InheritTypes::{HTMLFieldSetElementDerived, NodeCast, NodeTypeId};
+use dom::bindings::codegen::InheritTypes::{HTMLFieldSetElementDerived, NodeCast};
 use dom::bindings::js::Root;
 use dom::document::Document;
 use dom::element::{AttributeMutation, Element};
@@ -42,14 +41,6 @@ pub struct HTMLButtonElement {
     button_type: Cell<ButtonType>
 }
 
-impl HTMLButtonElementDerived for EventTarget {
-    fn is_htmlbuttonelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLButtonElement)))
-    }
-}
-
 impl HTMLButtonElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmlcanvaselement.rs

@@ -7,9 +7,7 @@ use dom::attr::Attr;
 use dom::bindings::codegen::Bindings::HTMLCanvasElementBinding;
 use dom::bindings::codegen::Bindings::HTMLCanvasElementBinding::HTMLCanvasElementMethods;
 use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLContextAttributes;
-use dom::bindings::codegen::InheritTypes::{ElementCast, ElementTypeId, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast, HTMLElementTypeId};
-use dom::bindings::codegen::InheritTypes::{HTMLCanvasElementDerived, HTMLElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, NodeTypeId};
 use dom::bindings::codegen::UnionTypes::CanvasRenderingContext2DOrWebGLRenderingContext;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{HeapGCValue, JS, LayoutJS, MutNullableHeap, Root};
@@ -17,7 +15,6 @@ use dom::bindings::utils::{Reflectable};
 use dom::canvasrenderingcontext2d::{CanvasRenderingContext2D, LayoutCanvasRenderingContext2DHelpers};
 use dom::document::Document;
 use dom::element::AttributeMutation;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::{Node, window_from_node};
 use dom::virtualmethods::VirtualMethods;
@@ -57,14 +54,6 @@ impl PartialEq for HTMLCanvasElement {
     }
 }
 
-impl HTMLCanvasElementDerived for EventTarget {
-    fn is_htmlcanvaselement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLCanvasElement)))
-    }
-}
-
 impl HTMLCanvasElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmldataelement.rs

@@ -3,11 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLDataElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLDataElementDerived, HTMLElementTypeId, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -17,14 +15,6 @@ pub struct HTMLDataElement {
     htmlelement: HTMLElement
 }
 
-impl HTMLDataElementDerived for EventTarget {
-    fn is_htmldataelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLDataElement)))
-    }
-}
-
 impl HTMLDataElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmldatalistelement.rs

@@ -4,13 +4,10 @@
 
 use dom::bindings::codegen::Bindings::HTMLDataListElementBinding;
 use dom::bindings::codegen::Bindings::HTMLDataListElementBinding::HTMLDataListElementMethods;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, HTMLOptionElementDerived, NodeCast};
-use dom::bindings::codegen::InheritTypes::{HTMLDataListElementDerived, HTMLElementTypeId};
-use dom::bindings::codegen::InheritTypes::{HTMLOptionElementDerived, NodeCast, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
 use dom::element::Element;
-use dom::eventtarget::EventTarget;
 use dom::htmlcollection::{CollectionFilter, HTMLCollection};
 use dom::htmlelement::HTMLElement;
 use dom::node::{Node, window_from_node};
@@ -21,14 +18,6 @@ pub struct HTMLDataListElement {
     htmlelement: HTMLElement
 }
 
-impl HTMLDataListElementDerived for EventTarget {
-    fn is_htmldatalistelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLDataListElement)))
-    }
-}
-
 impl HTMLDataListElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmldialogelement.rs

@@ -5,11 +5,9 @@
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::HTMLDialogElementBinding;
 use dom::bindings::codegen::Bindings::HTMLDialogElementBinding::HTMLDialogElementMethods;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLDialogElementDerived, HTMLElementTypeId, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use std::borrow::ToOwned;
@@ -21,14 +19,6 @@ pub struct HTMLDialogElement {
     return_value: DOMRefCell<DOMString>,
 }
 
-impl HTMLDialogElementDerived for EventTarget {
-    fn is_htmldialogelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLDialogElement)))
-    }
-}
-
 impl HTMLDialogElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmldirectoryelement.rs

@@ -3,11 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLDirectoryElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLDirectoryElementDerived, HTMLElementTypeId, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -17,14 +15,6 @@ pub struct HTMLDirectoryElement {
     htmlelement: HTMLElement
 }
 
-impl HTMLDirectoryElementDerived for EventTarget {
-    fn is_htmldirectoryelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLDirectoryElement)))
-    }
-}
-
 impl HTMLDirectoryElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmldivelement.rs

@@ -3,11 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLDivElementBinding::{self, HTMLDivElementMethods};
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLDivElementDerived, HTMLElementTypeId, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -17,14 +15,6 @@ pub struct HTMLDivElement {
     htmlelement: HTMLElement
 }
 
-impl HTMLDivElementDerived for EventTarget {
-    fn is_htmldivelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLDivElement)))
-    }
-}
-
 impl HTMLDivElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmldlistelement.rs

@@ -3,11 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLDListElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLDListElementDerived, HTMLElementTypeId, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -17,14 +15,6 @@ pub struct HTMLDListElement {
     htmlelement: HTMLElement
 }
 
-impl HTMLDListElementDerived for EventTarget {
-    fn is_htmldlistelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLDListElement)))
-    }
-}
-
 impl HTMLDListElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: &Document) -> HTMLDListElement {
         HTMLDListElement {

components/script/dom/htmlelement.rs

@@ -10,8 +10,7 @@ use dom::bindings::codegen::Bindings::HTMLElementBinding::HTMLElementMethods;
 use dom::bindings::codegen::Bindings::HTMLInputElementBinding::HTMLInputElementMethods;
 use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
 use dom::bindings::codegen::InheritTypes::{ElementCast, ElementTypeId};
-use dom::bindings::codegen::InheritTypes::{EventTargetCast, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::{EventTargetCast, HTMLBodyElementDerived};
-use dom::bindings::codegen::InheritTypes::{HTMLBodyElementDerived, HTMLElementDerived};
 use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, HTMLFrameSetElementDerived};
 use dom::bindings::codegen::InheritTypes::{HTMLHtmlElementDerived, HTMLInputElementCast};
 use dom::bindings::codegen::InheritTypes::{NodeCast, NodeTypeId};
@@ -22,7 +21,6 @@ use dom::cssstyledeclaration::{CSSModificationAccess, CSSStyleDeclaration};
 use dom::document::Document;
 use dom::domstringmap::DOMStringMap;
 use dom::element::{AttributeMutation, Element};
-use dom::eventtarget::EventTarget;
 use dom::htmlinputelement::HTMLInputElement;
 use dom::node::{Node, SEQUENTIALLY_FOCUSABLE, document_from_node, window_from_node};
 use dom::virtualmethods::VirtualMethods;
@@ -47,15 +45,6 @@ impl PartialEq for HTMLElement {
     }
 }
 
-impl HTMLElementDerived for EventTarget {
-    fn is_htmlelement(&self) -> bool {
-        match *self.type_id() {
-            EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(_))) => true,
-            _ => false
-        }
-    }
-}
-
 impl HTMLElement {
     pub fn new_inherited(type_id: HTMLElementTypeId,
                          tag_name: DOMString,

components/script/dom/htmlembedelement.rs

@@ -3,11 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLEmbedElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, HTMLEmbedElementDerived, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -17,14 +15,6 @@ pub struct HTMLEmbedElement {
     htmlelement: HTMLElement
 }
 
-impl HTMLEmbedElementDerived for EventTarget {
-    fn is_htmlembedelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLEmbedElement)))
-    }
-}
-
 impl HTMLEmbedElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: &Document) -> HTMLEmbedElement {
         HTMLEmbedElement {

components/script/dom/htmlfieldsetelement.rs

@@ -5,13 +5,12 @@
 use dom::attr::Attr;
 use dom::bindings::codegen::Bindings::HTMLFieldSetElementBinding;
 use dom::bindings::codegen::Bindings::HTMLFieldSetElementBinding::HTMLFieldSetElementMethods;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId, HTMLElementCast};
+use dom::bindings::codegen::InheritTypes::{ElementTypeId, HTMLElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, HTMLFieldSetElementDerived};
+use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, HTMLLegendElementDerived};
-use dom::bindings::codegen::InheritTypes::{HTMLLegendElementDerived, NodeCast, NodeTypeId};
+use dom::bindings::codegen::InheritTypes::{NodeCast, NodeTypeId};
 use dom::bindings::js::{Root, RootedReference};
 use dom::document::Document;
 use dom::element::{AttributeMutation, Element};
-use dom::eventtarget::EventTarget;
 use dom::htmlcollection::{CollectionFilter, HTMLCollection};
 use dom::htmlelement::HTMLElement;
 use dom::htmlformelement::{FormControl, HTMLFormElement};
@@ -25,14 +24,6 @@ pub struct HTMLFieldSetElement {
     htmlelement: HTMLElement
 }
 
-impl HTMLFieldSetElementDerived for EventTarget {
-    fn is_htmlfieldsetelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLFieldSetElement)))
-    }
-}
-
 impl HTMLFieldSetElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmlfontelement.rs

@@ -7,13 +7,10 @@ use dom::attr::{Attr, AttrValue};
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::HTMLFontElementBinding;
 use dom::bindings::codegen::Bindings::HTMLFontElementBinding::HTMLFontElementMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, ElementTypeId, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast, HTMLElementTypeId};
-use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLElementTypeId};
-use dom::bindings::codegen::InheritTypes::{HTMLFontElementDerived, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
 use dom::element::{AttributeMutation, RawLayoutElementHelpers};
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use dom::virtualmethods::VirtualMethods;
@@ -29,13 +26,6 @@ pub struct HTMLFontElement {
     face: DOMRefCell<Option<Atom>>,
 }
 
-impl HTMLFontElementDerived for EventTarget {
-    fn is_htmlfontelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLFontElement)))
-    }
-}
 
 impl HTMLFontElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: &Document) -> HTMLFontElement {

components/script/dom/htmlformelement.rs

@@ -9,19 +9,18 @@ use dom::bindings::codegen::Bindings::HTMLButtonElementBinding::HTMLButtonElemen
 use dom::bindings::codegen::Bindings::HTMLFormElementBinding;
 use dom::bindings::codegen::Bindings::HTMLFormElementBinding::HTMLFormElementMethods;
 use dom::bindings::codegen::Bindings::HTMLInputElementBinding::HTMLInputElementMethods;
-use dom::bindings::codegen::InheritTypes::{ElementBase, ElementCast, ElementTypeId};
+use dom::bindings::codegen::InheritTypes::{ElementBase, ElementCast};
-use dom::bindings::codegen::InheritTypes::{EventTargetCast, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetCast};
 use dom::bindings::codegen::InheritTypes::{HTMLDataListElementCast, HTMLElementCast};
 use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, HTMLFormElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLFormElementDerived, HTMLInputElementCast};
+use dom::bindings::codegen::InheritTypes::{HTMLInputElementCast, HTMLTextAreaElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLTextAreaElementCast, NodeCast, NodeTypeId};
+use dom::bindings::codegen::InheritTypes::{NodeCast, NodeTypeId};
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{Root};
 use dom::bindings::utils::Reflectable;
 use dom::document::Document;
 use dom::element::Element;
 use dom::event::{Event, EventBubbles, EventCancelable};
-use dom::eventtarget::EventTarget;
 use dom::htmlbuttonelement::{HTMLButtonElement};
 use dom::htmlelement::HTMLElement;
 use dom::htmlinputelement::HTMLInputElement;
@@ -51,14 +50,6 @@ impl PartialEq for HTMLFormElement {
     }
 }
 
-impl HTMLFormElementDerived for EventTarget {
-    fn is_htmlformelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLFormElement)))
-    }
-}
-
 impl HTMLFormElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmlframeelement.rs

@@ -3,11 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLFrameElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, HTMLFrameElementDerived, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -17,14 +15,6 @@ pub struct HTMLFrameElement {
     htmlelement: HTMLElement
 }
 
-impl HTMLFrameElementDerived for EventTarget {
-    fn is_htmlframeelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLFrameElement)))
-    }
-}
-
 impl HTMLFrameElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: &Document) -> HTMLFrameElement {
         HTMLFrameElement {

components/script/dom/htmlframesetelement.rs

@@ -3,11 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLFrameSetElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, HTMLFrameSetElementDerived, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -17,14 +15,6 @@ pub struct HTMLFrameSetElement {
     htmlelement: HTMLElement
 }
 
-impl HTMLFrameSetElementDerived for EventTarget {
-    fn is_htmlframesetelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLFrameSetElement)))
-    }
-}
-
 impl HTMLFrameSetElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmlheadelement.rs

@@ -3,12 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLHeadElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId};
 use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLElementTypeId};
-use dom::bindings::codegen::InheritTypes::{HTMLHeadElementDerived, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use dom::userscripts::load_script;
@@ -20,14 +17,6 @@ pub struct HTMLHeadElement {
     htmlelement: HTMLElement
 }
 
-impl HTMLHeadElementDerived for EventTarget {
-    fn is_htmlheadelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLHeadElement)))
-    }
-}
-
 impl HTMLHeadElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmlheadingelement.rs

@@ -3,11 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLHeadingElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, HTMLHeadingElementDerived, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -28,14 +26,6 @@ pub struct HTMLHeadingElement {
     level: HeadingLevel,
 }
 
-impl HTMLHeadingElementDerived for EventTarget {
-    fn is_htmlheadingelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLHeadingElement)))
-    }
-}
-
 impl HTMLHeadingElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmlhrelement.rs

@@ -3,11 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLHRElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, HTMLHRElementDerived, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -17,14 +15,6 @@ pub struct HTMLHRElement {
     htmlelement: HTMLElement,
 }
 
-impl HTMLHRElementDerived for EventTarget {
-    fn is_htmlhrelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLHRElement)))
-    }
-}
-
 impl HTMLHRElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: &Document) -> HTMLHRElement {
         HTMLHRElement {

components/script/dom/htmlhtmlelement.rs

@@ -3,11 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLHtmlElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, HTMLHtmlElementDerived, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -17,14 +15,6 @@ pub struct HTMLHtmlElement {
     htmlelement: HTMLElement
 }
 
-impl HTMLHtmlElementDerived for EventTarget {
-    fn is_htmlhtmlelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLHtmlElement)))
-    }
-}
-
 impl HTMLHtmlElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: &Document) -> HTMLHtmlElement {
         HTMLHtmlElement {

components/script/dom/htmliframeelement.rs

@@ -6,10 +6,9 @@ use dom::attr::{Attr, AttrHelpersForLayout, AttrValue};
 use dom::bindings::codegen::Bindings::HTMLIFrameElementBinding;
 use dom::bindings::codegen::Bindings::HTMLIFrameElementBinding::HTMLIFrameElementMethods;
 use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, ElementTypeId, EventCast};
+use dom::bindings::codegen::InheritTypes::{ElementCast, EventCast};
-use dom::bindings::codegen::InheritTypes::{EventTargetCast, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::{EventTargetCast, HTMLElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLElementTypeId};
+use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, NodeCast};
-use dom::bindings::codegen::InheritTypes::{HTMLIFrameElementDerived, NodeCast, NodeTypeId};
 use dom::bindings::conversions::ToJSValConvertible;
 use dom::bindings::error::{Error, ErrorResult, Fallible};
 use dom::bindings::global::GlobalRef;
@@ -18,7 +17,6 @@ use dom::bindings::utils::Reflectable;
 use dom::customevent::CustomEvent;
 use dom::document::Document;
 use dom::element::{self, AttributeMutation};
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::{Node, window_from_node};
 use dom::urlhelper::UrlHelper;
@@ -64,16 +62,6 @@ pub struct HTMLIFrameElement {
     sandbox: Cell<Option<u8>>,
 }
 
-impl HTMLIFrameElementDerived for EventTarget {
-    fn is_htmliframeelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLIFrameElement)))
-    }
-}
-
-
-
 impl HTMLIFrameElement {
     pub fn is_sandboxed(&self) -> bool {
         self.sandbox.get().is_some()

components/script/dom/htmlimageelement.rs

@@ -8,10 +8,8 @@ use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::HTMLImageElementBinding;
 use dom::bindings::codegen::Bindings::HTMLImageElementBinding::HTMLImageElementMethods;
 use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, ElementTypeId};
+use dom::bindings::codegen::InheritTypes::{ElementCast, EventTargetCast, HTMLElementCast};
-use dom::bindings::codegen::InheritTypes::{EventTargetCast, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, NodeCast};
-use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLElementTypeId};
-use dom::bindings::codegen::InheritTypes::{HTMLImageElementDerived, NodeCast, NodeTypeId};
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{LayoutJS, Root};
@@ -19,7 +17,6 @@ use dom::bindings::refcounted::Trusted;
 use dom::document::Document;
 use dom::element::AttributeMutation;
 use dom::event::{Event, EventBubbles, EventCancelable};
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::{Node, NodeDamage, document_from_node, window_from_node};
 use dom::virtualmethods::VirtualMethods;
@@ -42,15 +39,6 @@ pub struct HTMLImageElement {
     image: DOMRefCell<Option<Arc<Image>>>,
 }
 
-impl HTMLImageElementDerived for EventTarget {
-    fn is_htmlimageelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLImageElement)))
-    }
-}
-
-
 impl HTMLImageElement {
     pub fn get_url(&self) -> Option<Url>{
         self.url.borrow().clone()

components/script/dom/htmlinputelement.rs

@@ -11,12 +11,10 @@ use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
 use dom::bindings::codegen::Bindings::HTMLInputElementBinding;
 use dom::bindings::codegen::Bindings::HTMLInputElementBinding::HTMLInputElementMethods;
 use dom::bindings::codegen::Bindings::KeyboardEventBinding::KeyboardEventMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, ElementTypeId};
+use dom::bindings::codegen::InheritTypes::{ElementCast, EventTargetCast};
-use dom::bindings::codegen::InheritTypes::{EventTargetCast, EventTargetTypeId};
 use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLElementTypeId};
 use dom::bindings::codegen::InheritTypes::{HTMLFieldSetElementDerived, HTMLInputElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLInputElementDerived, KeyboardEventCast};
+use dom::bindings::codegen::InheritTypes::{KeyboardEventCast, NodeCast};
-use dom::bindings::codegen::InheritTypes::{NodeCast, NodeTypeId};
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, LayoutJS, Root, RootedReference};
 use dom::document::Document;
@@ -105,14 +103,6 @@ impl InputActivationState {
     }
 }
 
-impl HTMLInputElementDerived for EventTarget {
-    fn is_htmlinputelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLInputElement)))
-    }
-}
-
 static DEFAULT_INPUT_SIZE: u32 = 20;
 
 impl HTMLInputElement {

components/script/dom/htmllabelelement.rs

@@ -4,11 +4,9 @@
 
 use dom::bindings::codegen::Bindings::HTMLLabelElementBinding;
 use dom::bindings::codegen::Bindings::HTMLLabelElementBinding::HTMLLabelElementMethods;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId, HTMLElementTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLLabelElementDerived, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::htmlformelement::{FormControl, HTMLFormElement};
 use dom::node::Node;
@@ -19,14 +17,6 @@ pub struct HTMLLabelElement {
     htmlelement: HTMLElement,
 }
 
-impl HTMLLabelElementDerived for EventTarget {
-    fn is_htmllabelelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLLabelElement)))
-    }
-}
-
 impl HTMLLabelElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmllegendelement.rs

@@ -3,11 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLLegendElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId, HTMLElementTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLLegendElementDerived, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -17,14 +15,6 @@ pub struct HTMLLegendElement {
     htmlelement: HTMLElement,
 }
 
-impl HTMLLegendElementDerived for EventTarget {
-    fn is_htmllegendelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLLegendElement)))
-    }
-}
-
 impl HTMLLegendElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmllielement.rs

@@ -3,11 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLLIElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId, HTMLElementTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLLIElementDerived, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -17,14 +15,6 @@ pub struct HTMLLIElement {
     htmlelement: HTMLElement,
 }
 
-impl HTMLLIElementDerived for EventTarget {
-    fn is_htmllielement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLLIElement)))
-    }
-}
-
 impl HTMLLIElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: &Document) -> HTMLLIElement {
         HTMLLIElement {

components/script/dom/htmllinkelement.rs

@@ -8,10 +8,8 @@ use dom::attr::{Attr, AttrValue};
 use dom::bindings::codegen::Bindings::HTMLLinkElementBinding;
 use dom::bindings::codegen::Bindings::HTMLLinkElementBinding::HTMLLinkElementMethods;
 use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, ElementTypeId};
+use dom::bindings::codegen::InheritTypes::{ElementCast, EventTargetCast, HTMLElementCast};
-use dom::bindings::codegen::InheritTypes::{EventTargetCast, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, NodeCast};
-use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLElementTypeId};
-use dom::bindings::codegen::InheritTypes::{HTMLLinkElementDerived, NodeCast, NodeTypeId};
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, MutNullableHeap, Root};
 use dom::bindings::js::{RootedReference};
@@ -20,7 +18,6 @@ use dom::document::Document;
 use dom::domtokenlist::DOMTokenList;
 use dom::element::{AttributeMutation, Element};
 use dom::event::{Event, EventBubbles, EventCancelable};
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::{Node, window_from_node};
 use dom::virtualmethods::VirtualMethods;
@@ -42,14 +39,6 @@ pub struct HTMLLinkElement {
     rel_list: MutNullableHeap<JS<DOMTokenList>>,
 }
 
-impl HTMLLinkElementDerived for EventTarget {
-    fn is_htmllinkelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLLinkElement)))
-    }
-}
-
 impl HTMLLinkElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: &Document) -> HTMLLinkElement {
         HTMLLinkElement {

components/script/dom/htmlmapelement.rs

@@ -3,11 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLMapElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId, HTMLElementTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLMapElementDerived, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -17,14 +15,6 @@ pub struct HTMLMapElement {
     htmlelement: HTMLElement
 }
 
-impl HTMLMapElementDerived for EventTarget {
-    fn is_htmlmapelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLMapElement)))
-    }
-}
-
 impl HTMLMapElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmlmediaelement.rs

@@ -2,11 +2,8 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, HTMLMediaElementTypeId};
-use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, HTMLMediaElementDerived};
-use dom::bindings::codegen::InheritTypes::{HTMLMediaElementTypeId, NodeTypeId};
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use util::str::DOMString;
 
@@ -15,16 +12,6 @@ pub struct HTMLMediaElement {
     htmlelement: HTMLElement,
 }
 
-impl HTMLMediaElementDerived for EventTarget {
-    fn is_htmlmediaelement(&self) -> bool {
-        match *self.type_id() {
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLMediaElement(_)))) => true,
-            _ => false
-        }
-    }
-}
-
 impl HTMLMediaElement {
     pub fn new_inherited(type_id: HTMLMediaElementTypeId, tag_name: DOMString,
                          prefix: Option<DOMString>, document: &Document)

components/script/dom/htmlmetaelement.rs

@@ -4,12 +4,10 @@
 
 use dom::bindings::codegen::Bindings::HTMLMetaElementBinding;
 use dom::bindings::codegen::Bindings::HTMLMetaElementBinding::HTMLMetaElementMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, ElementTypeId, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLElementTypeId};
+use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, NodeCast};
-use dom::bindings::codegen::InheritTypes::{HTMLMetaElementDerived, NodeCast, NodeTypeId};
 use dom::bindings::js::{Root, RootedReference};
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::{Node, window_from_node};
 use dom::virtualmethods::VirtualMethods;
@@ -23,14 +21,6 @@ pub struct HTMLMetaElement {
     htmlelement: HTMLElement,
 }
 
-impl HTMLMetaElementDerived for EventTarget {
-    fn is_htmlmetaelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLMetaElement)))
-    }
-}
-
 impl HTMLMetaElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmlmeterelement.rs

@@ -3,11 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLMeterElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId, HTMLElementTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLMeterElementDerived, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -17,14 +15,6 @@ pub struct HTMLMeterElement {
     htmlelement: HTMLElement
 }
 
-impl HTMLMeterElementDerived for EventTarget {
-    fn is_htmlmeterelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLMeterElement)))
-    }
-}
-
 impl HTMLMeterElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmlmodelement.rs

@@ -3,11 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLModElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId, HTMLElementTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLModElementDerived, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -17,14 +15,6 @@ pub struct HTMLModElement {
     htmlelement: HTMLElement
 }
 
-impl HTMLModElementDerived for EventTarget {
-    fn is_htmlmodelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLModElement)))
-    }
-}
-
 impl HTMLModElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmlobjectelement.rs

@@ -6,13 +6,10 @@ use dom::attr::Attr;
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::HTMLObjectElementBinding;
 use dom::bindings::codegen::Bindings::HTMLObjectElementBinding::HTMLObjectElementMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, ElementTypeId, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast, HTMLElementTypeId};
-use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLElementTypeId};
-use dom::bindings::codegen::InheritTypes::{HTMLObjectElementDerived, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
 use dom::element::AttributeMutation;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::htmlformelement::{FormControl, HTMLFormElement};
 use dom::node::{Node, window_from_node};
@@ -28,14 +25,6 @@ pub struct HTMLObjectElement {
     image: DOMRefCell<Option<Arc<Image>>>,
 }
 
-impl HTMLObjectElementDerived for EventTarget {
-    fn is_htmlobjectelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLObjectElement)))
-    }
-}
-
 impl HTMLObjectElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmlolistelement.rs

@@ -3,11 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLOListElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId, HTMLElementTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLOListElementDerived, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -17,14 +15,6 @@ pub struct HTMLOListElement {
     htmlelement: HTMLElement,
 }
 
-impl HTMLOListElementDerived for EventTarget {
-    fn is_htmlolistelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLOListElement)))
-    }
-}
-
 impl HTMLOListElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmloptgroupelement.rs

@@ -5,14 +5,11 @@
 use dom::attr::Attr;
 use dom::bindings::codegen::Bindings::HTMLOptGroupElementBinding;
 use dom::bindings::codegen::Bindings::HTMLOptGroupElementBinding::HTMLOptGroupElementMethods;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId};
 use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLElementTypeId};
-use dom::bindings::codegen::InheritTypes::{HTMLOptGroupElementDerived, HTMLOptionElementDerived};
+use dom::bindings::codegen::InheritTypes::{HTMLOptionElementDerived, NodeCast};
-use dom::bindings::codegen::InheritTypes::{NodeCast, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
 use dom::element::AttributeMutation;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use dom::virtualmethods::VirtualMethods;
@@ -23,14 +20,6 @@ pub struct HTMLOptGroupElement {
     htmlelement: HTMLElement
 }
 
-impl HTMLOptGroupElementDerived for EventTarget {
-    fn is_htmloptgroupelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLOptGroupElement)))
-    }
-}
-
 impl HTMLOptGroupElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmloptionelement.rs

@@ -7,14 +7,12 @@ use dom::bindings::codegen::Bindings::CharacterDataBinding::CharacterDataMethods
 use dom::bindings::codegen::Bindings::HTMLOptionElementBinding;
 use dom::bindings::codegen::Bindings::HTMLOptionElementBinding::HTMLOptionElementMethods;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
-use dom::bindings::codegen::InheritTypes::{CharacterDataCast, ElementCast, ElementTypeId};
+use dom::bindings::codegen::InheritTypes::{CharacterDataCast, ElementCast, HTMLElementCast};
-use dom::bindings::codegen::InheritTypes::{EventTargetTypeId, HTMLElementCast, HTMLElementTypeId};
+use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, HTMLScriptElementDerived};
-use dom::bindings::codegen::InheritTypes::{HTMLOptionElementDerived, HTMLScriptElementDerived};
+use dom::bindings::codegen::InheritTypes::{NodeCast, TextDerived};
-use dom::bindings::codegen::InheritTypes::{NodeCast, NodeTypeId, TextDerived};
 use dom::bindings::js::Root;
 use dom::document::Document;
 use dom::element::{AttributeMutation, Element};
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use dom::virtualmethods::VirtualMethods;
@@ -32,14 +30,6 @@ pub struct HTMLOptionElement {
     dirtiness: Cell<bool>,
 }
 
-impl HTMLOptionElementDerived for EventTarget {
-    fn is_htmloptionelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLOptionElement)))
-    }
-}
-
 impl HTMLOptionElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmloutputelement.rs

@@ -4,11 +4,9 @@
 
 use dom::bindings::codegen::Bindings::HTMLOutputElementBinding;
 use dom::bindings::codegen::Bindings::HTMLOutputElementBinding::HTMLOutputElementMethods;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId, HTMLElementTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLOutputElementDerived, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::htmlformelement::{FormControl, HTMLFormElement};
 use dom::node::{Node, window_from_node};
@@ -20,14 +18,6 @@ pub struct HTMLOutputElement {
     htmlelement: HTMLElement
 }
 
-impl HTMLOutputElementDerived for EventTarget {
-    fn is_htmloutputelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLOutputElement)))
-    }
-}
-
 impl HTMLOutputElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmlparagraphelement.rs

@@ -3,11 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLParagraphElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId, HTMLElementTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLParagraphElementDerived, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -17,14 +15,6 @@ pub struct HTMLParagraphElement {
     htmlelement: HTMLElement
 }
 
-impl HTMLParagraphElementDerived for EventTarget {
-    fn is_htmlparagraphelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLParagraphElement)))
-    }
-}
-
 impl HTMLParagraphElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmlparamelement.rs

@@ -3,11 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLParamElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId, HTMLElementTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLParamElementDerived, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -17,14 +15,6 @@ pub struct HTMLParamElement {
     htmlelement: HTMLElement
 }
 
-impl HTMLParamElementDerived for EventTarget {
-    fn is_htmlparamelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLParamElement)))
-    }
-}
-
 impl HTMLParamElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmlpreelement.rs

@@ -3,11 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLPreElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId, HTMLElementTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLPreElementDerived, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -17,14 +15,6 @@ pub struct HTMLPreElement {
     htmlelement: HTMLElement,
 }
 
-impl HTMLPreElementDerived for EventTarget {
-    fn is_htmlpreelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLPreElement)))
-    }
-}
-
 impl HTMLPreElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmlprogresselement.rs

@@ -3,11 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLProgressElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId, HTMLElementTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLProgressElementDerived, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -17,14 +15,6 @@ pub struct HTMLProgressElement {
     htmlelement: HTMLElement,
 }
 
-impl HTMLProgressElementDerived for EventTarget {
-    fn is_htmlprogresselement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLProgressElement)))
-    }
-}
-
 impl HTMLProgressElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmlquoteelement.rs

@@ -3,11 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLQuoteElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId, HTMLElementTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLQuoteElementDerived, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -17,14 +15,6 @@ pub struct HTMLQuoteElement {
     htmlelement: HTMLElement,
 }
 
-impl HTMLQuoteElementDerived for EventTarget {
-    fn is_htmlquoteelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLQuoteElement)))
-    }
-}
-
 impl HTMLQuoteElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmlscriptelement.rs

@@ -10,11 +10,9 @@ use dom::bindings::codegen::Bindings::DocumentBinding::DocumentMethods;
 use dom::bindings::codegen::Bindings::HTMLScriptElementBinding;
 use dom::bindings::codegen::Bindings::HTMLScriptElementBinding::HTMLScriptElementMethods;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, ElementTypeId};
+use dom::bindings::codegen::InheritTypes::{ElementCast, EventTargetCast};
-use dom::bindings::codegen::InheritTypes::{EventTargetCast, EventTargetTypeId};
 use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLElementTypeId};
-use dom::bindings::codegen::InheritTypes::{HTMLScriptElementCast, HTMLScriptElementDerived};
+use dom::bindings::codegen::InheritTypes::{HTMLScriptElementCast, NodeCast};
-use dom::bindings::codegen::InheritTypes::{NodeCast, NodeTypeId};
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::RootedReference;
 use dom::bindings::js::{JS, Root};
@@ -23,7 +21,6 @@ use dom::bindings::trace::JSTraceable;
 use dom::document::Document;
 use dom::element::{AttributeMutation, ElementCreator};
 use dom::event::{Event, EventBubbles, EventCancelable};
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::{ChildrenMutation, CloneChildrenFlag, Node};
 use dom::node::{document_from_node, window_from_node};
@@ -76,14 +73,6 @@ pub struct HTMLScriptElement {
     block_character_encoding: DOMRefCell<EncodingRef>,
 }
 
-impl HTMLScriptElementDerived for EventTarget {
-    fn is_htmlscriptelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLScriptElement)))
-    }
-}
-
 impl HTMLScriptElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: &Document,
                      creator: ElementCreator) -> HTMLScriptElement {

components/script/dom/htmlselectelement.rs

@@ -5,16 +5,13 @@
 use dom::attr::{Attr, AttrValue};
 use dom::bindings::codegen::Bindings::HTMLSelectElementBinding;
 use dom::bindings::codegen::Bindings::HTMLSelectElementBinding::HTMLSelectElementMethods;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId};
 use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLElementTypeId};
-use dom::bindings::codegen::InheritTypes::{HTMLFieldSetElementDerived, HTMLSelectElementDerived};
+use dom::bindings::codegen::InheritTypes::{HTMLFieldSetElementDerived, NodeCast};
-use dom::bindings::codegen::InheritTypes::{NodeCast, NodeTypeId};
 use dom::bindings::codegen::UnionTypes::HTMLElementOrLong;
 use dom::bindings::codegen::UnionTypes::HTMLOptionElementOrHTMLOptGroupElement;
 use dom::bindings::js::Root;
 use dom::document::Document;
 use dom::element::AttributeMutation;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::htmlformelement::{FormControl, HTMLFormElement};
 use dom::node::{Node, window_from_node};
@@ -29,14 +26,6 @@ pub struct HTMLSelectElement {
     htmlelement: HTMLElement
 }
 
-impl HTMLSelectElementDerived for EventTarget {
-    fn is_htmlselectelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLSelectElement)))
-    }
-}
-
 static DEFAULT_SELECT_SIZE: u32 = 0;
 
 impl HTMLSelectElement {

components/script/dom/htmlsourceelement.rs

@@ -3,11 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLSourceElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId, HTMLElementTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLSourceElementDerived, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -17,14 +15,6 @@ pub struct HTMLSourceElement {
     htmlelement: HTMLElement
 }
 
-impl HTMLSourceElementDerived for EventTarget {
-    fn is_htmlsourceelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLSourceElement)))
-    }
-}
-
 impl HTMLSourceElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmlspanelement.rs

@@ -3,11 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLSpanElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId, HTMLElementTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLSpanElementDerived, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -17,14 +15,6 @@ pub struct HTMLSpanElement {
     htmlelement: HTMLElement
 }
 
-impl HTMLSpanElementDerived for EventTarget {
-    fn is_htmlspanelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLSpanElement)))
-    }
-}
-
 impl HTMLSpanElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: &Document) -> HTMLSpanElement {
         HTMLSpanElement {

components/script/dom/htmlstyleelement.rs

@@ -5,13 +5,10 @@
 use cssparser::Parser as CssParser;
 use dom::bindings::codegen::Bindings::HTMLStyleElementBinding;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, ElementTypeId};
+use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast};
-use dom::bindings::codegen::InheritTypes::{EventTargetTypeId, HTMLElementCast};
+use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, NodeCast};
-use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, HTMLStyleElementDerived};
-use dom::bindings::codegen::InheritTypes::{NodeCast, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::{ChildrenMutation, Node, window_from_node};
 use dom::virtualmethods::VirtualMethods;
@@ -25,14 +22,6 @@ pub struct HTMLStyleElement {
     htmlelement: HTMLElement,
 }
 
-impl HTMLStyleElementDerived for EventTarget {
-    fn is_htmlstyleelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLStyleElement)))
-    }
-}
-
 impl HTMLStyleElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmltablecaptionelement.rs

@@ -3,11 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLTableCaptionElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId, HTMLElementTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLTableCaptionElementDerived, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -17,14 +15,6 @@ pub struct HTMLTableCaptionElement {
     htmlelement: HTMLElement
 }
 
-impl HTMLTableCaptionElementDerived for EventTarget {
-    fn is_htmltablecaptionelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTableCaptionElement)))
-    }
-}
-
 impl HTMLTableCaptionElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmltablecellelement.rs

@@ -6,14 +6,12 @@ use cssparser::RGBA;
 use dom::attr::{Attr, AttrValue};
 use dom::bindings::codegen::Bindings::HTMLTableCellElementBinding::HTMLTableCellElementMethods;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId, HTMLElementCast};
+use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLElementTypeId};
-use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, HTMLTableCellElementDerived};
+use dom::bindings::codegen::InheritTypes::{HTMLTableCellElementDerived, HTMLTableCellElementTypeId};
-use dom::bindings::codegen::InheritTypes::{HTMLTableCellElementTypeId, HTMLTableRowElementDerived};
+use dom::bindings::codegen::InheritTypes::{HTMLTableRowElementDerived, NodeCast};
-use dom::bindings::codegen::InheritTypes::{NodeCast, NodeTypeId};
 use dom::bindings::js::LayoutJS;
 use dom::document::Document;
 use dom::element::AttributeMutation;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::virtualmethods::VirtualMethods;
 use std::cell::Cell;
@@ -31,16 +29,6 @@ pub struct HTMLTableCellElement {
     width: Cell<LengthOrPercentageOrAuto>,
 }
 
-impl HTMLTableCellElementDerived for EventTarget {
-    fn is_htmltablecellelement(&self) -> bool {
-        match *self.type_id() {
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTableCellElement(_)))) => true,
-            _ => false
-        }
-    }
-}
-
 impl HTMLTableCellElement {
     pub fn new_inherited(type_id: HTMLTableCellElementTypeId,
                          tag_name: DOMString,

components/script/dom/htmltablecolelement.rs

@@ -3,11 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLTableColElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId, HTMLElementTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLTableColElementDerived, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -17,14 +15,6 @@ pub struct HTMLTableColElement {
     htmlelement: HTMLElement,
 }
 
-impl HTMLTableColElementDerived for EventTarget {
-    fn is_htmltablecolelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTableColElement)))
-    }
-}
-
 impl HTMLTableColElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmltabledatacellelement.rs

@@ -3,12 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLTableDataCellElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLTableCellElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, HTMLTableDataCellElementDerived};
-use dom::bindings::codegen::InheritTypes::{HTMLTableCellElementTypeId, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmltablecellelement::HTMLTableCellElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -18,15 +15,6 @@ pub struct HTMLTableDataCellElement {
     htmltablecellelement: HTMLTableCellElement,
 }
 
-impl HTMLTableDataCellElementDerived for EventTarget {
-    fn is_htmltabledatacellelement(&self) -> bool {
-        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(
-                                                   ElementTypeId::HTMLElement(
-                                                   HTMLElementTypeId::HTMLTableCellElement(
-                                                   HTMLTableCellElementTypeId::HTMLTableDataCellElement))))
-    }
-}
-
 impl HTMLTableDataCellElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmltableelement.rs

@@ -7,14 +7,12 @@ use dom::attr::{Attr, AttrValue};
 use dom::bindings::codegen::Bindings::HTMLTableElementBinding;
 use dom::bindings::codegen::Bindings::HTMLTableElementBinding::HTMLTableElementMethods;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, ElementTypeId, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLElementTypeId};
+use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, HTMLTableCaptionElementCast};
-use dom::bindings::codegen::InheritTypes::{HTMLTableCaptionElementCast, HTMLTableElementDerived};
+use dom::bindings::codegen::InheritTypes::{HTMLTableSectionElementDerived, NodeCast};
-use dom::bindings::codegen::InheritTypes::{HTMLTableSectionElementDerived, NodeCast, NodeTypeId};
 use dom::bindings::js::{Root, RootedReference};
 use dom::document::Document;
 use dom::element::AttributeMutation;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::htmltablecaptionelement::HTMLTableCaptionElement;
 use dom::htmltablesectionelement::HTMLTableSectionElement;
@@ -33,14 +31,6 @@ pub struct HTMLTableElement {
     width: Cell<LengthOrPercentageOrAuto>,
 }
 
-impl HTMLTableElementDerived for EventTarget {
-    fn is_htmltableelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTableElement)))
-    }
-}
-
 impl HTMLTableElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: &Document)
                      -> HTMLTableElement {

components/script/dom/htmltableheadercellelement.rs

@@ -3,12 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLTableHeaderCellElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLTableCellElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, HTMLTableHeaderCellElementDerived};
-use dom::bindings::codegen::InheritTypes::{HTMLTableCellElementTypeId, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmltablecellelement::HTMLTableCellElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -18,15 +15,6 @@ pub struct HTMLTableHeaderCellElement {
     htmltablecellelement: HTMLTableCellElement,
 }
 
-impl HTMLTableHeaderCellElementDerived for EventTarget {
-    fn is_htmltableheadercellelement(&self) -> bool {
-        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(
-                                                   ElementTypeId::HTMLElement(
-                                                   HTMLElementTypeId::HTMLTableCellElement(
-                                                   HTMLTableCellElementTypeId::HTMLTableHeaderCellElement))))
-    }
-}
-
 impl HTMLTableHeaderCellElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmltablerowelement.rs

@@ -6,14 +6,11 @@ use cssparser::RGBA;
 use dom::attr::Attr;
 use dom::bindings::codegen::Bindings::HTMLTableRowElementBinding::{self, HTMLTableRowElementMethods};
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId, HTMLElementCast};
+use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLElementTypeId, HTMLTableDataCellElementDerived};
-use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, HTMLTableDataCellElementDerived};
+use dom::bindings::codegen::InheritTypes::{HTMLTableHeaderCellElementDerived, NodeCast};
-use dom::bindings::codegen::InheritTypes::{HTMLTableHeaderCellElementDerived, HTMLTableRowElementDerived};
-use dom::bindings::codegen::InheritTypes::{NodeCast, NodeTypeId};
 use dom::bindings::js::{JS, MutNullableHeap, Root, RootedReference};
 use dom::document::Document;
 use dom::element::{AttributeMutation, Element};
-use dom::eventtarget::EventTarget;
 use dom::htmlcollection::{CollectionFilter, HTMLCollection};
 use dom::htmlelement::HTMLElement;
 use dom::node::{Node, window_from_node};
@@ -38,14 +35,6 @@ pub struct HTMLTableRowElement {
     background_color: Cell<Option<RGBA>>,
 }
 
-impl HTMLTableRowElementDerived for EventTarget {
-    fn is_htmltablerowelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTableRowElement)))
-    }
-}
-
 impl HTMLTableRowElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: &Document)
                      -> HTMLTableRowElement {

components/script/dom/htmltablesectionelement.rs

@@ -7,15 +7,13 @@ use dom::attr::Attr;
 use dom::bindings::codegen::Bindings::HTMLCollectionBinding::HTMLCollectionMethods;
 use dom::bindings::codegen::Bindings::HTMLTableSectionElementBinding::{self, HTMLTableSectionElementMethods};
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, ElementTypeId, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast, HTMLElementTypeId};
-use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLElementTypeId, HTMLTableRowElementDerived};
+use dom::bindings::codegen::InheritTypes::{HTMLTableRowElementDerived, NodeCast};
-use dom::bindings::codegen::InheritTypes::{HTMLTableSectionElementDerived, NodeCast, NodeTypeId};
 use dom::bindings::error::Error;
 use dom::bindings::error::{ErrorResult, Fallible};
 use dom::bindings::js::{Root, RootedReference};
 use dom::document::Document;
 use dom::element::{AttributeMutation, Element};
-use dom::eventtarget::EventTarget;
 use dom::htmlcollection::{CollectionFilter, HTMLCollection};
 use dom::htmlelement::HTMLElement;
 use dom::htmltablerowelement::HTMLTableRowElement;
@@ -31,14 +29,6 @@ pub struct HTMLTableSectionElement {
     background_color: Cell<Option<RGBA>>,
 }
 
-impl HTMLTableSectionElementDerived for EventTarget {
-    fn is_htmltablesectionelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTableSectionElement)))
-    }
-}
-
 impl HTMLTableSectionElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: &Document)
                      -> HTMLTableSectionElement {

components/script/dom/htmltemplateelement.rs

@@ -6,14 +6,11 @@ use dom::bindings::codegen::Bindings::DocumentBinding::DocumentMethods;
 use dom::bindings::codegen::Bindings::HTMLTemplateElementBinding;
 use dom::bindings::codegen::Bindings::HTMLTemplateElementBinding::HTMLTemplateElementMethods;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId};
 use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLElementTypeId};
-use dom::bindings::codegen::InheritTypes::{HTMLTemplateElementCast, HTMLTemplateElementDerived};
+use dom::bindings::codegen::InheritTypes::{HTMLTemplateElementCast, NodeCast};
-use dom::bindings::codegen::InheritTypes::{NodeCast, NodeTypeId};
 use dom::bindings::js::{JS, MutNullableHeap, Root};
 use dom::document::Document;
 use dom::documentfragment::DocumentFragment;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::{CloneChildrenFlag, Node, document_from_node};
 use dom::virtualmethods::VirtualMethods;
@@ -27,14 +24,6 @@ pub struct HTMLTemplateElement {
     contents: MutNullableHeap<JS<DocumentFragment>>,
 }
 
-impl HTMLTemplateElementDerived for EventTarget {
-    fn is_htmltemplateelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTemplateElement)))
-    }
-}
-
 impl HTMLTemplateElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmltextareaelement.rs

@@ -8,18 +8,15 @@ use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
 use dom::bindings::codegen::Bindings::HTMLTextAreaElementBinding;
 use dom::bindings::codegen::Bindings::HTMLTextAreaElementBinding::HTMLTextAreaElementMethods;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
-use dom::bindings::codegen::InheritTypes::{ElementCast, ElementTypeId, EventTargetCast};
+use dom::bindings::codegen::InheritTypes::{ElementCast, EventTargetCast, HTMLElementCast};
-use dom::bindings::codegen::InheritTypes::{EventTargetTypeId, HTMLElementCast};
 use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, HTMLFieldSetElementDerived};
-use dom::bindings::codegen::InheritTypes::{HTMLTextAreaElementDerived, KeyboardEventCast};
+use dom::bindings::codegen::InheritTypes::{KeyboardEventCast, NodeCast};
-use dom::bindings::codegen::InheritTypes::{NodeCast, NodeTypeId};
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{LayoutJS, Root};
 use dom::bindings::refcounted::Trusted;
 use dom::document::Document;
 use dom::element::AttributeMutation;
 use dom::event::{Event, EventBubbles, EventCancelable};
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::htmlformelement::{FormControl, HTMLFormElement};
 use dom::keyboardevent::KeyboardEvent;
@@ -46,14 +43,6 @@ pub struct HTMLTextAreaElement {
     value_changed: Cell<bool>,
 }
 
-impl HTMLTextAreaElementDerived for EventTarget {
-    fn is_htmltextareaelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTextAreaElement)))
-    }
-}
-
 pub trait LayoutHTMLTextAreaElementHelpers {
     #[allow(unsafe_code)]
     unsafe fn get_value_for_layout(self) -> String;

components/script/dom/htmltimeelement.rs

@@ -3,11 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLTimeElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId, HTMLElementTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLTimeElementDerived, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -17,14 +15,6 @@ pub struct HTMLTimeElement {
     htmlelement: HTMLElement
 }
 
-impl HTMLTimeElementDerived for EventTarget {
-    fn is_htmltimeelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTimeElement)))
-    }
-}
-
 impl HTMLTimeElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: &Document) -> HTMLTimeElement {
         HTMLTimeElement {

components/script/dom/htmltitleelement.rs

@@ -5,13 +5,10 @@
 use dom::bindings::codegen::Bindings::HTMLTitleElementBinding;
 use dom::bindings::codegen::Bindings::HTMLTitleElementBinding::HTMLTitleElementMethods;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
-use dom::bindings::codegen::InheritTypes::{CharacterDataCast, ElementTypeId};
+use dom::bindings::codegen::InheritTypes::{CharacterDataCast, HTMLElementCast};
-use dom::bindings::codegen::InheritTypes::{EventTargetTypeId, HTMLElementCast};
+use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, NodeCast, TextCast};
-use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, HTMLTitleElementDerived};
-use dom::bindings::codegen::InheritTypes::{NodeCast, NodeTypeId, TextCast};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::{ChildrenMutation, Node};
 use dom::text::Text;
@@ -23,14 +20,6 @@ pub struct HTMLTitleElement {
     htmlelement: HTMLElement,
 }
 
-impl HTMLTitleElementDerived for EventTarget {
-    fn is_htmltitleelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTitleElement)))
-    }
-}
-
 impl HTMLTitleElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: &Document) -> HTMLTitleElement {
         HTMLTitleElement {

components/script/dom/htmltrackelement.rs

@@ -3,11 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLTrackElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId, HTMLElementTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLTrackElementDerived, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -17,14 +15,6 @@ pub struct HTMLTrackElement {
     htmlelement: HTMLElement,
 }
 
-impl HTMLTrackElementDerived for EventTarget {
-    fn is_htmltrackelement(&self) -> bool {
-        *self.type_id() == EventTargetTypeId::Node(
-            NodeTypeId::Element(
-                ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTrackElement)))
-    }
-}
-
 impl HTMLTrackElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: &Document) -> HTMLTrackElement {
         HTMLTrackElement {

components/script/dom/htmlulistelement.rs

@@ -3,11 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLUListElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId, HTMLElementTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLUListElementDerived, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -17,14 +15,6 @@ pub struct HTMLUListElement {
     htmlelement: HTMLElement
 }
 
-impl HTMLUListElementDerived for EventTarget {
-    fn is_htmlulistelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLUListElement)))
-    }
-}
-
 impl HTMLUListElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: &Document) -> HTMLUListElement {
         HTMLUListElement {

components/script/dom/htmlunknownelement.rs

@@ -3,11 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLUnknownElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId, HTMLElementTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLUnknownElementDerived, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -17,14 +15,6 @@ pub struct HTMLUnknownElement {
     htmlelement: HTMLElement
 }
 
-impl HTMLUnknownElementDerived for EventTarget {
-    fn is_htmlunknownelement(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(
-                NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLUnknownElement)))
-    }
-}
-
 impl HTMLUnknownElement {
     fn new_inherited(localName: DOMString,
                      prefix: Option<DOMString>,

components/script/dom/htmlvideoelement.rs

@@ -3,12 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::HTMLVideoElementBinding;
-use dom::bindings::codegen::InheritTypes::{ElementTypeId, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::HTMLMediaElementTypeId;
-use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, HTMLMediaElementTypeId};
-use dom::bindings::codegen::InheritTypes::{HTMLVideoElementDerived, NodeTypeId};
 use dom::bindings::js::Root;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::htmlmediaelement::HTMLMediaElement;
 use dom::node::Node;
 use util::str::DOMString;
@@ -18,15 +15,6 @@ pub struct HTMLVideoElement {
     htmlmediaelement: HTMLMediaElement
 }
 
-impl HTMLVideoElementDerived for EventTarget {
-    fn is_htmlvideoelement(&self) -> bool {
-        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(
-                                                   ElementTypeId::HTMLElement(
-                                                   HTMLElementTypeId::HTMLMediaElement(
-                                                   HTMLMediaElementTypeId::HTMLVideoElement))))
-    }
-}
-
 impl HTMLVideoElement {
     fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: &Document) -> HTMLVideoElement {
         HTMLVideoElement {

components/script/dom/keyboardevent.rs

@@ -5,13 +5,11 @@
 use dom::bindings::codegen::Bindings::KeyboardEventBinding;
 use dom::bindings::codegen::Bindings::KeyboardEventBinding::{KeyboardEventConstants, KeyboardEventMethods};
 use dom::bindings::codegen::Bindings::UIEventBinding::UIEventMethods;
-use dom::bindings::codegen::InheritTypes::{EventCast, EventTypeId, KeyboardEventDerived};
+use dom::bindings::codegen::InheritTypes::{EventCast, UIEventCast};
-use dom::bindings::codegen::InheritTypes::{UIEventCast, UIEventTypeId};
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{Root, RootedReference};
 use dom::bindings::utils::{Reflectable, reflect_dom_object};
-use dom::event::Event;
 use dom::uievent::UIEvent;
 use dom::window::Window;
 use msg::constellation_msg;
@@ -40,12 +38,6 @@ pub struct KeyboardEvent {
     key_code: Cell<u32>,
 }
 
-impl KeyboardEventDerived for Event {
-    fn is_keyboardevent(&self) -> bool {
-        *self.type_id() == EventTypeId::UIEvent(UIEventTypeId::KeyboardEvent)
-    }
-}
-
 impl KeyboardEvent {
     fn new_inherited() -> KeyboardEvent {
         KeyboardEvent {

components/script/dom/messageevent.rs

@@ -5,7 +5,7 @@
 use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
 use dom::bindings::codegen::Bindings::MessageEventBinding;
 use dom::bindings::codegen::Bindings::MessageEventBinding::MessageEventMethods;
-use dom::bindings::codegen::InheritTypes::{EventCast, EventTypeId, MessageEventDerived};
+use dom::bindings::codegen::InheritTypes::EventCast;
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
@@ -26,12 +26,6 @@ pub struct MessageEvent {
     lastEventId: DOMString,
 }
 
-impl MessageEventDerived for Event {
-    fn is_messageevent(&self) -> bool {
-        *self.type_id() == EventTypeId::MessageEvent
-    }
-}
-
 impl MessageEvent {
     pub fn new_uninitialized(global: GlobalRef) -> Root<MessageEvent> {
         MessageEvent::new_initialized(global, HandleValue::undefined(), "".to_owned(), "".to_owned())

components/script/dom/mouseevent.rs

@@ -5,8 +5,7 @@
 use dom::bindings::codegen::Bindings::MouseEventBinding;
 use dom::bindings::codegen::Bindings::MouseEventBinding::MouseEventMethods;
 use dom::bindings::codegen::Bindings::UIEventBinding::UIEventMethods;
-use dom::bindings::codegen::InheritTypes::{EventCast, EventTypeId, UIEventCast};
+use dom::bindings::codegen::InheritTypes::{EventCast, UIEventCast};
-use dom::bindings::codegen::InheritTypes::{UIEventTypeId, MouseEventDerived};
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, MutNullableHeap, Root, RootedReference};
@@ -35,12 +34,6 @@ pub struct MouseEvent {
     related_target: MutNullableHeap<JS<EventTarget>>,
 }
 
-impl MouseEventDerived for Event {
-    fn is_mouseevent(&self) -> bool {
-        *self.type_id() == EventTypeId::UIEvent(UIEventTypeId::MouseEvent)
-    }
-}
-
 impl MouseEvent {
     fn new_inherited() -> MouseEvent {
         MouseEvent {

components/script/dom/node.rs

@@ -24,7 +24,7 @@ use dom::bindings::codegen::InheritTypes::{ElementCast, ElementDerived, ElementT
 use dom::bindings::codegen::InheritTypes::{EventTargetCast, EventTargetTypeId};
 use dom::bindings::codegen::InheritTypes::{HTMLElementTypeId, HTMLFieldSetElementDerived};
 use dom::bindings::codegen::InheritTypes::{HTMLLegendElementDerived, HTMLOptGroupElementDerived};
-use dom::bindings::codegen::InheritTypes::{NodeBase, NodeCast, NodeDerived, NodeTypeId};
+use dom::bindings::codegen::InheritTypes::{NodeBase, NodeCast, NodeTypeId};
 use dom::bindings::codegen::InheritTypes::{ProcessingInstructionCast, TextCast, TextDerived};
 use dom::bindings::codegen::UnionTypes::NodeOrString;
 use dom::bindings::conversions;
@@ -122,15 +122,6 @@ impl PartialEq for Node {
     }
 }
 
-impl NodeDerived for EventTarget {
-    fn is_node(&self) -> bool {
-        match *self.type_id() {
-            EventTargetTypeId::Node(_) => true,
-            _ => false
-        }
-    }
-}
-
 bitflags! {
     #[doc = "Flags for node items."]
     #[derive(JSTraceable, HeapSizeOf)]

components/script/dom/processinginstruction.rs

@@ -4,12 +4,10 @@
 
 use dom::bindings::codegen::Bindings::ProcessingInstructionBinding;
 use dom::bindings::codegen::Bindings::ProcessingInstructionBinding::ProcessingInstructionMethods;
-use dom::bindings::codegen::InheritTypes::{CharacterDataTypeId, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::CharacterDataTypeId;
-use dom::bindings::codegen::InheritTypes::{NodeTypeId, ProcessingInstructionDerived};
 use dom::bindings::js::Root;
 use dom::characterdata::CharacterData;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::node::Node;
 use util::str::DOMString;
 
@@ -20,13 +18,6 @@ pub struct ProcessingInstruction {
     target: DOMString,
 }
 
-impl ProcessingInstructionDerived for EventTarget {
-    fn is_processinginstruction(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::Node(NodeTypeId::CharacterData(CharacterDataTypeId::ProcessingInstruction))
-    }
-}
-
 impl ProcessingInstruction {
     fn new_inherited(target: DOMString, data: DOMString, document: &Document) -> ProcessingInstruction {
         ProcessingInstruction {

components/script/dom/progressevent.rs

@@ -5,7 +5,7 @@
 use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
 use dom::bindings::codegen::Bindings::ProgressEventBinding;
 use dom::bindings::codegen::Bindings::ProgressEventBinding::ProgressEventMethods;
-use dom::bindings::codegen::InheritTypes::{EventCast, EventTypeId, ProgressEventDerived};
+use dom::bindings::codegen::InheritTypes::EventCast;
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
@@ -21,12 +21,6 @@ pub struct ProgressEvent {
     total: u64
 }
 
-impl ProgressEventDerived for Event {
-    fn is_progressevent(&self) -> bool {
-        *self.type_id() == EventTypeId::ProgressEvent
-    }
-}
-
 impl ProgressEvent {
     fn new_inherited(length_computable: bool, loaded: u64, total: u64) -> ProgressEvent {
         ProgressEvent {

components/script/dom/text.rs

@@ -8,15 +8,13 @@ use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
 use dom::bindings::codegen::Bindings::TextBinding::{self, TextMethods};
 use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
 use dom::bindings::codegen::InheritTypes::{CharacterDataCast, CharacterDataTypeId};
-use dom::bindings::codegen::InheritTypes::{EventTargetTypeId, NodeCast};
+use dom::bindings::codegen::InheritTypes::{NodeCast, TextDerived};
-use dom::bindings::codegen::InheritTypes::{NodeTypeId, TextDerived};
 use dom::bindings::error::{Error, Fallible};
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::js::{RootedReference};
 use dom::characterdata::CharacterData;
 use dom::document::Document;
-use dom::eventtarget::EventTarget;
 use dom::node::Node;
 use util::str::DOMString;
 
@@ -26,12 +24,6 @@ pub struct Text {
     characterdata: CharacterData,
 }
 
-impl TextDerived for EventTarget {
-    fn is_text(&self) -> bool {
-        *self.type_id() == EventTargetTypeId::Node(NodeTypeId::CharacterData(CharacterDataTypeId::Text))
-    }
-}
-
 impl Text {
     fn new_inherited(text: DOMString, document: &Document) -> Text {
         Text {

components/script/dom/uievent.rs

@@ -5,7 +5,7 @@
 use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
 use dom::bindings::codegen::Bindings::UIEventBinding;
 use dom::bindings::codegen::Bindings::UIEventBinding::UIEventMethods;
-use dom::bindings::codegen::InheritTypes::{EventCast, EventTypeId, UIEventDerived};
+use dom::bindings::codegen::InheritTypes::EventCast;
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
@@ -25,15 +25,6 @@ pub struct UIEvent {
     detail: Cell<i32>
 }
 
-impl UIEventDerived for Event {
-    fn is_uievent(&self) -> bool {
-        match *self.type_id() {
-            EventTypeId::UIEvent(_) => true,
-            _ => false
-        }
-    }
-}
-
 impl UIEvent {
     pub fn new_inherited() -> UIEvent {
         UIEvent {

components/script/dom/webglcontextevent.rs

@@ -6,7 +6,7 @@ use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
 use dom::bindings::codegen::Bindings::WebGLContextEventBinding;
 use dom::bindings::codegen::Bindings::WebGLContextEventBinding::WebGLContextEventInit;
 use dom::bindings::codegen::Bindings::WebGLContextEventBinding::WebGLContextEventMethods;
-use dom::bindings::codegen::InheritTypes::{EventCast, EventTypeId, WebGLContextEventDerived};
+use dom::bindings::codegen::InheritTypes::EventCast;
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{Root, RootedReference};
@@ -27,12 +27,6 @@ impl WebGLContextEventMethods for WebGLContextEvent {
     }
 }
 
-impl WebGLContextEventDerived for Event {
-    fn is_webglcontextevent(&self) -> bool {
-        *self.type_id() == EventTypeId::WebGLContextEvent
-    }
-}
-
 impl WebGLContextEvent {
     pub fn new_inherited(status_message: DOMString) -> WebGLContextEvent {
         WebGLContextEvent {

components/script/dom/window.rs

@@ -11,8 +11,7 @@ use dom::bindings::codegen::Bindings::EventHandlerBinding::{EventHandlerNonNull,
 use dom::bindings::codegen::Bindings::FunctionBinding::Function;
 use dom::bindings::codegen::Bindings::WindowBinding::{ScrollBehavior, ScrollToOptions};
 use dom::bindings::codegen::Bindings::WindowBinding::{self, FrameRequestCallback, WindowMethods};
-use dom::bindings::codegen::InheritTypes::{ElementCast, EventTargetCast};
+use dom::bindings::codegen::InheritTypes::{ElementCast, EventTargetCast, NodeCast};
-use dom::bindings::codegen::InheritTypes::{EventTargetTypeId, NodeCast, WindowDerived};
 use dom::bindings::error::{Error, Fallible, report_pending_exception};
 use dom::bindings::global::GlobalRef;
 use dom::bindings::global::global_object_for_js_object;
@@ -1385,9 +1384,3 @@ fn debug_reflow_events(goal: &ReflowGoal, query_type: &ReflowQueryType, reason:
 
     println!("{}", debug_msg);
 }
-
-impl WindowDerived for EventTarget {
-    fn is_window(&self) -> bool {
-        self.type_id() == &EventTargetTypeId::Window
-    }
-}

components/script/dom/xmlhttprequest.rs

@@ -10,8 +10,7 @@ use dom::bindings::codegen::Bindings::XMLHttpRequestBinding;
 use dom::bindings::codegen::Bindings::XMLHttpRequestBinding::XMLHttpRequestMethods;
 use dom::bindings::codegen::Bindings::XMLHttpRequestBinding::XMLHttpRequestResponseType;
 use dom::bindings::codegen::Bindings::XMLHttpRequestBinding::XMLHttpRequestResponseType::{Json, Text, _empty};
-use dom::bindings::codegen::InheritTypes::{EventCast, EventTargetCast, EventTargetTypeId};
+use dom::bindings::codegen::InheritTypes::{EventCast, EventTargetCast};
-use dom::bindings::codegen::InheritTypes::{XMLHttpRequestDerived, XMLHttpRequestEventTargetTypeId};
 use dom::bindings::codegen::UnionTypes::StringOrURLSearchParams;
 use dom::bindings::codegen::UnionTypes::StringOrURLSearchParams::{eString, eURLSearchParams};
 use dom::bindings::conversions::ToJSValConvertible;
@@ -24,7 +23,6 @@ use dom::bindings::str::ByteString;
 use dom::bindings::utils::{Reflectable, reflect_dom_object};
 use dom::document::Document;
 use dom::event::{Event, EventBubbles, EventCancelable};
-use dom::eventtarget::EventTarget;
 use dom::progressevent::ProgressEvent;
 use dom::xmlhttprequesteventtarget::XMLHttpRequestEventTarget;
 use dom::xmlhttprequestupload::XMLHttpRequestUpload;
@@ -728,16 +726,6 @@ impl XMLHttpRequestMethods for XMLHttpRequest {
     }
 }
 
-
-impl XMLHttpRequestDerived for EventTarget {
-    fn is_xmlhttprequest(&self) -> bool {
-        match *self.type_id() {
-            EventTargetTypeId::XMLHttpRequestEventTarget(XMLHttpRequestEventTargetTypeId::XMLHttpRequest) => true,
-            _ => false
-        }
-    }
-}
-
 pub type TrustedXHRAddress = Trusted<XMLHttpRequest>;
 
 

components/script/dom/xmlhttprequesteventtarget.rs

@@ -5,7 +5,6 @@
 use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
 use dom::bindings::codegen::Bindings::XMLHttpRequestEventTargetBinding::XMLHttpRequestEventTargetMethods;
 use dom::bindings::codegen::InheritTypes::EventTargetCast;
-use dom::bindings::codegen::InheritTypes::{EventTargetTypeId, XMLHttpRequestEventTargetDerived};
 use dom::eventtarget::EventTarget;
 
 #[dom_struct]
@@ -21,16 +20,6 @@ impl XMLHttpRequestEventTarget {
     }
 }
 
-impl XMLHttpRequestEventTargetDerived for EventTarget {
-    fn is_xmlhttprequesteventtarget(&self) -> bool {
-        match *self.type_id() {
-            EventTargetTypeId::XMLHttpRequestEventTarget(_) => true,
-            _ => false
-        }
-    }
-
-}
-
 impl XMLHttpRequestEventTargetMethods for XMLHttpRequestEventTarget {
     // https://xhr.spec.whatwg.org/#handler-xhr-onloadstart
     event_handler!(loadstart, GetOnloadstart, SetOnloadstart);

components/script/dom/xmlhttprequestupload.rs

@@ -3,13 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::XMLHttpRequestUploadBinding;
-use dom::bindings::codegen::InheritTypes::EventTargetTypeId;
-use dom::bindings::codegen::InheritTypes::XMLHttpRequestEventTargetTypeId;
-use dom::bindings::codegen::InheritTypes::XMLHttpRequestUploadDerived;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::utils::reflect_dom_object;
-use dom::eventtarget::EventTarget;
 use dom::xmlhttprequesteventtarget::XMLHttpRequestEventTarget;
 
 #[dom_struct]
@@ -29,10 +25,3 @@ impl XMLHttpRequestUpload {
                            XMLHttpRequestUploadBinding::Wrap)
     }
 }
-
-impl XMLHttpRequestUploadDerived for EventTarget {
-    fn is_xmlhttprequestupload(&self) -> bool {
-        *self.type_id() ==
-            EventTargetTypeId::XMLHttpRequestEventTarget(XMLHttpRequestEventTargetTypeId::XMLHttpRequestUpload)
-    }
-}