Removing overloaded operations in dart2js.

tools/dom/scripts/htmldartgenerator.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 generator import AnalyzeOperation, ConstantOutputOrder, \
@@ skipping 75 matching lines @@
         if parent == self._interface:
           continue
         parent_type_info = self._type_registry.TypeInfo(parent.id)
         if parent_type_info.list_item_type():
           self.AmendIndexer(parent_type_info.list_item_type())
           break
 
     # Group overloaded operations by name.
     self._AddRenamedOverloads(interface)
     operationsByName = self._OperationsByName(interface)
+    if self.OmitOperationOverrides():
+      self._RemoveShadowingOperationsWithSameSignature(operationsByName,
+          interface)
 
     # Generate operations.
     for id in sorted(operationsByName.keys()):
       operations = operationsByName[id]
       info = AnalyzeOperation(interface, operations)
       self.AddOperation(info, declare_only)
       if ('%s.%s' % (interface.id, info.declared_name) in
           convert_to_future_members):
         self.AddOperation(ConvertToFuture(info), declare_only)
 
   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._database.TransitiveSecondaryParents(interface)
     for parent_interface in sorted(secondary_parents):
       if isinstance(parent_interface, str):
         continue
       for attr in sorted(parent_interface.attributes, ConstantOutputOrder):
         if not FindMatchingAttribute(interface, attr):
           if attr.type.id != 'EventListener':
             self.SecondaryContext(parent_interface)
             self.AddAttribute(attr)
 
       # Group overloaded operations by name.
       operationsByName =self._OperationsByName(parent_interface)
 
+      if self.OmitOperationOverrides():
+        self._RemoveShadowingOperationsWithSameSignature(operationsByName,
+            interface)
+
       # Generate operations.
       for id in sorted(operationsByName.keys()):
         if not any(op.id == id for op in interface.operations):
           operations = operationsByName[id]
           info = AnalyzeOperation(interface, operations)
           self.SecondaryContext(parent_interface)
           self.AddOperation(info)
 
+  def _RemoveShadowingOperationsWithSameSignature(self, operationsByName,
+      interface):
+    if not interface.parents:
+      return
+
+    parent = self._database.GetInterface(interface.parents[0].type.id)
+    if parent == self._interface or parent == interface:
+      return
+    for operation in parent.operations:
+      if operation.id in operationsByName:
+        operations = operationsByName[operation.id]
+        for existing_operation in operations:
+          if existing_operation.SameSignatureAs(operation):
+            del operationsByName[operation.id]
+
   def _AddRenamedOverloads(self, interface):
     """The IDL has a number of functions with the same name but that accept
     different types. This is fine for JavaScript, but results in vague type
     signatures for Dart. We rename some of these (by adding a new identical
     operation with a different DartName), and leave the original version in a
     few specific instances."""
     potential_added_operations = set()
     operations_by_name = self._OperationsByName(interface)
     already_renamed = [operation.ext_attrs['DartName'] if 'DartName' in
         operation.ext_attrs else '' for operation in interface.operations]
@@ skipping 52 matching lines @@
     return '%s.%s(%s)' % (interface.id, operation.id, ', '.join(
         ['%s %s' % (arg.type.id, arg.id) for arg in operation.arguments]))
 
   def _OperationsByName(self, interface):
     operationsByName = {}
     for operation in interface.operations:
       name = operation.ext_attrs.get('DartName', operation.id)
       operationsByName.setdefault(name, []).append(operation)
     return operationsByName
 
+  def OmitOperationOverrides(self):
+    return False
+
   def AddConstant(self, constant):
     const_name = self._renamer.RenameMember(
         self._interface.id, constant, constant.id, 'get:', dartify_name=False)
     if not const_name:
       return
 
     annotations = self._metadata.GetFormattedMetadata(
         self._library_name, self._interface, constant.id, '  ')
 
     type = TypeOrNothing(self._DartType(constant.type.id), constant.type.id)
@@ skipping 424 matching lines @@
     if dart_name == 'Window':
       return _secure_base_types[dart_name]
     return dart_name
 
   def SecureBaseName(self, type_name):
     if type_name in _secure_base_types:
       return _secure_base_types[type_name]
 
   def _DartType(self, type_name):
     return self._type_registry.DartType(type_name)