Make per-interface generators an implementation detail of a system.

lib/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 168 matching lines @@
       if HasAnnotations(interface):
         interface.constants = filter(HasAnnotations, interface.constants)
         interface.attributes = filter(HasAnnotations, interface.attributes)
         interface.operations = filter(HasAnnotations, interface.operations)
         interface.parents = filter(HasAnnotations, interface.parents)
       else:
         database.DeleteInterface(interface.id)
 
     self.FilterMembersWithUnidentifiedTypes(database)
 
-  def Generate(self, database, system, source_filter=None, super_database=None,
-      common_prefix=None, webkit_renames={}):
+  def Generate(self, database, system, super_database=None, webkit_renames={}):
     self._database = database
 
     # Collect interfaces
     interfaces = []
     for interface in database.GetInterfaces():
-      if not MatchSourceFilter(source_filter, interface):
+      if not MatchSourceFilter(interface):
         # Skip this interface since it's not present in the required source
         _logger.info('Omitting interface - %s' % interface.id)
         continue
       interfaces.append(interface)
 
     # TODO(sra): Use this list of exception names to generate information to
     # tell Frog which exceptions can be passed from JS to Dart code.
     exceptions = self._CollectExceptions(interfaces)
 
     super_map = dict((v, k) for k, v in webkit_renames.iteritems())
 
     # Render all interfaces into Dart and save them in files.
     for interface in self._PreOrderInterfaces(interfaces):
 
-      super_interface = None
       super_name = interface.id
 
       if super_name in super_map:
         super_name = super_map[super_name]
 
       if (super_database is not None and
           super_database.HasInterface(super_name)):
-        super_interface = super_name
+        interface.ext_attrs['synthesizedSuperInterfaceName'] = super_name
 
       interface_name = interface.id
       auxiliary_file = self._auxiliary_files.get(interface_name)
       if auxiliary_file is not None:
         _logger.info('Skipping %s because %s exists' % (
             interface_name, auxiliary_file))
         continue
 
       info = RecognizeCallback(interface)
       if info:
        system.ProcessCallback(interface, info)
       else:
         if 'Callback' in interface.ext_attrs:
           _logger.info('Malformed callback: %s' % interface.id)
-        self._ProcessInterface(system, interface, super_interface,
-                               source_filter, common_prefix)
+        _logger.info('Generating %s' % interface.id)
+        system.ProcessInterface(interface)
 
     system.GenerateLibraries()
     system.Finish()
 
   def _PreOrderInterfaces(self, interfaces):
     """Returns the interfaces in pre-order, i.e. parents first."""
     seen = set()
     ordered = []
     def visit(interface):
       if interface.id in seen:
         return
       seen.add(interface.id)
       for parent in interface.parents:
         if IsDartCollectionType(parent.type.id):
           continue
         if self._database.HasInterface(parent.type.id):
           parent_interface = self._database.GetInterface(parent.type.id)
           visit(parent_interface)
       ordered.append(interface)
 
     for interface in interfaces:
       visit(interface)
     return ordered
 
-
-  def _ProcessInterface(self, system, interface, super_interface_name,
-                        source_filter,
-                        common_prefix):
-    """."""
-    _logger.info('Generating %s' % interface.id)
-
-    generator = system.InterfaceGenerator(interface,
-                                          common_prefix,
-                                          super_interface_name,
-                                          source_filter)
-    if not generator:
-      return
-
-    generator.StartInterface()
-    generator.AddMembers(interface)
-    secondary_parents = self._TransitiveSecondaryParents(interface)
-    generator.AddSecondaryMembers(interface, secondary_parents)
-    generator.FinishInterface()
-
-  def _TransitiveSecondaryParents(self, interface):
-    """Returns a list of all non-primary parents.
-
-    The list contains the interface objects for interfaces defined in the
-    database, and the name for undefined interfaces.
-    """
-    def walk(parents):
-      for parent in parents:
-        if IsDartCollectionType(parent.type.id):
-          result.append(parent.type.id)
-          continue
-        if self._database.HasInterface(parent.type.id):
-          parent_interface = self._database.GetInterface(parent.type.id)
-          result.append(parent_interface)
-          walk(parent_interface.parents)
-
-    result = []
-    if interface.parents:
-      parent = interface.parents[0]
-      if IsPureInterface(parent.type.id):
-        walk(interface.parents)
-      else:
-        walk(interface.parents[1:])
-    return result;
-
-
   def _CollectExceptions(self, interfaces):
     """Returns the names of all exception classes raised."""
     exceptions = set()
     for interface in interfaces:
       for attribute in interface.attributes:
         if attribute.get_raises:
           exceptions.add(attribute.get_raises.id)
         if attribute.set_raises:
           exceptions.add(attribute.set_raises.id)
       for operation in interface.operations:
@@ skipping 21 matching lines @@
 
   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 ProcessInterface(self, interface):
+    DummyInterfaceGenerator(self, interface).Generate()
 
   def ProcessCallback(self, interface, info):
     pass
 
   def GenerateLibraries(self):
     # Library generated for implementation.
     self._GenerateLibFile(
         'dom_dummy.darttemplate',
         os.path.join(self._output_dir, 'dom_dummy.dart'),
         (self._interface_system._dart_interface_file_paths +
          self._interface_system._dart_callback_file_paths +
          self._impl_file_paths))
 
 
 # ------------------------------------------------------------------------------
 
 class DummyInterfaceGenerator(systembase.BaseGenerator):
   """Generates dummy implementation."""
 
   def __init__(self, system, interface):
-    super(DummyInterfaceGenerator, self).__init__(system._database)
+    super(DummyInterfaceGenerator, self).__init__(system._database, interface)
     self._system = system
-    self._interface = interface
 
   def StartInterface(self):
     # 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 AddTypedArrayConstructors(self, element_type):
     pass
 
   def AddEventAttributes(self, event_attrs):
     pass