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()
 
+    backend = self._backend

[Anton Muhin, 2012/07/04 20:03:17]

nit: backend -> old_backend

[podivilov, 2012/07/05 09:13:43]

Done.

+    self._backend = backend.MergedMembersGenerator()
     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 = backend

[Anton Muhin, 2012/07/04 20:03:17]

I am slightly uneasy that you mutate internal state, any chances this ugliness
may go away now or later?

[podivilov, 2012/07/05 09:13:43]

Why HtmlDartInterfaceGenerator shouldn't mutate it's own internal state? I can
pass the backend down through AddMembers to all AddFoo methods, but imo it
wouldn't make the code better.

I'm not sure if we need merged members in dart2js implementation classes.
Removing them may help to simplify this later.

 
-    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 79 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 MergedMembersGenerator(self):
+    return self
 
   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