Automatically generate most constructors

client/dom/scripts/systemfrog.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 systems to generate
 frog binding from the IDL database."""
 
 import os
 from generator import *
 from systembase import *
 
 class FrogSystem(System):
 
   def __init__(self, templates, database, emitters, output_dir):
     super(FrogSystem, self).__init__(
         templates, database, emitters, output_dir)
-    self._dart_frog_file_paths = []
+    self._impl_file_paths = []
 
   def InterfaceGenerator(self,
                          interface,
                          common_prefix,
                          super_interface_name,
                          source_filter):
     """."""
-    dart_frog_file_path = self._FilePathForFrogImpl(interface.id)
-    self._dart_frog_file_paths.append(dart_frog_file_path)
-
     template_file = 'impl_%s.darttemplate' % interface.id
     template = self._templates.TryLoad(template_file)
     if not template:
       template = self._templates.Load('frog_impl.darttemplate')
 
-    dart_code = self._emitters.FileEmitter(dart_frog_file_path)
+    dart_code = self._ImplFileEmitter(interface.id)
     return FrogInterfaceGenerator(self, interface, template,
                                   super_interface_name, dart_code)
 
   def GenerateLibraries(self, lib_dir):
     self._GenerateLibFile(
         'frog_dom.darttemplate',
         os.path.join(lib_dir, 'dom_frog.dart'),
         (self._interface_system._dart_interface_file_paths +
          self._interface_system._dart_callback_file_paths +
-         self._dart_frog_file_paths))
+         self._impl_file_paths))
 
   def Finish(self):
     pass
 
-  def _FilePathForFrogImpl(self, interface_name):
-    """Returns the file path of the Frog implementation."""
-    return os.path.join(self._output_dir, 'src', 'frog',
-                        '%s.dart' % interface_name)
+  def _ImplFileEmitter(self, name):
+    """Returns the file emitter of the Frog implementation file."""
+    path = os.path.join(self._output_dir, 'src', 'frog', '%s.dart' % name)
+    self._impl_file_paths.append(path)
+    return self._emitters.FileEmitter(path)
 
 # ------------------------------------------------------------------------------
 
 class FrogInterfaceGenerator(object):
   """Generates a Frog class for a DOM IDL interface."""
 
   def __init__(self, system, interface, template, super_interface, dart_code):
     """Generates Dart code for the given interface.
 
     Args:
@@ skipping 52 matching lines @@
         #}
         CLASSNAME=self._class_name,
         EXTENDS=extends,
         IMPLEMENTS=' implements ' + ', '.join(implements),
         NATIVESPEC=' native "' + native_spec + '"')
 
     element_type = MaybeTypedArrayElementType(interface)
     if element_type:
       self.AddTypedArrayConstructors(element_type)
 
+    # Emit a factory provider class for the constructor.
+    constructor_info = AnalyzeConstructor(interface)
+    if constructor_info:
+      self._EmitFactoryProvider(interface_name, constructor_info)
+
 
   def FinishInterface(self):
     """."""
     pass
 
   def _ImplClassName(self, type_name):
     return '_' + type_name + 'Js'
 
+  def _EmitFactoryProvider(self, interface_name, constructor_info):
+    template_file = 'factoryprovider_%s.darttemplate' % interface_name
+    template = self._system._templates.TryLoad(template_file)
+    if not template:
+      template = self._system._templates.Load('factoryprovider.darttemplate')
+
+    factory_provider = '_' + interface_name + 'FactoryProvider'
+    emitter = self._system._ImplFileEmitter(factory_provider)
+    emitter.Emit(
+        template,
+        FACTORYPROVIDER=factory_provider,
+        CONSTRUCTOR=interface_name,
+        PARAMETERS=constructor_info.ParametersImplementationDeclaration(),
+        NAMEDCONSTRUCTOR=constructor_info.name or interface_name,
+        ARGUMENTS=constructor_info.ParametersAsArgumentList())
+
   def _NarrowToImplementationType(self, type_name):
     # TODO(sra): Move into the 'system' and cache the result.
     if type_name == 'EventListener':
       # Callbacks are typedef functions so don't have a class.
       return type_name
     if self._system._database.HasInterface(type_name):
       interface = self._system._database.GetInterface(type_name)
       if RecognizeCallback(interface):
         # Callbacks are typedef functions so don't have a class.
         return type_name
@@ skipping 180 matching lines @@
     if native_body:
       native_body = " '''" + native_body + "'''"
 
     self._members_emitter.Emit(
         '\n'
         '  $TYPE $NAME($PARAMS) native$NATIVESTRING;\n',
         TYPE=self._NarrowOutputType(info.type_name),
         NAME=info.name,
         PARAMS=params,
         NATIVESTRING=native_body)