Move interface members traverse logic to BaseGenerator.

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
 import os
 import re
 import shutil
+import systembase
 from generator import *
-from systembase import *
 
 _logger = logging.getLogger('dartgenerator')
 
 def MergeNodes(node, other):
   node.operations.extend(other.operations)
   for attribute in other.attributes:
     if not node.has_attribute(attribute):
       node.attributes.append(attribute)
 
   node.constants.extend(other.constants)
@@ skipping 239 matching lines @@
     _logger.info('Generating %s' % interface.id)
 
     generator = system.InterfaceGenerator(interface,
                                           common_prefix,
                                           super_interface_name,
                                           source_filter)
     if not generator:
       return
 
     generator.StartInterface()
-
-    for const in sorted(interface.constants, ConstantOutputOrder):
-      generator.AddConstant(const)
-
-    attributes = [attr for attr in interface.attributes
-                  if attr.type.id != 'EventListener']
-    for (getter, setter) in  _PairUpAttributes(attributes):
-      generator.AddAttribute(getter, setter)
-
-    # The implementation should define an indexer if the interface directly
-    # extends List.
-    (element_type, requires_indexer) = ListImplementationInfo(
-          interface, self._database)
-    if element_type:
-      if requires_indexer:
-        generator.AddIndexer(element_type)
-      else:
-        generator.AmendIndexer(element_type)
-    # Group overloaded operations by id
-    operationsById = {}
-    for operation in interface.operations:
-      if operation.id not in operationsById:
-        operationsById[operation.id] = []
-      operationsById[operation.id].append(operation)
-
-    # Generate operations
-    for id in sorted(operationsById.keys()):
-      operations = operationsById[id]
-      info = AnalyzeOperation(interface, operations)
-      if info.IsStatic():
-        generator.AddStaticOperation(info)
-      else:
-        generator.AddOperation(info)
-
-    # With multiple inheritance, attributes and operations of non-first
-    # interfaces need to be added.  Sometimes the attribute or operation is
-    # defined in the current interface as well as a parent.  In that case we
-    # avoid making a duplicate definition and pray that the signatures match.
-
-    for parent_interface in self._TransitiveSecondaryParents(interface):
-      if isinstance(parent_interface, str):  # IsDartCollectionType(parent_interface)
-        continue
-      attributes = [attr for attr in parent_interface.attributes
-                    if not FindMatchingAttribute(interface, attr)]
-      for (getter, setter) in _PairUpAttributes(attributes):
-        generator.AddSecondaryAttribute(parent_interface, getter, setter)
-
-      # Group overloaded operations by id
-      operationsById = {}
-      for operation in parent_interface.operations:
-        if operation.id not in operationsById:
-          operationsById[operation.id] = []
-        operationsById[operation.id].append(operation)
-
-      # Generate operations
-      for id in sorted(operationsById.keys()):
-        if not any(op.id == id for op in interface.operations):
-          operations = operationsById[id]
-          info = AnalyzeOperation(interface, operations)
-          generator.AddSecondaryOperation(parent_interface, info)
-
+    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:
@@ skipping 32 matching lines @@
 
   def FixEventTargets(self, database):
     for interface in database.GetInterfaces():
       # Create fake EventTarget parent interface for interfaces that have
       # 'EventTarget' extended attribute.
       if 'EventTarget' in interface.ext_attrs:
         ast = [('Annotation', [('Id', 'WebKit')]),
                ('InterfaceType', ('ScopedName', 'EventTarget'))]
         interface.parents.append(idlnode.IDLParentInterface(ast))
 
-def _PairUpAttributes(attributes):
-  """Returns a list of (getter, setter) pairs sorted by name.
-
-  One element of the pair may be None.
-  """
-  names = sorted(set(attr.id for attr in attributes))
-  getters = {}
-  setters = {}
-  for attr in attributes:
-    if attr.is_fc_getter:
-      getters[attr.id] = attr
-    elif attr.is_fc_setter and 'Replaceable' not in attr.ext_attrs:
-      setters[attr.id] = attr
-  return [(getters.get(id), setters.get(id)) for id in names]
-
 # ------------------------------------------------------------------------------
 
-class DummyImplementationSystem(System):
+class DummyImplementationSystem(systembase.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')
@@ skipping 16 matching lines @@
     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(object):
+class DummyInterfaceGenerator(systembase.BaseGenerator):
   """Generates dummy implementation."""
 
   def __init__(self, system, interface):
+    super(DummyInterfaceGenerator, self).__init__(system._database)
     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 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 AmendIndexer(sefl, element_type):
-    pass
-
   def AddTypedArrayConstructors(self, element_type):
     pass
 
-  def AddOperation(self, info):
-    pass
-
-  def AddStaticOperation(self, info):
-    pass
-
   def AddEventAttributes(self, event_attrs):
     pass