Fix issue with dart2dart translation of parameters (collision risk).

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 149 matching lines @@
               .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;
+
+  Set<String> allNamedParameterIdentifiers = new Set<String>();
+  for (var functionScope in placeholderCollector.functionScopes.values) {
+    allNamedParameterIdentifiers.addAll(functionScope.parameterIdentifiers);
+  }
+
   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);
+        generator.generate((name) =>
+            forbiddenIdentifiers.contains(name)
+            || allNamedParameterIdentifiers.contains(name));
     rename = makeRenamer(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) {
       // 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>());
       }
       for (int i = 0; i < currentSortedNodes.length; i++) {
         allSortedLocals[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);
-    String localRenamer(LocalRenamable localRenamable) =>
-        generator.generate((name) =>
-            allParameterIdentifiers.contains(name)
-            || forbiddenIdentifiers.contains(name));
+    Function localRenamer = generateUniqueName;

[Anton Muhin, 2013/05/31 08:50:23]

maybe drop this local altogether?

[kasperl, 2013/05/31 08:51:57]

I think I'll keep it for consistency with the other renamers.

     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) {
       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'.
     final usedTopLevelOrMemberIdentifiers = new Set<String>();
     usedTopLevelOrMemberIdentifiers.add('main');
     usedTopLevelOrMemberIdentifiers.addAll(fixedMemberNames);
     generateUniqueName = (originalName) {
       String newName = conservativeGenerator(
-          originalName, usedTopLevelOrMemberIdentifiers.contains);
+          originalName, (name) =>
+              usedTopLevelOrMemberIdentifiers.contains(name)

[Anton Muhin, 2013/05/31 08:50:23]

why this change, only stylistic or am i missing something?

[kasperl, 2013/05/31 08:51:57]

I'm adding the allNamedParameterIdentifiers check below.

+              || allNamedParameterIdentifiers.contains(name));
       usedTopLevelOrMemberIdentifiers.add(newName);
       return newName;
     };
     rename = makeRenamer(generateUniqueName);
     renameElement = makeElementRenamer(rename, generateUniqueName);
     // Rename elements.
     sortedForEach(placeholderCollector.elementNodes,
         (Element element, Set<Node> nodes) {
       renameNodes(nodes, (_) => renameElement(element));
     });
@@ skipping 98 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();
   }
 }