Extract common FactoryProviders generation logic.

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 757 matching lines @@
         templates, database, emitters, output_dir)
     self._shared = HtmlSystemShared(database)
 
 class HtmlInterfacesSystem(HtmlSystem):
 
   def __init__(self, templates, database, emitters, output_dir, backend):
     super(HtmlInterfacesSystem, self).__init__(
         templates, database, emitters, output_dir)
     self._backend = backend
     self._dart_interface_file_paths = []
-    self._factory_provider_emitters = {}
+    self._elements_factory_emitter = None
 
   def ProcessInterface(self, interface):
     HtmlDartInterfaceGenerator(self, interface).Generate()
 
   def ProcessCallback(self, interface, info):
     """Generates a typedef for the callback interface."""
     interface_name = interface.id
     file_path = self._FilePathForDartInterface(interface_name)
     self._ProcessCallback(interface, info, file_path)
     self._backend.ProcessCallback(interface, info)
@@ skipping 61 matching lines @@
 
     factory_provider = None
     if typename in interface_factories:
       factory_provider = interface_factories[typename]
 
     constructors = []
     constructor_info = AnalyzeConstructor(self._interface)
     if constructor_info:
       constructors.append(constructor_info)
       factory_provider = '_' + typename + 'FactoryProvider'
+      path = self._backend.FilePathForDartFactoryProviderImplementation()
+      self._system._dart_interface_file_paths.append(path)
+      factory_provider_emitter = self._system._emitters.FileEmitter(path)
+      self._backend.EmitFactoryProvider(
+          constructor_info, factory_provider, factory_provider_emitter)
 
     infos = HtmlElementConstructorInfos(typename)
+    if infos:
+      if not self._system._elements_factory_emitter:
+        path = self._backend.FilePathForDartElementsFactoryProviderImplementation()
+        self._system._dart_interface_file_paths.append(path)
+        file_emitter = self._system._emitters.FileEmitter(path)
+        template = self._system._templates.Load(
+            'factoryprovider_Elements.darttemplate')
+        self._system._elements_factory_emitter = file_emitter.Emit(template)
+      EmitHtmlElementFactoryConstructors(
+          self._system._elements_factory_emitter,
+          infos,
+          self._html_interface_name,
+          self._backend.ImplementationClassName())
+
     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
 
     if factory_provider:
       extends_str += ' default ' + factory_provider
 
@@ skipping 18 matching lines @@
     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(
-          self._system._backend._EmitterForFactoryProviderBody(
-              infos[0].factory_provider_name),
-          infos,
-          self._html_interface_name,
-          self._backend.ImplementationClassName())
-
     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,'
@@ skipping 158 matching lines @@
     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 FilePathForDartImplementation(self):
     return os.path.join(self._system._output_dir, 'html', 'frog',
                         '%s.dart' % self._html_interface_name)
 
+  def FilePathForDartFactoryProviderImplementation(self):
+    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 _ImplClassName(self, type_name):
     return self._shared._ImplClassName(type_name)
 
   def _NarrowToImplementationType(self, type_name):
@@ skipping 38 matching lines @@
         #$!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(constructor_info)
-
     return self._members_emitter
 
-  def _EmitFactoryProvider(self, constructor_info):
+  def EmitFactoryProvider(self, constructor_info, factory_provider, emitter):
     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)
     emitter.Emit(
         template,
         FACTORYPROVIDER=factory_provider,
         CONSTRUCTOR=self._html_interface_name,
         PARAMETERS=constructor_info.ParametersImplementationDeclaration(),
         NAMED_CONSTRUCTOR=constructor_info.name or self._html_interface_name,
         ARGUMENTS=constructor_info.ParametersAsArgumentList())
 
   def AddIndexer(self, element_type):
     """Adds all the methods required to complete implementation of List."""
@@ skipping 177 matching lines @@
           PARAMS=info.ParametersImplementationDeclaration(
               lambda type_name: self._NarrowInputType(type_name)))
 
 # ------------------------------------------------------------------------------
 
 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 = {}
 
   def ImplementationGenerator(self, interface):
     return HtmlFrogClassGenerator(self, interface)
 
-  def GenerateLibraries(self, interface_files):
+  def GenerateLibraries(self, dart_files):
     self._GenerateLibFile(
         'html_frog.darttemplate',
         os.path.join(self._output_dir, 'html_frog.dart'),
-        interface_files + self._dart_frog_file_paths)
+        dart_files)
 
   def Finish(self):
     pass
 
-  def _ImplFileEmitter(self, name):
-    """Returns the file emitter of the Frog implementation file."""
-    path = os.path.join(self._output_dir, 'html', 'frog', '%s.dart' % name)
-    self._dart_frog_file_paths.append(path)
-    return self._emitters.FileEmitter(path)
-
-  def _EmitterForFactoryProviderBody(self, name):
-    if name not in self._factory_provider_emitters:
-      template = self._templates.Load('factoryprovider_%s.darttemplate' % name)
-      file_emitter = self._ImplFileEmitter(name)
-      self._factory_provider_emitters[name] = file_emitter.Emit(template)
-    return self._factory_provider_emitters[name]
-
 # -----------------------------------------------------------------------------
 
 def _ComputeInheritanceClosure(database):
   def Collect(interface, seen, collected):
     name = interface.id
     if '<' in name:
       # TODO(sra): Handle parameterized types.
       return
     if not name in seen:
       seen.add(name)
       collected.append(name)
       for parent in interface.parents:
         # TODO(sra): Handle parameterized types.
         if not '<' in parent.type.id:
           if database.HasInterface(parent.type.id):
             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