dart2dart Preproces placeholders instead of renaming them lazily,

lib/compiler/implementation/dart_backend/placeholder_collector.dart

Index: lib/compiler/implementation/dart_backend/placeholder_collector.dart
diff --git a/lib/compiler/implementation/dart_backend/placeholder_collector.dart b/lib/compiler/implementation/dart_backend/placeholder_collector.dart
index 364a8f56a2bdd922b95476f1cf01a0097155e59a..e3001c844f2d3411e54059169bd4e200454d33b5 100644
--- a/lib/compiler/implementation/dart_backend/placeholder_collector.dart
+++ b/lib/compiler/implementation/dart_backend/placeholder_collector.dart
@@ -72,14 +72,21 @@ class SendVisitor extends ResolvedVisitor {
 
 class PlaceholderCollector extends AbstractVisitor {
   final Compiler compiler;
-  final Map<Node, Placeholder> placeholders;
-  final Map<Element, Map<String, LocalPlaceholder>> localPlaceholders;
+  final Map<Element, Map<Node, LocalPlaceholder>> localPlaceholders;
+  final Map<Node, PrivatePlaceholder> privatePlaceholders;

[Anton Muhin, 2012/08/15 12:19:30]

should those be maps from Nodes to placeholders?  Cannot you keep a list of
nodes associated with a placeholder?

[Roman, 2012/08/15 12:43:21]

I don't understand. How about the following plan?
1) Null and unresolved placeholders have no info. So I can just keep track of
nodes that need to be nullified or nodes that are unresolved, in 2 sets:
Set<Node> unresolvedNodes;
Set<Node> nullNodes;
In renamer I just map nullNodes to '' and generate uniques for unresolved ones.
2) For nodes that correspond to element, I can have a map from element to a set
of nodes the element represents:
Map<Element, Set<Node>> elementNodes;
in Renamer I just call renameElement once and map all nodes in the set for given
element to rename result.
3) For local nodes we need to have LocalPlaceholder to keep track of original
name and all nodes with that name:
Map<FunctionElement, Set<LocalPlaceholder>> localNodes,
in LocalPlaceholder we keep track of all the nodes with given identifier.
4) For private nodes we will have a map from LibraryELement to list of nodes:
Map<LibraryElement, Set<Node>> privateNodes;
Renaming is straightforward.

So I keep only LocalPlaceholder and remove all else. Does that sound good?

+  final Map<Node, UnresolvedPlaceholder> unresolvedPlaceholders;
+  final Map<Node, NullPlaceholder> nullPlaceholders;
+  final Map<Node, ElementPlaceholder> elementPlaceholders;
+  Map<String, LocalPlaceholder> currentLocalPlaceholders;
   Element currentElement;
   TreeElements treeElements;
 
   PlaceholderCollector(this.compiler) :
-      placeholders = new Map<Node, Placeholder>(),
-      localPlaceholders = new Map<Element, Map<String, LocalPlaceholder>>();
+      localPlaceholders = new Map<Element, Map<Node, LocalPlaceholder>>(),
+      privatePlaceholders = new Map<Node, PrivatePlaceholder>(),
+      unresolvedPlaceholders = new Map<Node, UnresolvedPlaceholder>(),
+      nullPlaceholders = new Map<Node, NullPlaceholder>(),
+      elementPlaceholders = new Map<Node, ElementPlaceholder>();
 
   void collectFunctionDeclarationPlaceholders(
       FunctionElement element, FunctionExpression node) {
@@ -180,6 +187,7 @@ class PlaceholderCollector extends AbstractVisitor {
     } else {
       assert(false); // Unreachable.
     }
+    currentLocalPlaceholders = new Map<String, LocalPlaceholder>();
     compiler.withCurrentElement(element, () {
       elementNode.accept(this);
     });
@@ -214,35 +222,31 @@ class PlaceholderCollector extends AbstractVisitor {
   }
 
   void makeNullPlaceholder(Node node) {
-    placeholders[node] = new NullPlaceholder();
+    nullPlaceholders[node] = new NullPlaceholder();
   }
 
   void makeElementPlaceholder(Node node, Element element) {
     assert(element !== null);
-    placeholders[node] = new ElementPlaceholder(element);
+    elementPlaceholders[node] = new ElementPlaceholder(element);
   }
 
   void makePrivateIdentifier(Identifier node) {
     assert(node !== null);
-    placeholders[node] =
+    privatePlaceholders[node] =
         new PrivatePlaceholder(currentElement.getLibrary(), node);
   }
 
   void makeUnresolvedPlaceholder(Node node) {
-    placeholders[node] = const UnresolvedPlaceholder();
+    unresolvedPlaceholders[node] = const UnresolvedPlaceholder();
   }
 
   void makeLocalPlaceholder(Node node) {
     assert(currentElement is FunctionElement);
     assert(node is Identifier);
-    Map<String, LocalPlaceholder> functionLocals =
-        localPlaceholders.putIfAbsent(currentElement,
-            () => <LocalPlaceholder>{});
     String identifier = node.asIdentifier().source.slowToString();
     LocalPlaceholder localPlaceholder =
-        functionLocals.putIfAbsent(identifier,
+        currentLocalPlaceholders.putIfAbsent(identifier,
             () => new LocalPlaceholder(currentElement, identifier));
-    placeholders[node] = localPlaceholder;
   }
 
   void internalError(String reason, [Node node]) {