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 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) {
     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();
+    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]) {
     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);
   }
 }