Automatically generate most constructors

client/dom/scripts/dartgenerator.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 generates Dart APIs from the IDL database."""
 
 import emitter
 import idlnode
 import logging
@@ skipping 611 matching lines @@
 
 class DummyImplementationSystem(System):
   """Generates a dummy implementation for use by the editor analysis.
 
   All the code comes from hand-written library files.
   """
 
   def __init__(self, templates, database, emitters, output_dir):
     super(DummyImplementationSystem, self).__init__(
         templates, database, emitters, output_dir)
+    factory_providers_file = os.path.join(self._output_dir, 'src', 'dummy',
+                                          'RegularFactoryProviders.dart')
+    self._factory_providers_emitter = self._emitters.FileEmitter(
+        factory_providers_file)
+    self._impl_file_paths = [factory_providers_file]
 
   def InterfaceGenerator(self,
                          interface,
                          common_prefix,
                          super_interface_name,
                          source_filter):
     return DummyInterfaceGenerator(self, interface)
 
   def ProcessCallback(self, interface, info):
     pass
 
   def GenerateLibraries(self, lib_dir):
     # Library generated for implementation.
     self._GenerateLibFile(
         'dom_dummy.darttemplate',
         os.path.join(lib_dir, 'dom_dummy.dart'),
         (self._interface_system._dart_interface_file_paths +
          self._interface_system._dart_callback_file_paths +
-         []
-         # FIXME: Move the implementation to a separate library.
-         # self._dart_wrapping_file_paths
-         ))
+         self._impl_file_paths))
+
 
 # ------------------------------------------------------------------------------
 
 class DummyInterfaceGenerator(object):
-  """Generates nothing."""
+  """Generates dummy implementation."""
 
   def __init__(self, system, interface):
-    pass
+    self._system = system
+    self._interface = interface
 
   def StartInterface(self):
-    pass
+    # There is no implementation to match the interface, but there might be a
+    # factory constructor for the Dart interface.
+    constructor_info = AnalyzeConstructor(self._interface)
+    if constructor_info:
+      dart_interface_name = self._interface.id
+      self._EmitFactoryProvider(dart_interface_name, constructor_info)
+
+  def _EmitFactoryProvider(self, interface_name, constructor_info):
+    factory_provider = '_' + interface_name + 'FactoryProvider'
+    self._system._factory_providers_emitter.Emit(
+        self._system._templates.Load('factoryprovider.darttemplate'),
+        FACTORYPROVIDER=factory_provider,
+        CONSTRUCTOR=interface_name,
+        PARAMETERS=constructor_info.ParametersImplementationDeclaration())
 
   def FinishInterface(self):
     pass
 
   def AddConstant(self, constant):
     pass
 
   def AddAttribute(self, getter, setter):
     pass
 
   def AddSecondaryAttribute(self, interface, getter, setter):
     pass
 
   def AddSecondaryOperation(self, interface, info):
     pass
 
   def AddIndexer(self, element_type):
     pass
 
   def AddTypedArrayConstructors(self, element_type):
     pass
 
   def AddOperation(self, info):
     pass
 
   def AddEventAttributes(self, event_attrs):
     pass