Generate dummy dom to replace wrapping dom for dartc.

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 364 matching lines @@
     self._ComputeInheritanceClosure()
 
     self._systems = []
 
     interface_system = InterfacesSystem(
         TemplateLoader(self._template_dir, ['dom/interface', 'dom', '']),
         self._database, self._emitters, self._output_dir)
     self._systems.append(interface_system)
 
     if 'native' in systems:
-        native_system = NativeImplementationSystem(
-            TemplateLoader(self._template_dir, ['dom/native', 'dom', '']),
-            self._database, self._emitters, self._auxiliary_dir,
-            self._output_dir)
+      native_system = NativeImplementationSystem(
+          TemplateLoader(self._template_dir, ['dom/native', 'dom', '']),
+          self._database, self._emitters, self._auxiliary_dir,
+          self._output_dir)
 
-        self._systems.append(native_system)
+      self._systems.append(native_system)
 
     if 'wrapping' in systems:
       wrapping_system = WrappingImplementationSystem(
           TemplateLoader(self._template_dir, ['dom/wrapping', 'dom', '']),
           self._database, self._emitters, self._output_dir)
 
       # Makes interface files available for listing in the library for the
       # wrapping implementation.
       wrapping_system._interface_system = interface_system
       self._systems.append(wrapping_system)
 
+    if 'dummy' in systems:
+      dummy_system = DummyImplementationSystem(
+          TemplateLoader(self._template_dir, ['dom/dummy', 'dom', '']),
+          self._database, self._emitters, self._output_dir)
+
+      # Makes interface files available for listing in the library for the
+      # dummy implementation.
+      dummy_system._interface_system = interface_system
+      self._systems.append(dummy_system)
+
     if 'frog' in systems:
       frog_system = FrogSystem(
           TemplateLoader(self._template_dir, ['dom/frog', 'dom', '']),
           self._database, self._emitters, self._output_dir)
 
       frog_system._interface_system = interface_system
       self._systems.append(frog_system)
 
 
     # Render all interfaces into Dart and save them in files.
@@ skipping 553 matching lines @@
 
 
   def _FilePathForDartInterface(self, interface_name):
     """Returns the file path of the Dart interface definition."""
     return os.path.join(self._output_dir, 'src', 'interface',
                         '%s.dart' % interface_name)
 
 
 # ------------------------------------------------------------------------------
 
+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)
+
+  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
+         ))
+
+# ------------------------------------------------------------------------------
+
 class WrappingImplementationSystem(System):
 
   def __init__(self, templates, database, emitters, output_dir):
     """Prepared for generating wrapping implementation.
 
     - Creates emitter for JS code.
     - Creates emitter for Dart code.
     """
     super(WrappingImplementationSystem, self).__init__(
         templates, database, emitters, output_dir)
@@ skipping 288 matching lines @@
 
 # Given a sorted sequence of type identifiers, return an appropriate type
 # name
 def TypeName(typeIds, interface):
   # Dynamically type this field for now.
   return 'var'
 
 
 # ------------------------------------------------------------------------------
 
+class DummyInterfaceGenerator(object):
+  """Generates nothing."""
+
+  def __init__(self, system, interface):
+    pass
+
+  def StartInterface(self):
+    pass
+
+  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
+
+# ------------------------------------------------------------------------------
+
 class WrappingInterfaceGenerator(object):
   """Generates Dart and JS implementation for one DOM IDL interface."""
 
   def __init__(self, interface, super_interface, dart_code, js_code, type_map,
                externs, base_members):
     """Generates Dart and JS code for the given interface.
 
     Args:
 
       interface: an IDLInterface instance. It is assumed that all types have
@@ skipping 989 matching lines @@
                    INDENT=indent,
                    NATIVENAME=native_name,
                    ARGS=argument_expressions)
 
     self._members_emitter.Emit('  $TYPE $NATIVE_NAME($PARAMS) native '
                                '"$(INTERFACE)$(NATIVE_NAME)_Callback";\n',
                                NATIVE_NAME=native_name,
                                TYPE=info.type_name,
                                PARAMS=', '.join(arg_names),
                                INTERFACE=self._interface.id)