Extract common logic for emitting implementation classes.

lib/html/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
 import os
@@ skipping 204 matching lines @@
     code.Emit('typedef $TYPE $NAME($PARAMS);\n',
               NAME=self._interface.id,
               TYPE=DartType(info.type_name),
               PARAMS=info.ParametersImplementationDeclaration(DartType))
     self._backend.GenerateCallback(info)
 
   def GenerateInterface(self):
     if (not self._interface.id in _merged_html_interfaces and
         # Don't re-generate types that have been converted to native dart types.
         self._html_interface_name not in nativified_classes):
-      self._interface_emitter = self._library_emitter.FileEmitter(
+      interface_emitter = self._library_emitter.FileEmitter(
           self._html_interface_name)
     else:
-      self._interface_emitter = emitter.Emitter()
+      interface_emitter = emitter.Emitter()
 
     template_file = 'interface_%s.darttemplate' % self._html_interface_name
     interface_template = (self._template_loader.TryLoad(template_file) or
                           self._template_loader.Load('interface.darttemplate'))
 
     typename = self._html_interface_name
 
     implements = []
     suppressed_implements = []
 
@@ skipping 46 matching lines @@
     for info in infos:
       constructors.append(info.ConstructorInfo(typename))
       if factory_provider:
         assert factory_provider == info.factory_provider_name
       else:
         factory_provider = info.factory_provider_name
 
     # TODO(vsm): Add appropriate package / namespace syntax.
     (self._type_comment_emitter,
      self._members_emitter,
-     self._top_level_emitter) = self._interface_emitter.Emit(
+     self._top_level_emitter) = interface_emitter.Emit(
          interface_template + '$!TOP_LEVEL',
          ID=typename,
          EXTENDS=implements_str)
 
     self._type_comment_emitter.Emit("/// @domName $DOMNAME",
         DOMNAME=self._interface.doc_js_name)
 
     if self._backend.HasImplementation():
       if not self._interface.id in _merged_html_interfaces:
         name = self._html_interface_name
         if self._html_interface_name in nativified_classes:
           name = nativified_classes[self._html_interface_name]
         basename = '%sImpl' % name
       else:
         basename = '%sImpl_Merged' % self._html_interface_name
-      self._implementation_emitter = self._library_emitter.FileEmitter(basename)
+      implementation_emitter = self._library_emitter.FileEmitter(basename)
     else:
-      self._implementation_emitter = emitter.Emitter()
-    self._backend.SetImplementationEmitter(self._implementation_emitter)
-    self._implementation_members_emitter = self._backend.StartInterface()
+      implementation_emitter = emitter.Emitter()
+
+    base_class = self._backend.BaseClassName()
+    implemented_interfaces = [self._html_interface_name] +\
+                             self._backend.AdditionalImplementedInterfaces()
+    self._implementation_members_emitter = implementation_emitter.Emit(
+        self._backend.ImplementationTemplate(),
+        CLASSNAME=self._backend.ImplementationClassName(),
+        EXTENDS=' extends %s' % base_class if base_class else '',
+        IMPLEMENTS=' implements ' + ', '.join(implemented_interfaces),
+        NATIVESPEC=self._backend.NativeSpec())
+    self._backend.StartInterface(self._implementation_members_emitter)
 
     for constructor_info in constructors:
       constructor_info.GenerateFactoryInvocation(
           self._DartType, self._members_emitter, factory_provider)
 
     element_type = MaybeTypedArrayElementTypeInHierarchy(
         self._interface, self._database)
     if element_type:
       self._members_emitter.Emit(
           '\n'
           '  factory $CTOR(int length) =>\n'
           '    $FACTORY.create$(CTOR)(length);\n'
           '\n'
           '  factory $CTOR.fromList(List<$TYPE> list) =>\n'
           '    $FACTORY.create$(CTOR)_fromList(list);\n'
           '\n'
           '  factory $CTOR.fromBuffer(ArrayBuffer buffer, [int byteOffset, int length]) => \n'
           '    $FACTORY.create$(CTOR)_fromBuffer(buffer, byteOffset, length);\n',
         CTOR=self._interface.id,
         TYPE=self._DartType(element_type),
         FACTORY=factory_provider)
 
     events_interface = self._event_generator.ProcessInterface(
         self._interface, self._html_interface_name,
         self._backend.CustomJSMembers(),
-        self._interface_emitter, self._implementation_emitter)
+        interface_emitter, implementation_emitter)
     if events_interface:
       self._EmitEventGetter(events_interface, '_%sImpl' % events_interface)
 
     old_backend = self._backend
     if not self._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)
