From 13ea3ac413c511872784ccde416956217746553c Mon Sep 17 00:00:00 2001 From: Anthony Ramine Date: Tue, 6 Oct 2015 17:21:44 +0200 Subject: Introduce trait Castable This trait is used to hold onto the downcast and upcast functions of all castable IDL interfaces. A castable IDL interface is one which either derives from or is derived by other interfaces. The deriving relation is represented by implementations of marker trait DerivedFrom generated in InheritTypes. /^[ ]*use dom::bindings::codegen::InheritTypes::.*(Base|Cast|Derived)/ { /::[a-zA-Z]+(Base|Cast|Derived);/d s/([{ ])[a-zA-Z]+(Base|Cast|Derived), /\1/g s/([{ ])[a-zA-Z]+(Base|Cast|Derived), /\1/g s/, [a-zA-Z]+(Base|Cast|Derived)([},])/\2/g s/, [a-zA-Z]+(Base|Cast|Derived)([},])/\2/g /\{([a-zA-Z]+(Base|Cast|Derived))?\};$/d s/\{([a-zA-Z_]+)\};$/\1;/ } s/([a-zA-Z]+)Cast::from_ref\(\&?\**([a-zA-Z_]+)(\.r\(\))?\)/\2.upcast::<\1>()/g s/([a-zA-Z]+)Cast::from_ref\(\&?\**([a-zA-Z_]+)(\.[a-zA-Z_]+\(\))?\)/\2\3.upcast::<\1>()/g s/\(([a-zA-Z]+)Cast::from_ref\)/\(Castable::upcast::<\1>\)/g s/([a-zA-Z]+)Cast::from_root/Root::upcast::<\1>/g s/([a-zA-Z]+)Cast::from_layout_js\(\&([a-zA-Z_.]+)\)/\2.upcast::<\1>()/g s/([a-zA-Z]+)Cast::to_ref\(\&?\**([a-zA-Z_]+)(\.r\(\))?\)/\2.downcast::<\1>()/g s/([a-zA-Z]+)Cast::to_ref\(\&?\**([a-zA-Z_]+)(\.[a-zA-Z_]+\(\))?\)/\2\3.downcast::<\1>()/g s/\(([a-zA-Z]+)Cast::to_ref\)/\(Castable::downcast::<\1>\)/g s/([a-zA-Z]+)Cast::to_root/Root::downcast::<\1>/g s/([a-zA-Z]+)Cast::to_layout_js\(&?([a-zA-Z_.]+(\(\))?)\)/\2.downcast::<\1>()/g s/\.is_document\(\)/.is::()/g s/\.is_htmlanchorelement\(\)/.is::()/g s/\.is_htmlappletelement\(\)/.is::()/g s/\.is_htmlareaelement\(\)/.is::()/g s/\.is_htmlbodyelement\(\)/.is::()/g s/\.is_htmlembedelement\(\)/.is::()/g s/\.is_htmlfieldsetelement\(\)/.is::()/g s/\.is_htmlformelement\(\)/.is::()/g s/\.is_htmlframesetelement\(\)/.is::()/g s/\.is_htmlhtmlelement\(\)/.is::()/g s/\.is_htmlimageelement\(\)/.is::()/g s/\.is_htmllegendelement\(\)/.is::()/g s/\.is_htmloptgroupelement\(\)/.is::()/g s/\.is_htmloptionelement\(\)/.is::()/g s/\.is_htmlscriptelement\(\)/.is::()/g s/\.is_htmltabledatacellelement\(\)/.is::()/g s/\.is_htmltableheadercellelement\(\)/.is::()/g s/\.is_htmltablerowelement\(\)/.is::()/g s/\.is_htmltablesectionelement\(\)/.is::()/g s/\.is_htmltitleelement\(\)/.is::()/g --- .../script/dom/bindings/codegen/CodegenRust.py | 125 ++------------------- 1 file changed, 9 insertions(+), 116 deletions(-) (limited to 'components/script/dom/bindings/codegen/CodegenRust.py') diff --git a/components/script/dom/bindings/codegen/CodegenRust.py b/components/script/dom/bindings/codegen/CodegenRust.py index 13a3cd51a1b..d42656ae0e7 100644 --- a/components/script/dom/bindings/codegen/CodegenRust.py +++ b/components/script/dom/bindings/codegen/CodegenRust.py @@ -5824,7 +5824,7 @@ class GlobalGenRoots(): descriptors = config.getDescriptors(register=True, isCallback=False) imports = [CGGeneric("use dom::types::*;\n"), - CGGeneric("use dom::bindings::conversions::{IDLInterface, get_dom_class};\n"), + CGGeneric("use dom::bindings::conversions::{Castable, DerivedFrom, get_dom_class};\n"), CGGeneric("use dom::bindings::js::{JS, LayoutJS, Root};\n"), CGGeneric("use dom::bindings::trace::JSTraceable;\n"), CGGeneric("use dom::bindings::utils::Reflectable;\n"), @@ -5839,131 +5839,24 @@ class GlobalGenRoots(): upcast = descriptor.hasDescendants() downcast = len(chain) != 1 - if upcast or downcast: - # Define a dummy structure to hold the cast functions. - allprotos.append(CGGeneric("pub struct %sCast;\n\n" % name)) - if upcast and not downcast: topTypes.append(name) - if upcast: - # Define a `FooBase` trait for subclasses to implement, as well as the - # `FooCast::from_*` methods that use it. - allprotos.append(CGGeneric("""\ -/// Types which are derived from `%(name)s` and can be freely converted -/// to `%(name)s` -pub trait %(baseTrait)s: Sized {} - -impl %(name)sCast { - #[inline] - /// Upcast an instance of a derived class of `%(name)s` to `%(name)s` - pub fn from_ref(derived: &T) -> &%(name)s { - unsafe { mem::transmute(derived) } - } - - #[inline] - #[allow(unrooted_must_root)] - pub fn from_layout_js(derived: &LayoutJS) -> LayoutJS<%(name)s> { - unsafe { mem::transmute_copy(derived) } - } - - #[inline] - pub fn from_root(derived: Root) -> Root<%(name)s> { - unsafe { mem::transmute(derived) } - } -} + if not upcast: + # No other interface will implement DeriveFrom for this Foo, so avoid + # implementing it for itself. + chain = chain[:-1] -""" % {'baseTrait': name + 'Base', 'name': name})) - else: - # The `FooBase` trait is not defined, so avoid implementing it by - # removing `Foo` itself from the chain. - chain = descriptor.prototypeChain[:-1] - - # Implement `BarBase` for `Foo`, for all `Bar` that `Foo` inherits from. + # Implement `DerivedFrom` for `Foo`, for all `Bar` that `Foo` inherits from. + if chain: + allprotos.append(CGGeneric("impl Castable for %s {}\n" % name)) for baseName in chain: - allprotos.append(CGGeneric("impl %s for %s {}\n" % (baseName + 'Base', name))) + allprotos.append(CGGeneric("impl DerivedFrom<%s> for %s {}\n" % (baseName, name))) if chain: allprotos.append(CGGeneric("\n")) if downcast: hierarchy[descriptor.getParentName()].append(name) - # Define a `FooDerived` trait for superclasses to implement, - # as well as the `FooCast::to_*` methods that use it. - baseName = descriptor.prototypeChain[0] - args = { - 'baseName': baseName, - 'derivedTrait': name + 'Derived', - 'methodName': 'is_' + name.lower(), - 'name': name, - } - allprotos.append(CGGeneric("""\ -/// Types which `%(name)s` derives from -pub trait %(derivedTrait)s: Sized { - fn %(methodName)s(&self) -> bool; -} - -impl %(name)sCast { - #[inline] - /// Downcast an instance of a base class of `%(name)s` to an instance of - /// `%(name)s`, if it internally is an instance of `%(name)s` - pub fn to_ref(base: &T) -> Option<&%(name)s> { - match base.%(methodName)s() { - true => Some(unsafe { mem::transmute(base) }), - false => None - } - } - - #[inline] - #[allow(unrooted_must_root)] - pub fn to_layout_js(base: &LayoutJS) -> Option> { - unsafe { - match (*base.unsafe_get()).%(methodName)s() { - true => Some(mem::transmute_copy(base)), - false => None - } - } - } - - #[inline] - pub fn to_root(base: Root) -> Option> { - match base.%(methodName)s() { - true => Some(unsafe { mem::transmute(base) }), - false => None - } - } -} - -impl %(derivedTrait)s for %(baseName)s { - fn %(methodName)s(&self) -> bool { - let dom_class = unsafe { - get_dom_class(self.reflector().get_jsobject().get()).unwrap() - }; - %(name)s::derives(dom_class) - } -} - -""" % args)) - - # Implement the `FooDerived` trait for non-root superclasses by deferring to - # the direct superclass. This leaves the implementation of the `FooDerived` - # trait for the root superclass to manual code. `FooDerived` is not - # implemented for `Foo` itself. - for baseName in descriptor.prototypeChain[1:-1]: - args = { - 'baseName': baseName, - 'derivedTrait': name + 'Derived', - 'methodName': 'is_' + name.lower(), - 'parentName': config.getDescriptor(baseName).getParentName(), - } - allprotos.append(CGGeneric("""\ -impl %(derivedTrait)s for %(baseName)s { - #[inline] - fn %(methodName)s(&self) -> bool { - %(parentName)sCast::from_ref(self).%(methodName)s() - } -} - -""" % args)) typeIdCode = [] topTypeVariants = [ -- cgit v1.2.3