Split backend.AddMembers call into series of backend.AddAtribute/backend.AddOperation calls.

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 914 matching lines @@
           '\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))
 
     self._GenerateEvents()
 
+    old_backend = self._backend
+    if not old_backend.ImplementsMergedMembers():
+      self._backend = HtmlGeneratorDummyBackend()
     for merged_interface in _merged_html_interfaces:
       if _merged_html_interfaces[merged_interface] == self._interface.id:
         merged_interface = self._database.GetInterface(merged_interface)
         self.AddMembers(merged_interface)
-        self._backend.AddMergedMembers(merged_interface)
+    self._backend = old_backend
 
-    self._backend.AddMembers(self._interface)
-    self._backend.AddSecondaryMembers(self._interface)
-    self._backend.FinishInterface()
+  def AddIndexer(self, element_type):
+    self._backend.AddIndexer(element_type)
+
+  def AmendIndexer(self, element_type):
+    self._backend.AmendIndexer(element_type)
 
   def AddAttribute(self, attribute):
+    self._backend.AddAttribute(attribute)
+
     getter = attribute
     setter = attribute if not IsReadOnly(attribute) else None
     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 35 matching lines @@
       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=self._shared.DartType(info.type_name),
                                  NAME=html_name,
                                  PARAMS=info.ParametersInterfaceDeclaration(
                                         self._shared.DartType))
+    self._backend.AddOperation(info)
+
+  def AddStaticOperation(self, info):
+    self._backend.AddStaticOperation(info)
 
   def FinishInterface(self):
-    pass
+    self._backend.AddSecondaryMembers(self._interface)
+    self._backend.FinishInterface()
 
   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)
+    self._backend.AddConstant(constant)
 
   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'
     events_class = '_%sImpl' % events_interface
     parent_events_interface = self._shared.GetParentEventsClass(self._interface)
@@ skipping 41 matching lines @@
         '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)
 
 
+class HtmlGeneratorDummyBackend(object):
+  def AddAttribute(self, attribute):
+    pass
+
+  def AddOperation(self, info):
+    pass
+
+
 # ------------------------------------------------------------------------------
 
 # 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 18 matching lines @@
     return os.path.join(self._system._output_dir, 'html', 'frog',
                         '_%sFactoryProvider.dart' % self._html_interface_name)
 
   def FilePathForDartElementsFactoryProviderImplementation(self):
     return os.path.join(self._system._output_dir, 'html', 'frog',
                         '_Elements.dart')
 
   def SetImplementationEmitter(self, implementation_emitter):
     self._dart_code = implementation_emitter
 
-  def AddMergedMembers(self, merged_interface):
-    self.AddMembers(merged_interface)
+  def ImplementsMergedMembers(self):

[Anton Muhin, 2012/07/05 16:07:00]

that could probably be a simple field

+    return True
 
   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):
@@ skipping 279 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