Drop DatabaseBuilder.set_same_signatures method.

lib/dom/scripts/databasebuilder.py

 #!/usr/bin/python
 # Copyright (c) 2011, 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.
 
 import copy
 import database
 import idlparser
 import logging
 import os
@@ skipping 51 matching lines @@
     self.obsolete_old_declarations = obsolete_old_declarations
 
 
 class DatabaseBuilder(object):
   def __init__(self, database):
     """DatabaseBuilder is used for importing and merging interfaces into
     the Database"""
     self._database = database
     self._imported_interfaces = []
     self._impl_stmts = []
-    self._same_signatures = {}
 
   def _load_idl_file(self, file_name, import_options):
     """Loads an IDL file intor memory"""
     idl_parser = idlparser.IDLParser(import_options.idl_syntax)
 
     try:
       f = open(file_name, 'r')
       content = f.read()
       f.close()
 
@@ skipping 119 matching lines @@
     map(add_source_annotation, interface.attributes)
     map(add_source_annotation, interface.operations)
 
   def _sign(self, node):
     """Computes a unique signature for the node, for merging purposed, by
     concatenating types and names in the declaration."""
     if isinstance(node, IDLType):
       res = node.id
       if res.startswith('unsigned '):
         res = res[len('unsigned '):]
-      if res in self._same_signatures:
-        res = self._same_signatures[res]
       return res
 
     res = []
     if isinstance(node, IDLInterface):
       res = ['interface', node.id]
     elif isinstance(node, IDLParentInterface):
       res = ['parent', self._sign(node.type)]
     elif isinstance(node, IDLOperation):
       res = ['op']
       for special in node.specials:
@@ skipping 202 matching lines @@
                 import_options.source_attributes)
           return
       # not found, so add new one
       parent = IDLParentInterface(None)
       parent.type = IDLType(implemented_name)
       if source:
         parent.annotations[source] = IDLAnnotation(
             import_options.source_attributes)
       interface.parents.append(parent)
 
-  def set_same_signatures(self, signatures_table):
-    """Customize signature calculations by providing a custom table
-    indicating which types are equivalent"""
-    self._same_signatures = signatures_table
-
   def merge_imported_interfaces(self, optional_argument_whitelist):
     """Merges all imported interfaces and loads them into the DB."""
 
     # Step 1: Pre process imported interfaces
     for interface, module_name, import_options in self._imported_interfaces:
       self._split_declarations(interface, optional_argument_whitelist)
       self._annotate(interface, module_name, import_options)
 
     # Step 2: Add all new interfaces and merge overlapping ones
     for interface, module_name, import_options in self._imported_interfaces:
@@ skipping 139 matching lines @@
             annotation = idl_node.annotations[source]
             for name, value in annotation.items():
               if (name in top_level_annotation
                   and value == top_level_annotation[name]):
                 del annotation[name]
 
         map(normalize, interface.parents)
         map(normalize, interface.constants)
         map(normalize, interface.attributes)
         map(normalize, interface.operations)