Use original WebKit IDL database for dart:html generation.

lib/dom/scripts/systemhtml.py

 #!/usr/bin/python
 # Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 # for details. All rights reserved. Use of this source code is governed by a
 # BSD-style license that can be found in the LICENSE file.
 
 """This module provides shared functionality for the system to generate
 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.
 _private_html_members = set([
   'Document.createElement',
   'Document.createElementNS',
   'Document.createEvent',
   'Document.createTextNode',
   'Document.createTouchList',
   'Document.getElementById',
@@ skipping 563 matching lines @@
   return _html_event_names[event_name]
 
 # ------------------------------------------------------------------------------
 class HtmlSystemShared(object):
 
   def __init__(self, database):
     self._event_classes = set()
     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
 
   def _AllAncestorInterfaces(self, interface_name):
     return [interface_name] + self._inheritance_closure[interface_name]
 
   def RenameInHtmlLibrary(self, interface_name, member, member_prefix='',
                           implementation_class=False):
     """
@@ skipping 67 matching lines @@
                    if attr.type.id == 'EventListener'])
 
     if events or interface.id in _html_explicit_event_classes:
       return True, events
     else:
       return False, None
 
   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):
     super(HtmlSystem, self).__init__(
         templates, database, emitters, output_dir)
     self._shared = HtmlSystemShared(database)
 
 class HtmlInterfacesSystem(HtmlSystem):
 
   def __init__(self, templates, database, emitters, output_dir):
     super(HtmlInterfacesSystem, self).__init__(
         templates, database, emitters, output_dir)
     self._dart_interface_file_paths = []
     self._factory_provider_emitters = {}
 
   def InterfaceGenerator(self,
                          interface,
                          common_prefix,
                          super_interface_name,
                          source_filter):
     """."""
     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')
 
     return HtmlDartInterfaceGenerator(
         self, interface, dart_interface_code,
         template,
         common_prefix, super_interface_name,
         source_filter, self._shared)
 
@@ skipping 18 matching lines @@
 # TODO(jmesserly): inheritance is probably not the right way to factor this long
 # term, but it makes merging better for now.
 class HtmlDartInterfaceGenerator(DartInterfaceGenerator):
   """Generates Dart Interface definition for one DOM IDL interface."""
 
   def __init__(self, system, interface, emitter, template,
                common_prefix, super_interface, source_filter, shared):
     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 = []
 
     for parent in self._interface.parents:
       # 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 = ''
     if extends:
       extends_str += ' extends ' + ', '.join(extends)
       comment = ','
     if suppressed_extends:
       extends_str += ' /*%s %s */' % (comment, ', '.join(suppressed_extends))
 
     factory_provider = None
@@ skipping 25 matching lines @@
          ID=typename,
          EXTENDS=extends_str)
 
     self._type_comment_emitter.Emit("/// @domName $DOMNAME",
         DOMNAME=self._interface.doc_js_name)
 
     for constructor_info in constructors:
       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)
     if element_type:
       self._members_emitter.Emit(
           '\n'
           '  $CTOR(int length);\n'
           '\n'
           '  $CTOR.fromList(List<$TYPE> list);\n'
           '\n'
           '  $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:
       return
     elif events:
       self.AddEventAttributes(events)
     else:
       self._EmitEventGetter(self._shared.GetParentEventsClass(self._interface))
 
     if self._interface.id in _merged_html_interfaces:
@@ skipping 15 matching lines @@
       return
 
     # We don't yet handle inconsistent renames of the getter and setter yet.
     if html_getter_name and html_setter_name:
       assert html_getter_name == html_setter_name
 
     self._members_emitter.Emit('\n  /** @domName $DOMINTERFACE.$DOMNAME */',
         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))
 
   def AddOperation(self, info):
     """
     Arguments:
       operations - contains the overloads, one or more operations with the same
         name.
     """
     html_name = self._shared.RenameInHtmlLibrary(
         self._interface.id, info.name)
     if html_name and not self._shared.IsPrivate(html_name):
       self._members_emitter.Emit('\n  /** @domName $DOMINTERFACE.$DOMNAME */',
           DOMINTERFACE=info.overloads[0].doc_js_interface_name,
           DOMNAME=info.name)
 
       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
 
   def AddConstant(self, constant):
     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(
         '\ninterface $INTERFACE extends $PARENTS {\n$!MEMBERS}\n',
         INTERFACE=events_interface,
         PARENTS=', '.join(
             self._shared.GetParentsEventsClasses(self._interface)))
 
     for event_name in event_attrs:
       if event_name in _html_event_names:
