[dart2dart] fix after https://codereview.chromium.org/11227007

lib/compiler/implementation/dart_backend/renamer.dart

 // 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.
 
 part of dart_backend;
 
 Function get _compareNodes =>
     compareBy((n) => n.getBeginToken().charOffset);
 
 typedef String _Renamer(Renamable renamable);
@@ skipping 65 matching lines @@
       renames[node] = renamer(node);
     }
   }
 
   sortedForEach(Map<Element, Dynamic> map, f) {
     for (Element element in sortElements(map.keys)) {
       f(element, map[element]);
     }
   }
 
+  String renameType(DartType type, Function renameElement) {
+    // TODO(smok): Do not rename type if it is in platform library or
+    // js-helpers.
+    StringBuffer result = new StringBuffer(renameElement(type.element));
+    if (type is InterfaceType && !type.arguments.isEmpty) {
+      result.add('<');
+      Link<DartType> argumentsLink = type.arguments;
+      result.add(renameType(argumentsLink.head, renameElement));
+      for (Link<DartType> link = argumentsLink.tail; !link.isEmpty;
+           link = link.tail) {
+        result.add(',');
+        result.add(renameType(link.head, renameElement));
+      }
+      result.add('>');
+    }
+    return result.toString();
+  }
+
+  String renameConstructor(Element element, DartType type,
+      Function renameString, Function renameElement) {
+    assert(element.isConstructor());
+    StringBuffer result = new StringBuffer();
+    String name = element.name.slowToString();
+    if (element.name != element.getEnclosingClass().name) {
+      // Named constructor or factory. Is there a more reliable way to check
+      // this case?
+      result.add(renameType(type, renameElement));
+      result.add('.');
+      String prefix = '${element.getEnclosingClass().name.slowToString()}\$';
+      if (!name.startsWith(prefix)) {
+        // Factory for another interface (that is going away soon).
+        compiler.internalErrorOnElement(element,
+            "Factory constructors for external interfaces are not supported.");
+      }
+      name = name.substring(prefix.length);
+      result.add(name);
+    } else {
+      result.add(renameType(type, renameElement));
+    }
+    return result.toString();
+  }
+
   Function makeElementRenamer(rename, generateUniqueName) => (element) {
     assert(Elements.isStaticOrTopLevel(element)
            || element is TypeVariableElement);
     // TODO(smok): We may want to reuse class static field and method names.
     String originalName = element.name.slowToString();
     LibraryElement library = element.getLibrary();
+    if (identical(element.getLibrary(), compiler.coreLibrary)) {
+      return originalName;
+    }
     if (library.isPlatformLibrary) {
       assert(element.isTopLevel());
       final prefix =
           imports.putIfAbsent(library, () => generateUniqueName('p'));
       return '$prefix.$originalName';
     }
 
     return rename(library, originalName);
   };
 
   Function makeRenamer(generateUniqueName) =>
       (library, originalName) =>
           renamed.putIfAbsent(library, () => <String>{})
               .putIfAbsent(originalName,
                   () => generateUniqueName(originalName));
 
   // Renamer function that takes library and original name and returns a new
   // name for given identifier.
   Function rename;
+  Function renameElement;
   // A function that takes original identifier name and generates a new unique
   // identifier.
   Function generateUniqueName;
   if (compiler.enableMinification) {
     MinifyingGenerator generator = new MinifyingGenerator();
     Set<String> forbiddenIdentifiers = new Set<String>.from(['main']);
     forbiddenIdentifiers.addAll(Keyword.keywords.keys);
     forbiddenIdentifiers.addAll(fixedMemberNames);
     generateUniqueName = (_) =>
         generator.generate(forbiddenIdentifiers.contains);
     rename = makeRenamer(generateUniqueName);
-    Function renameElement = makeElementRenamer(rename, generateUniqueName);
+    renameElement = makeElementRenamer(rename, generateUniqueName);
 
     Set<String> allParameterIdentifiers = new Set<String>();
     for (var functionScope in placeholderCollector.functionScopes.values) {
       allParameterIdentifiers.addAll(functionScope.parameterIdentifiers);
     }
     // Build a sorted (by usage) list of local nodes that will be renamed to
     // the same identifier. So the top-used local variables in all functions
     // will be renamed first and will all share the same new identifier.
     List<Set<Node>> allSortedLocals = new List<Set<Node>>();
     for (var functionScope in placeholderCollector.functionScopes.values) {
@@ skipping 48 matching lines @@
     final usedTopLevelOrMemberIdentifiers = new Set<String>();
     usedTopLevelOrMemberIdentifiers.add('main');
     usedTopLevelOrMemberIdentifiers.addAll(fixedMemberNames);
     generateUniqueName = (originalName) {
       String newName = conservativeGenerator(
           originalName, usedTopLevelOrMemberIdentifiers.contains);
       usedTopLevelOrMemberIdentifiers.add(newName);
       return newName;
     };
     rename = makeRenamer(generateUniqueName);
-    Function renameElement = makeElementRenamer(rename, generateUniqueName);
+    renameElement = makeElementRenamer(rename, generateUniqueName);
     // Rename elements.
     sortedForEach(placeholderCollector.elementNodes,
         (Element element, Set<Node> nodes) {
       renameNodes(nodes, (_) => renameElement(element));
     });
 
     // Rename locals.
     sortedForEach(placeholderCollector.functionScopes,
         (functionElement, functionScope) {
       Set<LocalPlaceholder> placeholders = functionScope.localPlaceholders;
@@ skipping 21 matching lines @@
     // Do not rename members to top-levels, that allows to avoid renaming
     // members to constructors.
     usedMemberIdentifiers.addAll(usedTopLevelOrMemberIdentifiers);
     placeholderCollector.memberPlaceholders.forEach((identifier, nodes) {
       String newIdentifier = conservativeGenerator(
           identifier, usedMemberIdentifiers.contains);
       renameNodes(nodes, (_) => newIdentifier);
     });
   }
 
+  // Rename constructors.
+  placeholderCollector.constructorPlaceholders.forEach(
+      (Element constructor, List<ConstructorPlaceholder> placeholders) {
+        for (ConstructorPlaceholder ph in placeholders) {
+          renames[ph.node] =
+              renameConstructor(constructor, ph.type, rename, renameElement);
+        }
+  });
   sortedForEach(placeholderCollector.privateNodes, (library, nodes) {
     renameNodes(nodes, (node) => rename(library, node.source.slowToString()));
   });
   renameNodes(placeholderCollector.unresolvedNodes,
       (_) => generateUniqueName('Unresolved'));
   renameNodes(placeholderCollector.nullNodes, (_) => '');
   if (cutDeclarationTypes) {
     for (DeclarationTypePlaceholder placeholder in
          placeholderCollector.declarationTypePlaceholders) {
       renames[placeholder.typeNode] = placeholder.requiresVar ? 'var' : '';
@@ skipping 44 matching lines @@
     index ~/= firstCharAlphabet.length;
     int length = otherCharsAlphabet.length;
     while (index >= length) {
       resultBuilder.add(otherCharsAlphabet[index % length]);
       index ~/= length;
     }
     resultBuilder.add(otherCharsAlphabet[index]);
     return resultBuilder.toString();
   }
 }