Unfork html events generation in dart2js and dartium.

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."""
 
 import emitter
 
@@ skipping 861 matching lines @@
     (self._type_comment_emitter,
      self._members_emitter,
      self._top_level_emitter) = self._interface_emitter.Emit(
          interface_template + '$!TOP_LEVEL',
          ID=typename,
          EXTENDS=extends_str)
 
     self._type_comment_emitter.Emit("/// @domName $DOMNAME",
         DOMNAME=self._interface.doc_js_name)
 
+    if self._backend.HasImplementation():
+      path = self._backend.FilePathForDartImplementation()
+      self._system._dart_interface_file_paths.append(path)
+      self._implementation_emitter = self._system._emitters.FileEmitter(path)
+    else:
+      self._implementation_emitter = emitter.Emitter()
+    self._backend.SetImplementationEmitter(self._implementation_emitter)
+    self._implementation_members_emitter = self._backend.StartInterface()
+
     for constructor_info in constructors:
       self._members_emitter.Emit(
           '\n'
           '  $CTOR($PARAMS);\n',
           CTOR=self._shared.DartType(constructor_info.ConstructorFullName()),
           PARAMS=constructor_info.ParametersInterfaceDeclaration(
                      self._shared.DartType));
 
     if infos:
       EmitHtmlElementFactoryConstructors(
@@ skipping 10 matching lines @@
           '\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=self._shared.DartType(element_type))
 
-    emit_events, events = self._shared.GetEventAttributes(self._interface)
-    if emit_events:
-      if events:
-        self.AddEventAttributes(events)
-      else:
-        self._EmitEventGetter(self._shared.GetParentEventsClass(self._interface))
+    self._GenerateEvents()
 
     for merged_interface in _merged_html_interfaces:
       if _merged_html_interfaces[merged_interface] == self._interface.id:
-        self.AddMembers(self._database.GetInterface(merged_interface))
+        merged_interface = self._database.GetInterface(merged_interface)
+        self.AddMembers(merged_interface)
+        self._backend.AddMergedMembers(merged_interface)
 
-    # Generate implementation.
-    if self._backend.HasImplementation():
-      path = self._backend.FilePathForDartImplementation()
-      self._system._dart_interface_file_paths.append(path)
-      implementation_emitter = self._system._emitters.FileEmitter(path)
-    else:
-      implementation_emitter = emitter.Emitter()
-    self._backend.SetImplementationEmitter(implementation_emitter)
-    self._backend.Generate()
+    self._backend.AddMembers(self._interface)
+    self._backend.AddSecondaryMembers(self._interface)
+    self._backend.FinishInterface()
 
   def AddAttribute(self, getter, setter):
     dom_name = DartDomNameOfAttribute(getter)
     html_getter_name = self._shared.RenameInHtmlLibrary(
       self._interface.id, dom_name, 'get:')
     html_setter_name = self._shared.RenameInHtmlLibrary(
       self._interface.id, dom_name, 'set:')
 
     if not html_getter_name or self._shared.IsPrivate(html_getter_name):
       getter = None
@@ skipping 46 matching lines @@
   def FinishInterface(self):
     pass
 
   def AddConstant(self, constant):
     type = TypeOrNothing(DartType(constant.type.id), constant.type.id)
     self._members_emitter.Emit('\n  static final $TYPE$NAME = $VALUE;\n',
                                NAME=constant.id,
                                TYPE=type,
                                VALUE=constant.value)
 
-  def AddEventAttributes(self, event_attrs):
-    event_attrs = DomToHtmlEvents(self._html_interface_name, event_attrs)
+  def _GenerateEvents(self):
+    emit_events, event_attrs = self._shared.GetEventAttributes(self._interface)
+    if not emit_events:
+      return
+
     self._shared._event_classes.add(self._interface.id)
     events_interface = self._html_interface_name + 'Events'
-    self._EmitEventGetter(events_interface)
+    events_class = '_%sImpl' % events_interface
+    parent_events_interface = self._shared.GetParentEventsClass(self._interface)
+    parent_events_class = '_%sImpl' % parent_events_interface
+
+    if not event_attrs:
+      self._EmitEventGetter(parent_events_interface, parent_events_class)
+      return
+
+    self._EmitEventGetter(events_interface, events_class)
 
     events_members = self._interface_emitter.Emit(
         '\ninterface $INTERFACE extends $PARENTS {\n$!MEMBERS}\n',
         INTERFACE=events_interface,
         PARENTS=', '.join(
             self._shared.GetParentsEventsClasses(self._interface)))
 
+    # TODO(jacobr): specify the type of _ptr as EventTarget
+    implementation_events_members = self._implementation_emitter.Emit(
+        '\n'
+        'class $CLASSNAME extends $SUPER implements $INTERFACE {\n'
+        '  $CLASSNAME(_ptr) : super(_ptr);\n'
+        '$!MEMBERS}\n',
+        CLASSNAME=events_class,
+        INTERFACE=events_interface,
+        SUPER=parent_events_class)
+
+    event_attrs = DomToHtmlEvents(self._html_interface_name, event_attrs)
     for event_name in event_attrs:
       if event_name in _html_event_names:
         events_members.Emit('\n  EventListenerList get $NAME();\n',
           NAME=_html_event_names[event_name])
+        implementation_events_members.Emit(
+            "\n"
+            "  EventListenerList get $NAME() => this['$DOM_NAME'];\n",
+            NAME=_html_event_names[event_name],
+            DOM_NAME=event_name)
       else:
         raise Exception('No known html even name for event: ' + event_name)
 
-  def _EmitEventGetter(self, events_interface):
+  def _EmitEventGetter(self, events_interface, events_class):
     self._members_emitter.Emit(
         '\n  /**'
         '\n   * @domName EventTarget.addEventListener, '
         'EventTarget.removeEventListener, EventTarget.dispatchEvent'
         '\n   */'
         '\n  $TYPE get on();\n',
         TYPE=events_interface)
 
+    self._implementation_members_emitter.Emit(
+        '\n  $TYPE get on() =>\n    new $TYPE(this);\n',
+        TYPE=events_class)
+
+
 # ------------------------------------------------------------------------------
 
 # TODO(jmesserly): inheritance is probably not the right way to factor this long
 # term, but it makes merging better for now.
 class HtmlFrogClassGenerator(FrogInterfaceGenerator):
   """Generates a Frog class for the dart:html library from a DOM IDL
   interface.
   """
 
   def __init__(self, system, interface):
@@ skipping 10 matching lines @@
   def ImplementationClassName(self):
     return self._ImplClassName(self._html_interface_name)
 
   def FilePathForDartImplementation(self):
     return os.path.join(self._system._output_dir, 'html', 'frog',
                         '%s.dart' % self._html_interface_name)
 
   def SetImplementationEmitter(self, implementation_emitter):
     self._dart_code = implementation_emitter
 
+  def AddMergedMembers(self, merged_interface):
+    self.AddMembers(merged_interface)
+
   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
@@ skipping 37 matching lines @@
         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(constructor_info)
 
-    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')
-
-    for merged_interface in _merged_html_interfaces:
-      if _merged_html_interfaces[merged_interface] == self._interface.id:
-        self.AddMembers(self._database.GetInterface(merged_interface))
+    return self._members_emitter
 
   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 = '_' + self._html_interface_name + 'FactoryProvider'
     emitter = self._system._ImplFileEmitter(factory_provider)
@@ skipping 180 matching lines @@
           '  $TYPE $(HTML_NAME)($PARAMS) native "$NAME";\n')
     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._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'
-        '  $CLASSNAME(_ptr) : super(_ptr);\n'
-        '$!MEMBERS}\n',
-        CLASSNAME=events_class,
-        INTERFACE=events_interface,
-        SUPER='_' + parent_event_class + 'Impl')
-
-    for event_name in event_attrs:
-      if event_name in _html_event_names:
-        events_members.Emit(
-            "\n"
-            "  EventListenerList get $NAME() => this['$RAWNAME'];\n",
-            RAWNAME=event_name,
-            NAME=_html_event_names[event_name])
-      else:
-        raise Exception('No known html even name for event: ' + event_name)
-
-  def _EmitEventGetter(self, events_class):
-    self._members_emitter.Emit(
-        '\n  $TYPE get on() =>\n    new $TYPE(this);\n',
-        TYPE=events_class)
-
 # ------------------------------------------------------------------------------
 
 class HtmlFrogSystem(HtmlSystem):
 
   def __init__(self, templates, database, emitters, output_dir):
     super(HtmlFrogSystem, self).__init__(
         templates, database, emitters, output_dir)
     self._dart_frog_file_paths = []
     self._factory_provider_emitters = {}
 
@@ skipping 40 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