Enable unique global renaming in dart2dart minification.

sdk/lib/_internal/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 49 matching lines @@
 
 /**
  * Renames only top-level elements that would let to ambiguity if not renamed.
  */
 void renamePlaceholders(
     Compiler compiler,
     PlaceholderCollector placeholderCollector,
     Map<Node, String> renames,
     Map<LibraryElement, String> imports,
     Set<String> fixedMemberNames,
-    bool cutDeclarationTypes) {
+    bool cutDeclarationTypes,
+    {uniqueGlobalNaming: false}) {
   final Map<LibraryElement, Map<String, String>> renamed
       = new Map<LibraryElement, Map<String, String>>();
 
   renameNodes(Iterable<Node> nodes, renamer) {
     for (Node node in sorted(nodes, _compareNodes)) {
       renames[node] = renamer(node);
     }
   }
 
   sortedForEach(Map<Element, dynamic> map, f) {
@@ skipping 90 matching lines @@
     Set<String> forbiddenIdentifiers = new Set<String>.from(['main']);
     forbiddenIdentifiers.addAll(Keyword.keywords.keys);
     forbiddenIdentifiers.addAll(fixedMemberNames);
     generateUniqueName = (_) =>
         generator.generate((name) =>
             forbiddenIdentifiers.contains(name)
             || allNamedParameterIdentifiers.contains(name));
     rename = makeRenamer(generateUniqueName);
     renameElement = makeElementRenamer(rename, generateUniqueName);
 
-    // 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) {
-      // Add current sorted local identifiers to the whole sorted list
-      // of all local identifiers for all functions.
-      List<LocalPlaceholder> currentSortedPlaceholders =
-          sorted(functionScope.localPlaceholders,
-              compareBy((LocalPlaceholder ph) => -ph.nodes.length));
-      List<Set<Node>> currentSortedNodes =
-          currentSortedPlaceholders.map((ph) => ph.nodes).toList();
-      // Make room in all sorted locals list for new stuff.
-      while (currentSortedNodes.length > allSortedLocals.length) {
-        allSortedLocals.add(new Set<Node>());
+    List<Set<Node>> allLocals = new List<Set<Node>>();
+    // If we are using the mirror_helper library we need all names to be
+    // globally unique.
+    if(uniqueGlobalNaming) {

[ahe, 2013/08/16 18:39:26]

Missing space after if.

[zarah, 2013/08/28 10:19:29]

Done.

+      for (var functionScope in placeholderCollector.functionScopes.values) {
+        functionScope.localPlaceholders.forEach(
+            (ph) => allLocals.add(new Set<Node>()..addAll(ph.nodes)));

[ahe, 2013/08/16 18:39:26]

ph.nodes.toSet()?

[zarah, 2013/08/28 10:19:29]

Done.

       }
-      for (int i = 0; i < currentSortedNodes.length; i++) {
-        allSortedLocals[i].addAll(currentSortedNodes[i]);
+    } else {
+      // 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.
+      for (var functionScope in placeholderCollector.functionScopes.values) {
+        // Add current sorted local identifiers to the whole sorted list
+        // of all local identifiers for all functions.
+        List<LocalPlaceholder> currentSortedPlaceholders =
+            sorted(functionScope.localPlaceholders,
+                compareBy((LocalPlaceholder ph) => -ph.nodes.length));
+        List<Set<Node>> currentSortedNodes =
+            currentSortedPlaceholders.map((ph) => ph.nodes).toList();
+        // Make room in all sorted locals list for new stuff.
+        while (currentSortedNodes.length > allLocals.length) {
+          allLocals.add(new Set<Node>());
+        }
+        for (int i = 0; i < currentSortedNodes.length; i++) {
+          allLocals[i].addAll(currentSortedNodes[i]);
+        }
       }
     }
 
     // Rename elements, members and locals together based on their usage count,
     // otherwise when we rename elements first there will be no good identifiers
     // left for members even if they are used often.
     String elementRenamer(ElementRenamable elementRenamable) =>
         renameElement(elementRenamable.element);
     String memberRenamer(MemberRenamable memberRenamable) =>
         generator.generate(forbiddenIdentifiers.contains);
     Function localRenamer = generateUniqueName;
     List<Renamable> renamables = [];
     placeholderCollector.elementNodes.forEach(
         (Element element, Set<Node> nodes) {
       renamables.add(new ElementRenamable(element, nodes, elementRenamer));
     });
     placeholderCollector.memberPlaceholders.forEach(
         (String memberName, Set<Identifier> identifiers) {
       renamables.add(
           new MemberRenamable(memberName, identifiers, memberRenamer));
     });
-    for (Set<Node> localIdentifiers in allSortedLocals) {
+    for (Set<Node> localIdentifiers in allLocals) {
       renamables.add(new LocalRenamable(localIdentifiers, localRenamer));
     }
     renamables.sort((Renamable renamable1, Renamable renamable2) =>
         renamable1.compareTo(renamable2));
     for (Renamable renamable in renamables) {
       String newName = renamable.rename();
       renameNodes(renamable.nodes, (_) => newName);
     }
   } else {
     // Never rename anything to 'main'.
@@ skipping 116 matching lines @@
     index ~/= firstCharAlphabet.length;
     int length = otherCharsAlphabet.length;
     while (index >= length) {
       resultBuilder.write(otherCharsAlphabet[index % length]);
       index ~/= length;
     }
     resultBuilder.write(otherCharsAlphabet[index]);
     return resultBuilder.toString();
   }
 }