dart2dart Preproces placeholders instead of renaming them lazily,

lib/compiler/implementation/dart_backend/placeholder_collector.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.
 
 class SendVisitor extends ResolvedVisitor {
   final PlaceholderCollector collector;
 
   SendVisitor(this.collector, TreeElements elements) : super(elements);
 
   visitSuperSend(Send node) {}
@@ skipping 54 matching lines @@
     }
   }
 
   tryRenamePrivateSelector(Send node) {
     collector.tryMakePrivateIdentifier(node.selector.asIdentifier());
   }
 }
 
 class PlaceholderCollector extends AbstractVisitor {
   final Compiler compiler;
-  final Map<Node, Placeholder> placeholders;
-  final Map<Element, Map<String, LocalPlaceholder>> localPlaceholders;
+  final Set<Node> nullNodes;  // Nodes that should not be in output.
+  final Set<Identifier> unresolvedNodes;
+  final Map<Element, Set<Node>> elementNodes;
+  final Map<FunctionElement, Set<LocalPlaceholder>> localPlaceholders;
+  final Map<LibraryElement, Set<Node>> privateNodes;
+  Map<String, LocalPlaceholder> currentLocalPlaceholders;
   Element currentElement;
   TreeElements treeElements;
 
   PlaceholderCollector(this.compiler) :
-      placeholders = new Map<Node, Placeholder>(),
-      localPlaceholders = new Map<Element, Map<String, LocalPlaceholder>>();
+      nullNodes = new Set<Node>(),
+      unresolvedNodes = new Set<Identifier>(),
+      elementNodes = new Map<Element, Set<Node>>(),
+      localPlaceholders = new Map<FunctionElement, Set<LocalPlaceholder>>(),
+      privateNodes = new Map<LibraryElement, Set<Node>>();
 
   void collectFunctionDeclarationPlaceholders(
       FunctionElement element, FunctionExpression node) {
     if (element.isGenerativeConstructor() || element.isFactoryConstructor()) {
       // Two complicated cases for class/interface renaming:
       // 1) class which implements constructors of other interfaces, but not
       //    implements interfaces themselves:
       //      0.dart: class C { I(); }
       //      1.dart and 2.dart: interface I default C { I(); }
       //    now we have to duplicate our I() constructor in C class with
@@ skipping 80 matching lines @@
       // variable list element twice, better merge this with emitter logic.
       currentElement = (element as VariableElement).variables;
       elementNode = currentElement.parseNode(compiler);
       collectFieldDeclarationPlaceholders(element, elementNode);
     } else if (element is ClassElement || element is TypedefElement) {
       currentElement = element;
       elementNode = currentElement.parseNode(compiler);
     } else {
       assert(false); // Unreachable.
     }
+    currentLocalPlaceholders = new Map<String, LocalPlaceholder>();
     compiler.withCurrentElement(element, () {
       elementNode.accept(this);
     });
   }
 
   Type resolveType(TypeAnnotation typeAnnotation) {
     if (treeElements === null) return null;
     var result = treeElements.getType(typeAnnotation);
     // TODO: Have better type resolution.
     if (result === null) {
@@ skipping 14 matching lines @@
         || (element.isFunction() && !Elements.isStaticOrTopLevel(element))) {
       makeLocalPlaceholder(node);
     }
   }
 
   void makeTypePlaceholder(Node node, Type type) {
     makeElementPlaceholder(node, type.element);
   }
 
   void makeNullPlaceholder(Node node) {
-    placeholders[node] = new NullPlaceholder();
+    assert(node is Identifier || node is Send);
+    nullNodes.add(node);
   }
 
   void makeElementPlaceholder(Node node, Element element) {
     assert(element !== null);
-    placeholders[node] = new ElementPlaceholder(element);
+    elementNodes.putIfAbsent(element, () => new Set<Node>()).add(node);
   }
 
   void makePrivateIdentifier(Identifier node) {
     assert(node !== null);
-    placeholders[node] =
-        new PrivatePlaceholder(currentElement.getLibrary(), node);
+    privateNodes.putIfAbsent(
+        currentElement.getLibrary(), () => new Set<Node>()).add(node);
   }
 
   void makeUnresolvedPlaceholder(Node node) {
-    placeholders[node] = const UnresolvedPlaceholder();
+    unresolvedNodes.add(node);
   }
 
   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,
-            () => new LocalPlaceholder(currentElement, identifier));
-    placeholders[node] = localPlaceholder;
+        currentLocalPlaceholders.putIfAbsent(identifier,
+            () {
+              LocalPlaceholder localPlaceholder =
+                  new LocalPlaceholder(identifier);
+              localPlaceholders.putIfAbsent(currentElement,
+                  () => new Set<LocalPlaceholder>()).add(localPlaceholder);
+              return localPlaceholder;
+            });
   }
 
   void internalError(String reason, [Node node]) {
     compiler.cancel(reason: reason, node: node);
   }
 
   visit(Node node) => (node === null) ? null : node.accept(this);
 
   visitNode(Node node) { node.visitChildren(this); }  // We must go deeper.
 
@@ skipping 114 matching lines @@
       if (element is FunctionElement && element !== currentElement) {
         if (node.name !== null) {
           assert(node.name is Identifier);
           tryMakeLocalPlaceholder(element, node.name);
         }
       }
     }
     node.visitChildren(this);
   }
 }