Do not add secondary interfaces implemented by parents.

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 537 matching lines @@
 
   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)
+          result.add(parent.type.id)
           continue
         if self._database.HasInterface(parent.type.id):
           parent_interface = self._database.GetInterface(parent.type.id)
-          result.append(parent_interface)
+          result.add(parent_interface)
           walk(parent_interface.parents)
 
-    result = []
+    result = set()
     if interface.parents:
       parent = interface.parents[0]
       if IsPureInterface(parent.type.id):
         walk(interface.parents)
       else:
         walk(interface.parents[1:])
+        while self._database.HasInterface(parent.type.id):

[podivilov, 2012/10/30 13:43:49]

EventTarget is an extended attribute in idls, not an implemented interface. We
currently add it to interface hierarchy, which is a hack and should be fixed.
Given that, adding EventTarget to parents only if interface is EventTarget and
its parent is not an EventTarget seems like a better solution.

[Anton Muhin, 2012/10/30 13:45:09]

I am not sure it's a hack.  And even though currently it only helps for
EventTargets, I still think it's superior approach---we shouldn't emit
additional members.

On 2012/10/30 13:43:49, podivilov wrote:

[podivilov, 2012/10/30 13:55:42]

It's a hack because we agreed that IDL AST should represent what's written in
idls. I'm not sure we shouldn't emit additional members, as it will break
bindings for non-virtual methods.

[Anton Muhin, 2012/10/30 14:05:01]

WebKit IDLs has many peculiarities, for example, according to
https://developer.mozilla.org/en-US/docs/IndexedDB/IDBRequest IDBRequest should
inherit from EventTarget.

So it's rather irregular way in which information about EventTarget is
represented in WebKit IDLs than a hack.

In the similar way one can always make subinterface extend an interface which
parent implements.

I remember I was concerned about non-virtual methods too, but thinking more
about it I am not sure if it should be treated as another peculiar thing about
WebKit or not---I believe in the cases where methods are overridden by IDLs,
they should be virtual in C++ as per Web IDL semantics.

On 2012/10/30 13:55:42, podivilov wrote:

[podivilov, 2012/10/30 14:12:15]

I think the rule of thumb is we shouldn't be more clever than
CodeGeneratorV8.pm, otherwise we'll be beaten one day. Adding non-trivial logic
in places such as this only make future debugging more painful. If you
explicitly state that you are adding an exception only for EventTarget, this
code will be easier to find, understand and modify.

+          parent_interface = self._database.GetInterface(parent.type.id)
+          result.discard(parent_interface)
+          result -= self._TransitiveSecondaryParents(parent_interface)
+          if not parent_interface.parents:
+            break
+          parent = parent_interface.parents[0]
+
     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
@@ skipping 532 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(
           "part '$PATH';\n", PATH=massage_path(relpath))