Introduce AST cloning.

tests/compiler/dart2js/unparser_test.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.
 
 #import('dart:uri');
 #import('parser_helper.dart');
 #import('mock_compiler.dart');
 #import("../../../lib/compiler/compiler.dart");
 #import("../../../lib/compiler/implementation/leg.dart", prefix:'leg');
 #import("../../../lib/compiler/implementation/dart_backend/dart_backend.dart");
@@ skipping 456 matching lines @@
     'set p_topgetset(arg){}'
     'main(){p_topgetset;p_topgetset=6;topgetset;topgetset=5;}';
   testDart2DartWithLibrary(mainSrc, librarySrc,
       (String result) { Expect.equals(expectedResult, result); });
 }
 
 testFieldTypeOutput() {
   testDart2Dart('main(){new A().field;}class B{}class A{B field;}');
 }
 
+class DynoMap implements Map<Element, ElementAst> {

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

I don't understand "DynoMap" name, what does it mean?

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

Name is horrible, sorry.  I meant that there is no real data, but they are
rather synthesized on the fly.  Any better ideas?  Something like ParsingMap? 
Sounds horrible too.

Another option would be to forget about map altogether and pass a function to
convert an element into element ast, but you usually are so fond of OOP :)

+  final compiler;
+  DynoMap(this.compiler);
+
+  get resolvedElements => compiler.enqueuer.resolution.resolvedElements;
+  ElementAst operator[](Element element) =>
+      new ElementAst(element.parseNode(compiler), resolvedElements[element]);
+}
+
+PlaceholderCollector collectPlaceholders(compiler, element) =>
+  new PlaceholderCollector(compiler, new Set<String>(), new DynoMap(compiler))
+      ..collect(element);
+
 testLocalFunctionPlaceholder() {
   var src = '''
 main() {
   function localfoo() {}
   localfoo();
 }
 ''';
   MockCompiler compiler = new MockCompiler();
   compiler.parseScript(src);
   FunctionElement mainElement = compiler.mainApp.find(leg.Compiler.MAIN);
   compiler.processQueue(compiler.enqueuer.resolution, mainElement);
-  PlaceholderCollector collector =
-      new PlaceholderCollector(compiler, new Set<String>());
-  collector.collect(mainElement,
-      compiler.enqueuer.resolution.resolvedElements[mainElement]);
+  PlaceholderCollector collector = collectPlaceholders(compiler, mainElement);
   FunctionExpression mainNode = mainElement.parseNode(compiler);
   FunctionExpression fooNode = mainNode.body.statements.nodes.head.function;
   LocalPlaceholder fooPlaceholder =
       collector.functionScopes[mainElement].localPlaceholders.iterator().next();
   Expect.isTrue(fooPlaceholder.nodes.contains(fooNode.name));
 }
 
 testDefaultClassNamePlaceholder() {
   var src = '''
 interface I default C{
   I();
 }
 
 class C {
   I() {}
 }
 
 main() {
   new I();
 }
 ''';
   MockCompiler compiler = new MockCompiler();
   compiler.parseScript(src);
   ClassElement interfaceElement = compiler.mainApp.find(buildSourceString('I'));
   interfaceElement.ensureResolved(compiler);
   PlaceholderCollector collector =
-      new PlaceholderCollector(compiler, new Set<String>());
-  collector.collect(interfaceElement,
-      compiler.enqueuer.resolution.resolvedElements[interfaceElement]);
+      collectPlaceholders(compiler, interfaceElement);
   ClassNode interfaceNode = interfaceElement.parseNode(compiler);
   Node defaultTypeNode = interfaceNode.defaultClause.typeName;
   ClassElement classElement = compiler.mainApp.find(buildSourceString('C'));
   // Check that 'C' in default clause of I gets into placeholders.
   Expect.isTrue(collector.elementNodes[classElement].contains(defaultTypeNode));
 }
 
 testFactoryRename() {
   var librarySrc = '''
 #library('mylib');
@@ skipping 319 matching lines @@
   testDoubleMains();
   testInterfaceDefaultAnotherLib();
   testStaticAccessIoLib();
   testLocalFunctionPlaceholder();
   testMinification();
   testClosureLocalsMinified();
   testParametersMinified();
   testTypeVariablesInDifferentLibraries();
   testDeclarationTypePlaceholders();
 }