Use original WebKit IDL database for dart:html generation.

lib/dom/scripts/systemhtml.py

Index: lib/dom/scripts/systemhtml.py
diff --git a/lib/dom/scripts/systemhtml.py b/lib/dom/scripts/systemhtml.py
index 11963edaf4b2acf5c170f548605ff342222e1ca7..76ac6868ba02d6cd2cb868a22331225ffd4c7e66 100644
--- a/lib/dom/scripts/systemhtml.py
+++ b/lib/dom/scripts/systemhtml.py
@@ -9,6 +9,20 @@ Dart:html APIs from the IDL database."""
 from systemfrog import *
 from systeminterface import *
 
+_html_strip_webkit_prefix_classes = [
+    'Animation',
+    'AnimationEvent',
+    'AnimationList',
+    'BlobBuilder',
+    'CSSKeyframeRule',
+    'CSSKeyframesRule',
+    'CSSMatrix',
+    'CSSTransformValue',
+    'Flags',
+    'LoseContext',
+    'Point',
+    'TransitionEvent']
+
 # Members from the standard dom that should not be exposed publicly in dart:html
 # but need to be exposed internally to implement dart:html on top of a standard
 # browser.
@@ -592,13 +606,46 @@ class HtmlSystemShared(object):
     self._seen_event_names = {}
     self._database = database
     self._inheritance_closure = _ComputeInheritanceClosure(database)
+    self._html_renames = self._MakeHtmlRenames()
+
+  def _HasAncestor(self, interface, names_to_match):
+    for parent in interface.parents:
+      if (parent.type.id in names_to_match or

[Anton Muhin, 2012/06/07 11:43:47]

up to you, but I find it somewhat hard to read, what about

if parent.type.id in names_to_match: return True
if not self._database.HasInterface(parent.type.id): continue
if self._HasAncestor(self._data....)

plus I believed we either already have or was dreaming of generic traversal of
inheritance chain, I'd suggest something like

def AllParents(interface, database):
  for parent in interface.parents:
    yield parent
    if not database.HasInterface(parent.type.id): continue
    for child in Parents(database.GetInterface(parent.type.id)):
      yield child

Now you can have a very nice _HasAncestor:

def _HasAncestor(self, interface, names_to_match):
  return any(parent.type.id in names_to_match for parent in
AllParents(interface, self._database)

[podivilov, 2012/06/08 18:03:25]

Done.

+          (self._database.HasInterface(parent.type.id) and
+          self._HasAncestor(self._database.GetInterface(parent.type.id),
+              names_to_match))):
+        return True
+    return False
+
+  def _MakeHtmlRenames(self):
+    html_renames = {}
+
+    for interface in self._database.GetInterfaces():
+      if (interface.id.startswith("HTML") and

[Anton Muhin, 2012/06/07 11:43:47]

nit: single quote strings, please

[podivilov, 2012/06/08 18:03:25]

Done.

+          self._HasAncestor(interface, ['Element', 'Document'])):
+        html_renames[interface.id] = interface.id[4:]
+
+    for subclass in _html_strip_webkit_prefix_classes:
+      html_renames['WebKit' + subclass] = subclass
+
+    # TODO(jacobr): we almost want to add this commented out line back.
+    #    html_renames['HTMLCollection'] = 'ElementList'
+    #    html_renames['NodeList'] = 'ElementList'
+    #    html_renames['HTMLOptionsCollection'] = 'ElementList'
+    html_renames['DOMWindow'] = 'Window'
+
+    return html_renames
+
+  def _HTMLInterfaceName(self, interface_name):
+    return self._html_renames.get(interface_name, interface_name)
 
   def _FindMatch(self, interface_name, member, member_prefix, candidates):
     for ancestor_name in self._AllAncestorInterfaces(interface_name):
-      name = ancestor_name + '.' + member
+      name = self._HTMLInterfaceName(ancestor_name) + '.' + member
       if name in candidates:
         return name
-      name = interface_name + '.' + member_prefix + member
+      name = self._HTMLInterfaceName(interface_name) + '.' + member_prefix +
+             member
       if name in candidates:
         return name
     return None
@@ -686,6 +733,10 @@ class HtmlSystemShared(object):
   def IsPrivate(self, name):
     return name.startswith('_')
 
+  def DartType(self, idl_type):
+    type_info = GetIDLTypeInfo(idl_type)
+    return self._HTMLInterfaceName(type_info.dart_type())
+
 class HtmlSystem(System):
 
   def __init__(self, templates, database, emitters, output_dir):
@@ -710,14 +761,15 @@ class HtmlInterfacesSystem(HtmlSystem):
     if interface.id in _merged_html_interfaces.values():
       return None
 
-    interface_name = interface.id
-    dart_interface_file_path = self._FilePathForDartInterface(interface_name)
+    html_interface_name = self._shared._HTMLInterfaceName(interface.id)
+    dart_interface_file_path =
+        self._FilePathForDartInterface(html_interface_name)
 
     self._dart_interface_file_paths.append(dart_interface_file_path)
 
     dart_interface_code = self._emitters.FileEmitter(dart_interface_file_path)
 
-    template_file = 'interface_%s.darttemplate' % interface_name
+    template_file = 'interface_%s.darttemplate' % html_interface_name
     template = self._templates.TryLoad(template_file)
     if not template:
       template = self._templates.Load('interface.darttemplate')
@@ -756,9 +808,11 @@ class HtmlDartInterfaceGenerator(DartInterfaceGenerator):
     super(HtmlDartInterfaceGenerator, self).__init__(system, interface,
       emitter, template, common_prefix, super_interface, source_filter)
     self._shared = shared
+    self._html_interface_name =
+        self._shared._HTMLInterfaceName(self._interface.id)
 
   def StartInterface(self):
-    typename = self._interface.id
+    typename = self._html_interface_name
 
     extends = []
     suppressed_extends = []
@@ -767,14 +821,14 @@ class HtmlDartInterfaceGenerator(DartInterfaceGenerator):
       # TODO(vsm): Remove source_filter.
       if MatchSourceFilter(self._source_filter, parent):
         # Parent is a DOM type.
-        extends.append(DartType(parent.type.id))
+        extends.append(self._shared.DartType(parent.type.id))
       elif '<' in parent.type.id:
         # Parent is a Dart collection type.
         # TODO(vsm): Make this check more robust.
-        extends.append(DartType(parent.type.id))
+        extends.append(self._shared.DartType(parent.type.id))
       else:
         suppressed_extends.append('%s.%s' %
-            (self._common_prefix, DartType(parent.type.id)))
+            (self._common_prefix, self._shared.DartType(parent.type.id)))
 
     comment = ' extends'
     extends_str = ''
@@ -820,8 +874,9 @@ class HtmlDartInterfaceGenerator(DartInterfaceGenerator):
       self._members_emitter.Emit(
           '\n'
           '  $CTOR($PARAMS);\n',
-          CTOR=constructor_info.ConstructorFullName(),
-          PARAMS=constructor_info.ParametersInterfaceDeclaration());
+          CTOR=self._shared.DartType(constructor_info.ConstructorFullName()),
+          PARAMS=constructor_info.ParametersInterfaceDeclaration(
+                     self._shared.DartType));
 
     element_type = MaybeTypedArrayElementTypeInHierarchy(
         self._interface, self._system._database)
@@ -835,7 +890,7 @@ class HtmlDartInterfaceGenerator(DartInterfaceGenerator):
           '  $CTOR.fromBuffer(ArrayBuffer buffer,'
                             ' [int byteOffset, int length]);\n',
         CTOR=self._interface.id,
-        TYPE=DartType(element_type))
+        TYPE=self._shared.DartType(element_type))
 
     emit_events, events = self._shared.GetEventAttributes(self._interface)
     if not emit_events:
@@ -871,15 +926,15 @@ class HtmlDartInterfaceGenerator(DartInterfaceGenerator):
         DOMINTERFACE=getter.doc_js_interface_name,
         DOMNAME=dom_name)
     if (getter and setter and
-        DartType(getter.type.id) == DartType(setter.type.id)):
+        getter.type.id == setter.type.id):
       self._members_emitter.Emit('\n  $TYPE $NAME;\n',
                                  NAME=html_getter_name,
-                                 TYPE=DartType(getter.type.id));
+                                 TYPE=self._shared.DartType(getter.type.id));
       return
     if getter and not setter:
       self._members_emitter.Emit('\n  final $TYPE $NAME;\n',
                                  NAME=html_getter_name,
-                                 TYPE=DartType(getter.type.id));
+                                 TYPE=self._shared.DartType(getter.type.id));
       return
     raise Exception('Unexpected getter/setter combination %s %s' %
                     (getter, setter))
@@ -899,9 +954,10 @@ class HtmlDartInterfaceGenerator(DartInterfaceGenerator):
 
       self._members_emitter.Emit('\n'
                                  '  $TYPE $NAME($PARAMS);\n',
-                                 TYPE=info.type_name,
+                                 TYPE=self._shared.DartType(info.type_name),
                                  NAME=html_name,
-                                 PARAMS=info.ParametersInterfaceDeclaration())
+                                 PARAMS=info.ParametersInterfaceDeclaration(
+                                        self._shared.DartType))
 
   def FinishInterface(self):
     pass
@@ -910,9 +966,9 @@ class HtmlDartInterfaceGenerator(DartInterfaceGenerator):
     self._EmitConstant(self._members_emitter, constant)
 
   def AddEventAttributes(self, event_attrs):
-    event_attrs = DomToHtmlEvents(self._interface.id, event_attrs)
+    event_attrs = DomToHtmlEvents(self._html_interface_name, event_attrs)
     self._shared._event_classes.add(self._interface.id)
-    events_interface = self._interface.id + 'Events'
+    events_interface = self._html_interface_name + 'Events'
     self._EmitEventGetter(events_interface)
 
     events_members = self._emitter.Emit(
@@ -951,15 +1007,22 @@ class HtmlFrogClassGenerator(FrogInterfaceGenerator):
     super(HtmlFrogClassGenerator, self).__init__(
         system, interface, template, super_interface, dart_code)
     self._shared = shared
+    self._html_interface_name =
+       self._shared._HTMLInterfaceName(self._interface.id)
 
   def _ImplClassName(self, type_name):
     return self._shared._ImplClassName(type_name)
 
+  def _NarrowToImplementationType(self, type_name):
+    if self._ShouldNarrowToImplementationType(type_name):
+      return self._ImplClassName(self._shared.DartType(type_name))
+    return self._shared.DartType(type_name)
+
   def StartInterface(self):
     interface = self._interface
     interface_name = interface.id
 
-    self._class_name = self._ImplClassName(interface_name)
+    self._class_name = self._ImplClassName(self._html_interface_name)
 
     base = None
     if interface.parents:
@@ -970,17 +1033,17 @@ class HtmlFrogClassGenerator(FrogInterfaceGenerator):
       elif IsPureInterface(supertype):
         pass
       else:
-        base = self._ImplClassName(supertype)
+        base = self._ImplClassName(self._shared._HTMLInterfaceName(supertype))
 
     native_spec = MakeNativeSpec(interface.javascript_binding_name)
 
     extends = ' extends ' + base if base else ''
 
     # TODO: Include all implemented interfaces, including other Lists.
-    implements = [interface_name]
+    implements = [self._html_interface_name]
     element_type = MaybeTypedArrayElementType(self._interface)
     if element_type:
-      implements.append('List<%s>' % DartType(element_type))
+      implements.append('List<%s>' % self._shared.DartType(element_type))
 
     self._members_emitter = self._dart_code.Emit(
         self._template,
@@ -998,9 +1061,9 @@ class HtmlFrogClassGenerator(FrogInterfaceGenerator):
     # Emit a factory provider class for the constructor.
     constructor_info = AnalyzeConstructor(interface)
     if constructor_info:
-      self._EmitFactoryProvider(interface_name, constructor_info)
+      self._EmitFactoryProvider(constructor_info)
 
-    infos = HtmlElementConstructorInfos(interface_name)
+    infos = HtmlElementConstructorInfos(self._html_interface_name)
     if infos:
       self._EmitHtmlElementFactoryConstructors(infos)
 
@@ -1017,20 +1080,21 @@ class HtmlFrogClassGenerator(FrogInterfaceGenerator):
       merged_interface = _merged_html_interfaces[self._interface.id]
       self.AddMembers(self._database.GetInterface(merged_interface))
 
-  def _EmitFactoryProvider(self, interface_name, constructor_info):
-    template_file = 'factoryprovider_%s.darttemplate' % interface_name
+  def _EmitFactoryProvider(self, constructor_info):
+    template_file = 'factoryprovider_%s.darttemplate' %
+                        self._html_interface_name
     template = self._system._templates.TryLoad(template_file)
     if not template:
       template = self._system._templates.Load('factoryprovider.darttemplate')
 
-    factory_provider = '_' + interface_name + 'FactoryProvider'
+    factory_provider = '_' + self._html_interface_name + 'FactoryProvider'
     emitter = self._system._ImplFileEmitter(factory_provider)
     emitter.Emit(
         template,
         FACTORYPROVIDER=factory_provider,
-        CONSTRUCTOR=interface_name,
+        CONSTRUCTOR=self._html_interface_name,
         PARAMETERS=constructor_info.ParametersImplementationDeclaration(),
-        NAMED_CONSTRUCTOR=constructor_info.name or interface_name,
+        NAMED_CONSTRUCTOR=constructor_info.name or self._html_interface_name,
         ARGUMENTS=constructor_info.ParametersAsArgumentList())
 
   def _EmitHtmlElementFactoryConstructors(self, infos):
@@ -1038,7 +1102,7 @@ class HtmlFrogClassGenerator(FrogInterfaceGenerator):
         self._system._EmitterForFactoryProviderBody(
             infos[0].factory_provider_name),
         infos,
-        self._interface.id, self._class_name)
+        self._html_interface_name, self._class_name)
 
   def AddIndexer(self, element_type):
     """Adds all the methods required to complete implementation of List."""
@@ -1086,7 +1150,7 @@ class HtmlFrogClassGenerator(FrogInterfaceGenerator):
     if self._interface.id != 'NodeList':
       template_file = 'immutable_list_mixin.darttemplate'
       template = self._system._templates.Load(template_file)
-      self._members_emitter.Emit(template, E=DartType(element_type))
+      self._members_emitter.Emit(template, E=self._shared.DartType(element_type))
 
   def AddAttribute(self, getter, setter):
     dom_name = DartDomNameOfAttribute(getter or setter)
@@ -1125,7 +1189,7 @@ class HtmlFrogClassGenerator(FrogInterfaceGenerator):
     (super_setter, super_setter_interface) = self._FindShadowedAttribute(setter)
     if super_getter or super_setter:
       if getter and not setter and super_getter and not super_setter:
-        if DartType(getter.type.id) == DartType(super_getter.type.id):
+        if getter.type.id == super_getter.type.id:
           # Compatible getter, use the superclass property.  This works because
           # JavaScript will do its own dynamic dispatch.
           output_type = getter and self._NarrowOutputType(getter.type.id)
@@ -1223,9 +1287,9 @@ class HtmlFrogClassGenerator(FrogInterfaceGenerator):
               lambda type_name: self._NarrowInputType(type_name)))
 
   def AddEventAttributes(self, event_attrs):
-    event_attrs = DomToHtmlEvents(self._interface.id, event_attrs)
-    events_class = '_' + self._interface.id + 'EventsImpl'
-    events_interface = self._interface.id + 'Events'
+    event_attrs = DomToHtmlEvents(self._html_interface_name, event_attrs)
+    events_class = '_' + self._html_interface_name + 'EventsImpl'
+    events_interface = self._html_interface_name + 'Events'
     self._EmitEventGetter(events_class)
 
     self._shared._event_classes.add(self._interface.id)
@@ -1278,12 +1342,14 @@ class HtmlFrogSystem(HtmlSystem):
 
     if IsPureInterface(interface.id):
       return
-    template_file = 'impl_%s.darttemplate' % interface.id
+
+    html_interface_name = self._shared._HTMLInterfaceName(interface.id)
+    template_file = 'impl_%s.darttemplate' % html_interface_name
     template = self._templates.TryLoad(template_file)
     if not template:
       template = self._templates.Load('frog_impl.darttemplate')
 
-    dart_code = self._ImplFileEmitter(interface.id)
+    dart_code = self._ImplFileEmitter(html_interface_name)
     return HtmlFrogClassGenerator(self, interface, template,
                                   super_interface_name, dart_code, self._shared)