Move interface merging info to type registry.

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
 import os
@@ skipping 15 matching lines @@
     'SelectElement.selectedOptions',
     'TableElement.createTBody',
     'LocalWindow.document',
     'LocalWindow.indexedDB',
     'LocalWindow.location',
     'LocalWindow.open',
     'LocalWindow.webkitCancelAnimationFrame',
     'LocalWindow.webkitRequestAnimationFrame',
     ])
 
-# This map controls merging of interfaces in dart:html library.
-# All constants, attributes, and operations of merged interface (key) are
-# added to target interface (value). All references to the merged interface
-# (e.g. parameter types, return types, parent interfaces) are replaced with
-# target interface. There are two important restrictions:
-# 1) Merged and target interfaces shouldn't have common members, otherwise there
-# would be duplicated declarations in generated Dart code.
-# 2) Merged interface should be direct child of target interface, so the
-# children of merged interface are not affected by the merge.
-# As a consequence, target interface implementation and its direct children
-# interface implementations should implement merged attribute accessors and
-# operations. For example, SVGElement and Element implementation classes should
-# implement HTMLElement.insertAdjacentElement(), HTMLElement.innerHTML, etc.
-_merged_html_interfaces = {
-   'HTMLDocument': 'Document',
-   'HTMLElement': 'Element'
-}
 
 # Types that are accessible cross-frame in a limited fashion.
 # In these cases, the base type (e.g., Window) provides restricted access
 # while the subtype (e.g., LocalWindow) provides full access to the
 # corresponding objects if there are from the same frame.
 _secure_base_types = {
   'LocalWindow': 'Window',
   'LocalLocation': 'Location',
   'LocalHistory': 'History',
 }
@@ skipping 149 matching lines @@
   def __init__(self, options, library_emitter, event_generator, interface,
                backend):
     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._interface_type_info = self._type_registry.TypeInfo(self._interface.id)
     self._html_interface_name = options.renamer.RenameInterface(self._interface)
 
   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=self._DartType(info.type_name),
               PARAMS=info.ParametersImplementationDeclaration(self._DartType))
     self._backend.GenerateCallback(info)
 
   def GenerateInterface(self):
-    interface_type_info = self._type_registry.TypeInfo(self._interface.id)
-    if (not self._interface.id in _merged_html_interfaces and
-        interface_type_info.has_generated_interface()):
+    if (self._interface_type_info.has_generated_interface() and
+        not self._interface_type_info.merged_into()):
       interface_emitter = self._library_emitter.FileEmitter(
           self._html_interface_name)
     else:
       interface_emitter = emitter.Emitter()
 
     template_file = 'interface_%s.darttemplate' % self._html_interface_name
     interface_template = (self._template_loader.TryLoad(template_file) or
                           self._template_loader.Load('interface.darttemplate'))
 
     typename = self._html_interface_name
@@ skipping 64 matching lines @@
     (self._type_comment_emitter,
      self._members_emitter,
      self._top_level_emitter) = interface_emitter.Emit(
          interface_template + '$!TOP_LEVEL',
          ID=typename,
          EXTENDS=implements_str)
 
     self._type_comment_emitter.Emit("/// @domName $DOMNAME",
         DOMNAME=self._interface.doc_js_name)
 
-    if self._backend.HasImplementation():
-      if not self._interface.id in _merged_html_interfaces:
-        name = self._html_interface_name
-        basename = '%sImpl' % name
-      else:
-        basename = '%sImpl_Merged' % self._html_interface_name
-      implementation_emitter = self._library_emitter.FileEmitter(basename)
-    else:
-      implementation_emitter = emitter.Emitter()
-
+    implementation_emitter = self._ImplementationEmitter()
     base_class = self._backend.BaseClassName()
     interface_type_info = self._type_registry.TypeInfo(self._interface.id)
     implemented_interfaces = [interface_type_info.interface_name()] +\
                              self._backend.AdditionalImplementedInterfaces()
     self._implementation_members_emitter = implementation_emitter.Emit(
         self._backend.ImplementationTemplate(),
         CLASSNAME=self._backend.ImplementationClassName(),
         EXTENDS=' extends %s' % base_class if base_class else '',
         IMPLEMENTS=' implements ' + ', '.join(implemented_interfaces),
         NATIVESPEC=self._backend.NativeSpec())
@@ skipping 23 matching lines @@
     events_interface = self._event_generator.ProcessInterface(
         self._interface, self._html_interface_name,
         self._backend.CustomJSMembers(),
         interface_emitter, implementation_emitter)
     if events_interface:
       self._EmitEventGetter(events_interface, '_%sImpl' % events_interface)
 
     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)
