Add back unseparated out version of method overloads in dart:html.

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, \
     DartDomNameOfAttribute, FindMatchingAttribute, \
     TypeOrNothing, ConvertToFuture, GetCallbackInfo
 from copy import deepcopy
 from htmlrenamer import convert_to_future_members, custom_html_constructors, \
-    keep_overloaded_members, private_html_members, renamed_html_members, \
-    renamed_overloads, removed_html_members
+    keep_overloaded_members, overloaded_and_renamed, private_html_members, \
+    renamed_html_members, renamed_overloads, removed_html_members
 import logging
 import monitored
 import sys
 
 _logger = logging.getLogger('htmldartgenerator')
 
 # Types that are accessible cross-frame in a limited fashion.
 # In these cases, the base type (e.g., WindowBase) provides restricted access
 # while the subtype (e.g., Window) provides full access to the
 # corresponding objects if there are from the same frame.
@@ skipping 121 matching lines @@
       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."""
+    operation with a different DartName), but leave the original version as
+    well in some cases."""
     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]
 
+    added_operations = []
     for operation in interface.operations:
       full_operation_str = self._GetStringRepresentation(interface, operation)
       if (full_operation_str in renamed_overloads and
           renamed_overloads[full_operation_str] not in already_renamed):
-        dart_name = renamed_overloads[full_operation_str]
-        if not dart_name:
-          continue
+        if '%s.%s' % (interface.id, operation.id) in overloaded_and_renamed:
+          cloned_operation = deepcopy(operation)
+          cloned_operation.ext_attrs['DartName'] = renamed_overloads[
+              full_operation_str]
+          added_operations.append(cloned_operation)
+        else:
+          dart_name = renamed_overloads[full_operation_str]
+          if not dart_name:
+            continue
 
-        operation.ext_attrs['DartName'] = dart_name
-        potential_added_operations.add(operation.id)
+          operation.ext_attrs['DartName'] = dart_name
+          potential_added_operations.add(operation.id)
       self._EnsureNoMultipleTypeSignatures(interface, operation,
           operations_by_name)
+    interface.operations += added_operations
     self._AddDesiredOverloadedOperations(potential_added_operations, interface,
         operations_by_name)
 
   def _AddDesiredOverloadedOperations(self, potential_added_operations,
       interface, original_operations_by_name):
     """For some cases we desire to keep the overloaded version in dart, for
     simplicity of API, and explain the parameters accepted in documentation."""
     updated_operations_by_name = self._OperationsByName(interface)
     for operation_id in potential_added_operations:
       if (operation_id not in updated_operations_by_name and
           '%s.%s' % (interface.id, operation_id) in keep_overloaded_members):
         for operation in original_operations_by_name[operation_id]:
           cloned_operation = deepcopy(operation)
           cloned_operation.ext_attrs['DartName'] = operation_id
           interface.operations.append(cloned_operation)
 
   def _EnsureNoMultipleTypeSignatures(self, interface, operation,
       operations_by_name):
     """Make sure that there is now at most one operation with a particular
     operation.id. If not, stop library generation, and throw an error, requiring
     programmer input about the best name change before proceeding."""
     operation_str = '%s.%s' % (interface.id, operation.id)
     if (operation.id in operations_by_name and
         len(operations_by_name[operation.id]) > 1 and
         len(filter(lambda overload: overload.startswith(operation_str),
             renamed_overloads.keys())) == 0 and
         operation_str not in keep_overloaded_members and
+        operation_str not in overloaded_and_renamed and
         operation_str not in renamed_html_members and
         operation_str not in private_html_members and
         operation_str not in removed_html_members and
         operation.id != '__getter__' and
         operation.id != '__setter__' and
         operation.id != '__delete__'):
-      _logger.error('Multiple type signatures for %s.%s' % (
+      _logger.error('Multiple type signatures for %s.%s. Please file a bug with'
+          ' the dart:html team to determine if one of these functions should be'
+          ' renamed.' % (
           interface.id, operation.id))
-      raise Exception('Rename one of the methods in renamed_overloads or add it'
-          ' to  keep_overloaded_members.\n'
-          'Generation UNsuccessful.')
 
   def _GetStringRepresentation(self, interface, operation):
     """Given an IDLOperation, return a object-independent representation of the
     operations's signature."""
     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:
@@ skipping 468 matching lines @@
 
   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)
 
   def _TypeInfo(self, type_name):
     return self._type_registry.TypeInfo(type_name)