Do not merge IDL interfaces in dartdomgenerator.

lib/dom/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."""
 
 from systemfrog import *
 from systeminterface import *
@@ skipping 244 matching lines @@
     "Window.get:frameElement",
     ])
 
 _html_library_custom = set([
     'IFrameElement.get:contentWindow',
     'Window.get:document',
     'Window.get:top',
     'IDBDatabase.transaction',
     ])
 
+# 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'
+}
+
 # Events without onEventName attributes in the  IDL we want to support.
 # We can automatically extract most event event names by checking for
 # onEventName methods in the IDL but some events aren't listed so we need
 # to manually add them here so that they are easy for users to find.
 _html_manual_events = {
   'Element': ['touchleave', 'touchenter', 'webkitTransitionEnd'],
   'Window': ['DOMContentLoaded']
 }
 
 # These event names must be camel case when attaching event listeners
@@ skipping 421 matching lines @@
         templates, database, emitters, output_dir)
     self._dart_interface_file_paths = []
     self._factory_provider_emitters = {}
 
   def InterfaceGenerator(self,
                          interface,
                          common_prefix,
                          super_interface_name,
                          source_filter):
     """."""
+    if interface.id in _merged_html_interfaces:
+      return None
+
     interface_name = interface.id
     dart_interface_file_path = self._FilePathForDartInterface(interface_name)
 
     self._dart_interface_file_paths.append(dart_interface_file_path)
 
     dart_interface_code = self._emitters.FileEmitter(dart_interface_file_path)
 
     template_file = 'interface_%s.darttemplate' % interface_name
     template = self._templates.TryLoad(template_file)
     if not template:
@@ skipping 115 matching lines @@
         TYPE=DartType(element_type))
 
     emit_events, events = self._shared.GetEventAttributes(self._interface)
     if not emit_events:
       return
     elif events:
       self.AddEventAttributes(events)
     else:
       self._EmitEventGetter(self._shared.GetParentEventsClass(self._interface))
 
+    for merged_interface in _merged_html_interfaces:
+      if _merged_html_interfaces[merged_interface] == self._interface.id:
+        self.AddMembers(self._database.GetInterface(merged_interface))
 
   def AddAttribute(self, getter, setter):
     dom_name = DartDomNameOfAttribute(getter)
     html_getter_name = self._shared.RenameInHtmlLibrary(
       self._interface.id, dom_name, 'get:')
     html_setter_name = self._shared.RenameInHtmlLibrary(
       self._interface.id, dom_name, 'set:')
 
     if not html_getter_name or self._shared.IsPrivate(html_getter_name):
       getter = None
@@ skipping 145 matching lines @@
 
     emit_events, events = self._shared.GetEventAttributes(self._interface)
     if not emit_events:
       return
     elif events:
       self.AddEventAttributes(events)
     else:
       parent_events_class = self._shared.GetParentEventsClass(self._interface)
       self._EmitEventGetter('_' + parent_events_class + 'Impl')
 
+    for merged_interface in _merged_html_interfaces:
+      if _merged_html_interfaces[merged_interface] == self._interface.id:
+        self.AddMembers(self._database.GetInterface(merged_interface))
+
   def _EmitFactoryProvider(self, interface_name, constructor_info):
     template_file = 'factoryprovider_%s.darttemplate' % interface_name
     template = self._system._templates.TryLoad(template_file)
     if not template:
       template = self._system._templates.Load('factoryprovider.darttemplate')
 
     factory_provider = '_' + interface_name + 'FactoryProvider'
     emitter = self._system._ImplFileEmitter(factory_provider)
     emitter.Emit(
         template,
@@ skipping 84 matching lines @@
     if ((getter and html_getter_name != getter.id) or
         (setter and html_setter_name != setter.id)):
       if getter:
         self._AddRenamingGetter(getter, html_getter_name)
       if setter:
         self._AddRenamingSetter(setter, html_setter_name)
       return
 
     # If the (getter, setter) pair is shadowing, we can't generate a shadowing
     # field (Issue 1633).
-    (super_getter, super_getter_interface) = self._FindShadowedAttribute(getter)
-    (super_setter, super_setter_interface) = self._FindShadowedAttribute(setter)
+    (super_getter, super_getter_interface) = self._FindShadowedAttribute(getter, _merged_html_interfaces)
+    (super_setter, super_setter_interface) = self._FindShadowedAttribute(setter, _merged_html_interfaces)
     if super_getter or super_setter:
       if getter and not setter and super_getter and not super_setter:
         if DartType(getter.type.id) == DartType(super_getter.type.id):
           # Compatible getter, use the superclass property.  This works because
           # JavaScript will do its own dynamic dispatch.
           output_type = getter and self._NarrowOutputType(getter.type.id)
           self._members_emitter.Emit(
               '\n'
               '  // Use implementation from $SUPER.\n'
               '  // final $TYPE $NAME;\n',
-              SUPER=super_getter_interface.id,
+              SUPER=super_getter_interface,
               NAME=DartDomNameOfAttribute(getter),
               TYPE=output_type)
           return
 
       self._members_emitter.Emit('\n  // Shadowing definition.')
       self._AddAttributeUsingProperties(getter, setter)
       return
 
     output_type = getter and self._NarrowOutputType(getter.type.id)
     input_type = setter and self._NarrowInputType(setter.type.id)
@@ skipping 119 matching lines @@
         templates, database, emitters, output_dir)
     self._dart_frog_file_paths = []
     self._factory_provider_emitters = {}
 
   def InterfaceGenerator(self,
                          interface,
                          common_prefix,
                          super_interface_name,
                          source_filter):
     """."""
+    if interface.id in _merged_html_interfaces:
+      return None
+
     if IsPureInterface(interface.id):
       return
     template_file = 'impl_%s.darttemplate' % interface.id
     template = self._templates.TryLoad(template_file)
     if not template:
       template = self._templates.Load('frog_impl.darttemplate')
 
     dart_code = self._ImplFileEmitter(interface.id)
     return HtmlFrogClassGenerator(self, interface, template,
                                   super_interface_name, dart_code, self._shared)
@@ skipping 81 matching lines @@
             Collect(database.GetInterface(parent.type.id),
                     seen, collected)
 
   inheritance_closure = {}
   for interface in database.GetInterfaces():
     seen = set()
     collected = []
     Collect(interface, seen, collected)
     inheritance_closure[interface.id] = collected
   return inheritance_closure