Introduce AST cloning.

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 LocalPlaceholder implements Hashable {
   final String identifier;
   final Set<Node> nodes;
   LocalPlaceholder(this.identifier) : nodes = new Set<Node>();
   int hashCode() => identifier.hashCode();
   String toString() =>
@@ skipping 115 matching lines @@
   }
 
   internalError(String reason, [Node node]) {
     collector.internalError(reason, node);
   }
 }
 
 class PlaceholderCollector extends AbstractVisitor {
   final Compiler compiler;
   final Set<String> fixedMemberNames; // member names which cannot be renamed.
+  final Map<Element, ElementAst> elementAsts;
   final Set<Node> nullNodes;  // Nodes that should not be in output.
   final Set<Identifier> unresolvedNodes;
   final Map<Element, Set<Node>> elementNodes;
   final Map<FunctionElement, FunctionScope> functionScopes;
   final Map<LibraryElement, Set<Identifier>> privateNodes;
   final List<DeclarationTypePlaceholder> declarationTypePlaceholders;
   final Map<String, Set<Identifier>> memberPlaceholders;
   Map<String, LocalPlaceholder> currentLocalPlaceholders;
   Element currentElement;
   TreeElements treeElements;
 
   LibraryElement get coreLibrary => compiler.coreLibrary;
   FunctionElement get entryFunction => compiler.mainApp.find(Compiler.MAIN);
 
-  PlaceholderCollector(this.compiler, this.fixedMemberNames) :
+  PlaceholderCollector(this.compiler, this.fixedMemberNames, this.elementAsts) :
       nullNodes = new Set<Node>(),
       unresolvedNodes = new Set<Identifier>(),
       elementNodes = new Map<Element, Set<Node>>(),
       functionScopes = new Map<FunctionElement, FunctionScope>(),
       privateNodes = new Map<LibraryElement, Set<Identifier>>(),
       declarationTypePlaceholders = new List<DeclarationTypePlaceholder>(),
       memberPlaceholders = new Map<String, Set<Identifier>>();
 
   void tryMakeConstructorNamePlaceholder(
       FunctionExpression constructor, ClassElement element) {
@@ skipping 29 matching lines @@
       // 2 cases:
       // Plain interface name. Rename it unless it is the default
       // constructor for enclosing class.
       // Example:
       // interface I { I(); }
       // class C implements I { C(); }  don't rename this case.
       // OR I.named() inside C, rename first part.
       if (element.defaultImplementation !== null
           && element.defaultImplementation !== element) {
         FunctionElement implementingFactory = element.defaultImplementation;
-        tryMakeConstructorNamePlaceholder(implementingFactory.cachedNode,
-            element.getEnclosingClass());
+        if (implementingFactory is !SynthesizedConstructorElement) {

[Roman, 2012/09/07 08:10:56]

Why this check? If it fixes something, please add a test (or better fix it in a
separate CL). I also remember there was a CL that changed something in
shouldOutput about SynthesizedConstructorElement, is it related?

[Anton Muhin, 2012/09/07 12:26:07]

This is somewhat related as we started to drop synthesize constructors earlier.

On the other hand, there is no need to create a placeholder for them anyway as
they won't get output.

If you like I can fix it differently by building AST even for synthesize ctors
and move discarding them back to emitter, but I am not sure it's really better.

On 2012/09/07 08:10:56, Roman wrote:

+          tryMakeConstructorNamePlaceholder(
+              elementAsts[implementingFactory].ast,
+              element.getEnclosingClass());
+        }
       }
     } else if (Elements.isStaticOrTopLevel(element)) {
       // Note: this code should only rename private identifiers for class'
       // fields/getters/setters/methods.  Top-level identifiers are renamed
       // just to escape conflicts and that should be enough as we shouldn't
       // be able to resolve private identifiers for other libraries.
       makeElementPlaceholder(node.name, element);
     } else if (element.isMember()) {
       if (node.name is Identifier) {
         tryMakeMemberPlaceholder(node.name);
       } else {
         assert(node.name.asSend().isOperator);
       }
     }
   }
 
   void collectFieldDeclarationPlaceholders(Element element, Node node) {
     Identifier name = node is Identifier ? node : node.asSend().selector;
     if (Elements.isStaticOrTopLevel(element)) {
       makeElementPlaceholder(name, element);
     } else if (Elements.isInstanceField(element)) {
       tryMakeMemberPlaceholder(name);
     }
   }
 
-  void collect(Element element, TreeElements elements) {
-    treeElements = elements;
-    currentElement = element;
-    Node elementNode = currentElement.parseNode(compiler);
+  void collect(Element element) {
+    this.currentElement = element;
+    final ElementAst elementAst = elementAsts[element];
+    this.treeElements = elementAst.treeElements;
+    Node elementNode = elementAst.ast;
     if (element is FunctionElement) {
       collectFunctionDeclarationPlaceholders(element, elementNode);
     } else if (element is VariableListElement) {
       VariableDefinitions definitions = elementNode;
       for (Node definition in definitions.definitions) {
-        final definitionElement = elements[definition];
+        final definitionElement = treeElements[definition];
         // definitionElement === null if variable is actually unused.
         if (definitionElement === null) continue;
         collectFieldDeclarationPlaceholders(definitionElement, definition);
       }
       makeVarDeclarationTypePlaceholder(definitions);
     } else {
       assert(element is ClassElement || element is TypedefElement);
     }
     currentLocalPlaceholders = new Map<String, LocalPlaceholder>();
     compiler.withCurrentElement(element, () {
@@ skipping 316 matching lines @@
 
   visitBlock(Block node) {
     for (Node statement in node.statements.nodes) {
       if (statement is VariableDefinitions) {
         makeVarDeclarationTypePlaceholder(statement);
       }
     }
     node.visitChildren(this);
   }
 }