@@ skipping 212 matching lines @@
     self._html_interface_name = options.renamer.RenameInterface(self._interface)
     self._current_secondary_parent = None
 
   def HasImplementation(self):
     return not (IsPureInterface(self._interface.id) or
                 self._interface.id in _merged_html_interfaces)
 
   def ImplementationClassName(self):
     return self._ImplClassName(self._html_interface_name)
 
-  def SetImplementationEmitter(self, implementation_emitter):
-    self._dart_code = implementation_emitter
-
   def ImplementsMergedMembers(self):
     return True
 
   def _ImplClassName(self, type_name):
     name = type_name
     if type_name in nativified_classes:
       name = nativified_classes[type_name]
     return '_%sImpl' % name
 
   def GenerateCallback(self, info):
     pass
 
-  def StartInterface(self):
-    interface = self._interface
-    interface_name = interface.id
+  def BaseClassName(self):
+    if not self._interface.parents:
+      return None
+    supertype = self._interface.parents[0].type.id
+    if IsDartCollectionType(supertype):
+      # List methods are injected in AddIndexer.
+      return None
+    if IsPureInterface(supertype):
+      return None
+    return self._ImplClassName(self._DartType(supertype))
 
-    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(self._DartType(supertype))
-
-    native_spec = MakeNativeSpec(interface.javascript_binding_name)
-
-    extends = ' extends ' + base if base else ''
-
+  def AdditionalImplementedInterfaces(self):
     # TODO: Include all implemented interfaces, including other Lists.
-    implements = [self._html_interface_name]
+    implements = []
     element_type = MaybeTypedArrayElementType(self._interface)
     if element_type:
       implements.append('List<%s>' % self._DartType(element_type))
-
     if self._HasJavaScriptIndexingBehaviour():
       implements.append('JavaScriptIndexingBehavior')
+    return implements
 
+  def NativeSpec(self):
+    native_spec = MakeNativeSpec(self._interface.javascript_binding_name)
+    return ' native "%s"' % native_spec
+
+  def ImplementationTemplate(self):
     template_file = 'impl_%s.darttemplate' % self._html_interface_name
-    template = (self._template_loader.TryLoad(template_file) or
-                self._template_loader.Load('dart2js_impl.darttemplate'))
-    self._members_emitter = self._dart_code.Emit(
-        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)
+    return (self._template_loader.TryLoad(template_file) or
+            self._template_loader.Load('dart2js_impl.darttemplate'))
 
-    return self._members_emitter
+  def StartInterface(self, emitter):
+    self._members_emitter = emitter
 
   def FinishInterface(self):
     pass
 
   def EmitFactoryProvider(self, constructor_info, factory_provider, emitter):
     template_file = ('factoryprovider_%s.darttemplate' %
                      self._html_interface_name)
     template = self._template_loader.TryLoad(template_file)
     if not template:
       template = self._template_loader.Load('factoryprovider.darttemplate')
@@ skipping 473 matching lines @@
 
     library_emitter = self._multiemitter.FileEmitter(library_file_path)
     library_file_dir = os.path.dirname(library_file_path)
     auxiliary_dir = os.path.relpath(auxiliary_dir, library_file_dir)
     imports_emitter = library_emitter.Emit(
         self._template, AUXILIARY_DIR=massage_path(auxiliary_dir))
     for path in sorted(self._path_to_emitter.keys()):
       relpath = os.path.relpath(path, library_file_dir)
       imports_emitter.Emit(
           "#source('$PATH');\n", PATH=massage_path(relpath))