+    merged_interface = self._interface_type_info.merged_interface()
+    if merged_interface:
+      self.AddMembers(self._database.GetInterface(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)
 
@@ skipping 127 matching lines @@
     self._backend.SecondaryContext(interface)
     self.AddOperation(info, True)
 
   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 _ImplementationEmitter(self):
+    if IsPureInterface(self._interface.id):
+      return emitter.Emitter()
+
+    if not self._interface_type_info.merged_into():
+      name = self._html_interface_name
+      basename = '%sImpl' % name
+    else:
+      if self._backend.ImplementsMergedMembers():
+        # Merged members are implemented in target interface implementation.
+        return emitter.Emitter()
+      basename = '%sImpl_Merged' % self._html_interface_name
+    return self._library_emitter.FileEmitter(basename)
+
   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(
@@ skipping 45 matching lines @@
 class Dart2JSBackend(object):
   """Generates a dart2js class for the dart:html library from a DOM IDL
   interface.
   """
 
   def __init__(self, interface, options):
     self._interface = interface
     self._database = options.database
     self._template_loader = options.templates
     self._type_registry = options.type_registry
+    self._interface_type_info = self._type_registry.TypeInfo(self._interface.id)
     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 ImplementsMergedMembers(self):
     return True
 
   def _ImplClassName(self, type_name):
     return '_%sImpl' % type_name
 
   def GenerateCallback(self, info):
@@ skipping 111 matching lines @@
       self._AddAttributeUsingProperties(attribute, html_name, read_only)
       return
 
     # If the attribute is shadowing, we can't generate a shadowing
     # field (Issue 1633).
     # TODO(sra): _FindShadowedAttribute does not take into account the html
     #  renaming.  we should be looking for another attribute that has the same
     #  html_name.  Two attributes with the same IDL name might not match if one
     #  is renamed.
     (super_attribute, super_attribute_interface) = self._FindShadowedAttribute(
-        attribute, _merged_html_interfaces)
+        attribute)
     if super_attribute:
       if read_only:
         if attribute.type.id == super_attribute.type.id:
           # Compatible attribute, use the superclass property.  This works
           # because JavaScript will do its own dynamic dispatch.
           self._members_emitter.Emit(
               '\n'
               '  // Use implementation from $SUPER.\n'
               '  // final $TYPE $NAME;\n',
               SUPER=super_attribute_interface,
@@ skipping 301 matching lines @@
       return type_name
     return self._type_registry.TypeInfo(type_name).narrow_dart_type()
 
   def _NarrowInputType(self, type_name):
     return self._NarrowToImplementationType(type_name)
 
   def _NarrowOutputType(self, type_name):
     secure_name = SecureOutputType(self, type_name, True)
     return self._NarrowToImplementationType(secure_name)
 
-  def _FindShadowedAttribute(self, attr, merged_interfaces={}):
+  def _FindShadowedAttribute(self, attr):
     """Returns (attribute, superinterface) or (None, None)."""
     def FindInParent(interface):
       """Returns matching attribute in parent, or None."""
       if interface.parents:
         parent = interface.parents[0]
         if IsDartCollectionType(parent.type.id):
           return (None, None)
         if IsPureInterface(parent.type.id):
           return (None, None)
         if self._database.HasInterface(parent.type.id):
           interfaces_to_search_in = []
-          if parent.type.id in merged_interfaces:
+          parent_interface_name = parent.type.id
+          interfaces_to_search_in.append(parent_interface_name)
+          parent_type_info = self._type_registry.TypeInfo(parent_interface_name)
+          if parent_type_info.merged_into():
             # IDL parent was merged into another interface, which became a
             # parent interface in Dart.
-            interfaces_to_search_in.append(parent.type.id)
-            parent_interface_name = merged_interfaces[parent.type.id]
-          else:
-            parent_interface_name = parent.type.id
+            parent_interface_name = parent_type_info.merged_into()
+            interfaces_to_search_in.append(parent_interface_name)
+          elif parent_type_info.merged_interface():
+            # IDL parent has another interface that was merged into it.
+            interfaces_to_search_in.append(parent_type_info.merged_interface())
 
-          for interface_name in merged_interfaces:
-            if merged_interfaces[interface_name] == parent_interface_name:
-              # IDL parent has another interface that was merged into it.
-              interfaces_to_search_in.append(interface_name)
-
-          interfaces_to_search_in.append(parent_interface_name)
           for interface_name in interfaces_to_search_in:
             interface = self._database.GetInterface(interface_name)
             attr2 = FindMatchingAttribute(interface, attr)
             if attr2:
               return (attr2, parent_interface_name)
 
           return FindInParent(
               self._database.GetInterface(parent_interface_name))
       return (None, None)
 
@@ skipping 27 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))