Merge BaseGenerator into HtmlDartInterfaceGenerator.

lib/html/scripts/systemhtml.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 system to generate
 Dart:html APIs from the IDL database."""
 
 import emitter
-
-from systembase import *
+import os
+from generator import *
 
 _js_custom_members = set([
     'AudioBufferSourceNode.start',
     'AudioBufferSourceNode.stop',
     'CSSStyleDeclaration.setProperty',
     'Element.insertAdjacentElement',
     'Element.insertAdjacentHTML',
     'Element.insertAdjacentText',
     'Element.remove',
     'ElementEvents.mouseWheel',
@@ skipping 155 matching lines @@
         RETURN_TYPE=constructor_info.type_name,
         CONSTRUCTOR=constructor_info.ConstructorFactoryName(DartType),
         CLASS=class_name,
         TAG=info.tag,
         PARAMS=constructor_info.ParametersInterfaceDeclaration(DartType))
     for param in constructor_info.param_infos:
       inits.Emit('    if ($E != null) _e.$E = $E;\n', E=param.name)
 
 # ------------------------------------------------------------------------------
 
-class HtmlDartInterfaceGenerator(BaseGenerator):
+class HtmlDartInterfaceGenerator(object):
   """Generates dart interface and implementation for the DOM IDL interface."""
 
   def __init__(self, options, library_emitter, event_generator, interface,
                backend):
-    super(HtmlDartInterfaceGenerator, self).__init__(None, None, interface)
     self._renamer = options.renamer
     self._database = options.database
     self._template_loader = options.templates
     self._type_registry = options.type_registry
     self._library_emitter = library_emitter
     self._event_generator = event_generator
+    self._interface = interface
     self._backend = backend
     self._html_interface_name = options.renamer.RenameInterface(self._interface)
 
-  def GenerateCallback(self, info):
+  def Generate(self):
+    if 'Callback' in self._interface.ext_attrs:
+      self.GenerateCallback()
+    else:
+      self.GenerateInterface()
+
+  def GenerateCallback(self):
     """Generates a typedef for the callback interface."""
+    handlers = [operation for operation in self._interface.operations
+                if operation.id == 'handleEvent']
+    info = AnalyzeOperation(self._interface, handlers)
     code = self._library_emitter.FileEmitter(self._interface.id)
     code.Emit(self._template_loader.Load('callback.darttemplate'))
     code.Emit('typedef $TYPE $NAME($PARAMS);\n',
               NAME=self._interface.id,
               TYPE=DartType(info.type_name),
               PARAMS=info.ParametersImplementationDeclaration(DartType))
     self._backend.GenerateCallback(info)
 
-  def StartInterface(self):
+  def GenerateInterface(self):
     if (not self._interface.id in _merged_html_interfaces and
         # Don't re-generate types that have been converted to native dart types.
         self._html_interface_name not in nativified_classes):
       self._interface_emitter = self._library_emitter.FileEmitter(
           self._html_interface_name)
     else:
       self._interface_emitter = emitter.Emitter()
 
     template_file = 'interface_%s.darttemplate' % self._html_interface_name
     interface_template = (self._template_loader.TryLoad(template_file) or
@@ skipping 112 matching lines @@
 
     old_backend = self._backend
     if not self._backend.ImplementsMergedMembers():
       self._backend = HtmlGeneratorDummyBackend()
     for merged_interface in _merged_html_interfaces:
       if _merged_html_interfaces[merged_interface] == self._interface.id:
         merged_interface = self._database.GetInterface(merged_interface)
         self.AddMembers(merged_interface)
     self._backend = old_backend
 
+    self.AddMembers(self._interface)
+    self.AddSecondaryMembers(self._interface)
+    self._backend.FinishInterface()
+
+  def AddMembers(self, interface):
+    for const in sorted(interface.constants, ConstantOutputOrder):
+      self.AddConstant(const)
+
+    for attr in sorted(interface.attributes, ConstantOutputOrder):
+      if attr.type.id != 'EventListener':
+        self.AddAttribute(attr)
+
+    # 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:
+        self.AddIndexer(element_type)
+      else:
+        self.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)
+      self.AddOperation(info)
+
+  def AddSecondaryMembers(self, interface):
+    # 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.
+    secondary_parents = self._TransitiveSecondaryParents(interface)
+    for parent_interface in secondary_parents:
+      if isinstance(parent_interface, str):  # IsDartCollectionType(parent_interface)
+        continue
+      for attr in sorted(parent_interface.attributes, ConstantOutputOrder):
+        if not FindMatchingAttribute(interface, attr):
+          self.AddSecondaryAttribute(parent_interface, attr)
+
+      # 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)
+          self.AddSecondaryOperation(parent_interface, info)
+
   def AddIndexer(self, element_type):
     self._backend.AddIndexer(element_type)
 
   def AmendIndexer(self, element_type):
     self._backend.AmendIndexer(element_type)
 
   def AddAttribute(self, attribute, is_secondary=False):
     dom_name = DartDomNameOfAttribute(attribute)
     html_name = self._renamer.RenameMember(
       self._interface.id, dom_name, 'get:')
     if not html_name or self._IsPrivate(html_name):
       return
 
 
     html_setter_name = self._renamer.RenameMember(
         self._interface.id, dom_name, 'set:')
-    read_only = IsReadOnly(attribute) or not html_setter_name
+    read_only = (attribute.is_read_only or 'Replaceable' in attribute.ext_attrs
+                 or not html_setter_name)
 
     # We don't yet handle inconsistent renames of the getter and setter yet.
     assert(not html_setter_name or html_name == html_setter_name)
 
     if not is_secondary:
       self._members_emitter.Emit('\n  /** @domName $DOMINTERFACE.$DOMNAME */',
           DOMINTERFACE=attribute.doc_js_interface_name,
           DOMNAME=dom_name)
       if read_only:
         template = '\n  abstract $TYPE get $NAME;\n'
@@ skipping 39 matching lines @@
                                   '  $TYPE $NAME($PARAMS);\n',
                                   TYPE=self._DartType(info.type_name),
                                   NAME=html_name,
                                   PARAMS=info.ParametersInterfaceDeclaration(self._DartType))
     self._backend.AddOperation(info, html_name)
 
   def AddSecondaryOperation(self, interface, info):
     self._backend.SecondaryContext(interface)
     self.AddOperation(info, True)
 
-  def FinishInterface(self):
-    self._backend.FinishInterface()
-
   def AddConstant(self, constant):
     type = TypeOrNothing(self._DartType(constant.type.id), constant.type.id)
     self._members_emitter.Emit('\n  static const $TYPE$NAME = $VALUE;\n',
                                NAME=constant.id,
                                TYPE=type,
                                VALUE=constant.value)
 
   def _EmitEventGetter(self, events_interface, events_class):
     self._members_emitter.Emit(
         '\n  /**'
         '\n   * @domName EventTarget.addEventListener, '
         'EventTarget.removeEventListener, EventTarget.dispatchEvent'
         '\n   */'
         '\n  $TYPE get on;\n',
         TYPE=events_interface)
 
     self._implementation_members_emitter.Emit(
         '\n  $TYPE get on =>\n    new $TYPE(this);\n',
         TYPE=events_class)
 
+  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 _DartType(self, type_name):
+    return self._type_registry.DartType(type_name)
+
   def _IsPrivate(self, name):
     return name.startswith('_')
 
 
 class HtmlGeneratorDummyBackend(object):
   def AddAttribute(self, attribute, html_name, read_only):
     pass
 
   def AddOperation(self, info, html_name):
     pass
 
 
 # ------------------------------------------------------------------------------
 
-class Dart2JSBackend(BaseGenerator):
+class Dart2JSBackend(object):
   """Generates a dart2js class for the dart:html library from a DOM IDL
   interface.
   """
 
   def __init__(self, interface, options):
-    super(Dart2JSBackend, self).__init__(None, None, interface)
+    self._interface = interface
     self._database = options.database
     self._template_loader = options.templates
     self._type_registry = options.type_registry
     self._html_interface_name = options.renamer.RenameInterface(self._interface)
     self._current_secondary_parent = None
 
   def HasImplementation(self):
     return not (IsPureInterface(self._interface.id) or
                 self._interface.id in _merged_html_interfaces)
 
   def ImplementationClassName(self):
     return self._ImplClassName(self._html_interface_name)
 
   def SetImplementationEmitter(self, implementation_emitter):
     self._dart_code = implementation_emitter
 
   def ImplementsMergedMembers(self):
     return True
 
   def _ImplClassName(self, type_name):
     name = type_name
     if type_name in nativified_classes:
       name = nativified_classes[type_name]
     return '_%sImpl' % name
 
+  def GenerateCallback(self, info):
+    pass
+
   def StartInterface(self):
     interface = self._interface
     interface_name = interface.id
 
     self._class_name = self._ImplClassName(self._html_interface_name)
 
     base = None
     if interface.parents:
       supertype = interface.parents[0].type.id
       if IsDartCollectionType(supertype):
@@ skipping 203 matching lines @@
         ' this._$HTML_NAME = $CONVERT(value); }'
         '\n  void set _$HTML_NAME(/*$NATIVE_TYPE*/ value)'
         ' native "this.$NAME = value;";'
         '\n',
         CONVERT=conversion.function_name,
         HTML_NAME=html_name,
         NAME=attr.id,
         INPUT_TYPE=conversion.input_type,
         NATIVE_TYPE=conversion.output_type)
 
+  def AmendIndexer(self, element_type):
+    pass
 
   def AddOperation(self, info, html_name):
     """
     Arguments:
       info: An OperationInfo object.
     """
     if self._HasCustomImplementation(info.name):
       return
 
     # Any conversions needed?
@@ skipping 260 matching lines @@
             attr2 = FindMatchingAttribute(interface, attr)
             if attr2:
               return (attr2, parent_interface_name)
 
           return FindInParent(
               self._database.GetInterface(parent_interface_name))
       return (None, None)
 
     return FindInParent(self._interface) if attr else (None, None)
 
+  def _DartType(self, type_name):

[Anton Muhin, 2012/10/03 13:37:49]

I am slightly uneasy about duplication of this code.

It's definitely small, maybe introduce a function?

[podivilov1, 2012/10/03 15:57:37]

I'm somewhat reluctant to accessing private fields of arbitrary objects from a
static function. Maybe leave as is for now?

+    return self._type_registry.DartType(type_name)
+
 # ------------------------------------------------------------------------------
 
 class DartLibraryEmitter():
   def __init__(self, multiemitter, template, dart_sources_dir):
     self._multiemitter = multiemitter
     self._template = template
     self._dart_sources_dir = dart_sources_dir
     self._path_to_emitter = {}
 
   def FileEmitter(self, basename, template=None):
@@ skipping 12 matching lines @@
 
     library_emitter = self._multiemitter.FileEmitter(library_file_path)
     library_file_dir = os.path.dirname(library_file_path)
     auxiliary_dir = os.path.relpath(auxiliary_dir, library_file_dir)
     imports_emitter = library_emitter.Emit(
         self._template, AUXILIARY_DIR=massage_path(auxiliary_dir))
     for path in sorted(self._path_to_emitter.keys()):
       relpath = os.path.relpath(path, library_file_dir)
       imports_emitter.Emit(
           "#source('$PATH');\n", PATH=massage_path(relpath))