@@ skipping 18 matching lines @@
 class HtmlFrogClassGenerator(FrogInterfaceGenerator):
   """Generates a Frog class for the dart:html library from a DOM IDL
   interface.
   """
 
   def __init__(self, system, interface, template, super_interface, dart_code,
       shared):
     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:
       supertype = interface.parents[0].type.id
       if IsDartCollectionType(supertype):
         # List methods are injected in AddIndexer.
         pass
       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,
         #class $CLASSNAME$EXTENDS$IMPLEMENTS$NATIVESPEC {
         #$!MEMBERS
         #}
         CLASSNAME=self._class_name,
         EXTENDS=extends,
         IMPLEMENTS=' implements ' + ', '.join(implements),
         NATIVESPEC=' native "' + native_spec + '"')
     if self._members_emitter == None:
       raise Exception("Class %s doesn't use the $!MEMBERS variable" %
                       self._class_name)
 
     # 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)
 
     emit_events, events = self._shared.GetEventAttributes(self._interface)
     if not emit_events:
       return
     elif events:
       self.AddEventAttributes(events)
     else:
       parent_events_class = self._shared.GetParentEventsClass(self._interface)
       self._EmitEventGetter('_' + parent_events_class + 'Impl')
 
     if self._interface.id in _merged_html_interfaces:
       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):
     EmitHtmlElementFactoryConstructors(
         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."""
     # We would like to simply inherit the implementation of everything except
     # get length(), [], and maybe []=.  It is possible to extend from a base
     # array implementation class only when there is no other implementation
     # inheritance.  There might be no implementation inheritance other than
     # DOMBaseWrapper for many classes, but there might be some where the
     # array-ness is introduced by a non-root interface:
     #
@@ skipping 27 matching lines @@
             '  void operator[]=(int index, $TYPE value) {\n'
             '    throw new UnsupportedOperationException("Cannot assign element of immutable List.");\n'
             '  }\n',
             TYPE=self._NarrowInputType(element_type))
 
     # TODO(sra): Use separate mixins for mutable implementations of List<T>.
     # TODO(sra): Use separate mixins for typed array implementations of List<T>.
     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)
     html_getter_name = None
     if not self._shared.IsCustomInHtmlLibrary(
         self._interface, dom_name, 'get:'):
       html_getter_name = self._shared.RenameInHtmlLibrary(
           self._interface.id, dom_name, 'get:',
           implementation_class=True)
     html_setter_name = None
@@ skipping 18 matching lines @@
       if setter:
         self._AddRenamingSetter(setter, html_setter_name)
       return
 
     # If the (getter, setter) pair is shadowing, we can't generate a shadowing
     # field (Issue 1633).
     (super_getter, super_getter_interface) = self._FindShadowedAttribute(getter)
     (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)
           self._members_emitter.Emit(
               '\n'
               '  // Use implementation from $SUPER.\n'
               '  // final $TYPE $NAME;\n',
               SUPER=super_getter_interface.id,
               NAME=DartDomNameOfAttribute(getter),
               TYPE=output_type)
@@ skipping 77 matching lines @@
     else:
       self._members_emitter.Emit(
           '\n'
           '  $TYPE $NAME($PARAMS) native;\n',
           TYPE=self._NarrowOutputType(info.type_name),
           NAME=info.name,
           PARAMS=info.ParametersImplementationDeclaration(
               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)
 
     parent_event_class = self._shared.GetParentEventsClass(self._interface)
 
     # TODO(jacobr): specify the type of _ptr as EventTarget
     events_members = self._dart_code.Emit(
         '\n'
         'class $CLASSNAME extends $SUPER implements $INTERFACE {\n'
@@ skipping 32 matching lines @@
                          interface,
                          common_prefix,
                          super_interface_name,
                          source_filter):
     """."""
     if interface.id in _merged_html_interfaces.values():
       return None
 
     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)
 
   def GenerateLibraries(self):
     self._GenerateLibFile(
         'html_frog.darttemplate',
         os.path.join(self._output_dir, 'html_frog.dart'),
         (self._interface_system._dart_interface_file_paths +
          self._interface_system._dart_callback_file_paths +
          self._dart_frog_file_paths))
@@ skipping 73 matching lines @@
             Collect(database.GetInterface(parent.type.id),
                     seen, collected)
 
   inheritance_closure = {}
   for interface in database.GetInterfaces():
     seen = set()
     collected = []
     Collect(interface, seen, collected)
     inheritance_closure[interface.id] = collected
   return inheritance_closure