Introduce AST cloning.

lib/compiler/implementation/dart_backend/utils.dart

Index: lib/compiler/implementation/dart_backend/utils.dart
diff --git a/lib/compiler/implementation/dart_backend/utils.dart b/lib/compiler/implementation/dart_backend/utils.dart
new file mode 100644
index 0000000000000000000000000000000000000000..86e048ee06a9132ebabd58b48ab311b13c493e59
--- /dev/null
+++ b/lib/compiler/implementation/dart_backend/utils.dart
@@ -0,0 +1,205 @@
+// 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 CloningVisitor implements Visitor<Node> {
+  final TreeElements originalTreeElements;
+  final TreeElements cloneTreeElements;
+
+  CloningVisitor(this.originalTreeElements)

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

I suggest removing TreeElements cloning from this visitor to another place. This
would make CloningVisitor more simple from client perspective.

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

I might be missing some simple solution, but I found no easier way to recreate
this mapping after the cloning.  Do you have any particular ideas in mind?

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

[Roman, 2012/09/07 13:19:59]

Nothing particular.

+      : cloneTreeElements = new TreeElementMapping();
+
+  visit(Node node) {
+    if (node === null) return null;
+    final clone = node.accept(this);
+    final originalElement = originalTreeElements[node];
+    if (originalElement !== null) {
+      cloneTreeElements[clone] = originalElement;
+    }
+    TypeAnnotation asTypeAnnotation = node.asTypeAnnotation();
+    if (asTypeAnnotation !== null) {
+      final originalType = originalTreeElements.getType(asTypeAnnotation);
+      if (originalType !== null) {
+        cloneTreeElements.setType(clone.asTypeAnnotation(), originalType);
+      }
+    }
+    return clone;
+  }
+
+  visitBlock(Block node) => new Block(visit(node.statements));
+
+  visitBreakStatement(BreakStatement node) => new BreakStatement(
+      visit(node.target), node.keywordToken, node.semicolonToken);
+
+  visitCascade(Cascade node) => new Cascade(visit(node.expression));
+
+  visitCascadeReceiver(CascadeReceiver node) => new CascadeReceiver(
+      visit(node.expression), node.cascadeOperator);
+
+  visitCaseMatch(CaseMatch node) => new CaseMatch(
+      node.caseKeyword, visit(node.expression), node.colonToken);
+
+  visitCatchBlock(CatchBlock node) => new CatchBlock(
+      visit(node.type), visit(node.formals), visit(node.block),
+      node.onKeyword, node.catchKeyword);
+
+  visitClassNode(ClassNode node) => new ClassNode(
+      visit(node.name), visit(node.typeParameters),
+      visit(node.superclass), visit(node.interfaces), visit(node.defaultClause),
+      node.beginToken, node.extendsKeyword, visit(node.body), node.endToken);
+
+  visitConditional(Conditional node) => new Conditional(
+      visit(node.condition), visit(node.thenExpression),
+      visit(node.elseExpression), node.questionToken, node.colonToken);
+
+  visitContinueStatement(ContinueStatement node) => new ContinueStatement(
+      visit(node.target), node.keywordToken, node.semicolonToken);
+
+  visitDoWhile(DoWhile node) => new DoWhile(
+      visit(node.body), visit(node.condition),
+      node.doKeyword, node.whileKeyword, node.endToken);
+
+  visitEmptyStatement(EmptyStatement node) => new EmptyStatement(
+      node.semicolonToken);
+
+  visitExpressionStatement(ExpressionStatement node) => new ExpressionStatement(
+      visit(node.expression), node.endToken);
+
+  visitFor(For node) => new For(
+      visit(node.initializer), visit(node.conditionStatement),
+      visit(node.update), visit(node.body), node.forToken);
+
+  visitForIn(ForIn node) => new ForIn(
+      visit(node.declaredIdentifier), visit(node.expression), visit(node.body),
+      node.forToken, node.inToken);
+
+  visitFunctionDeclaration(FunctionDeclaration node) => new FunctionDeclaration(
+      visit(node.function));
+
+  visitFunctionExpression(FunctionExpression node) => new FunctionExpression(
+      visit(node.name), visit(node.parameters),
+      visit(node.body),
+      visit(node.returnType), visit(node.modifiers), visit(node.initializers),
+      node.getOrSet);
+
+  visitIdentifier(Identifier node) => new Identifier(node.token);
+
+  visitIf(If node) => new If(
+      visit(node.condition), visit(node.thenPart), visit(node.elsePart),
+      node.ifToken, node.elseToken);
+
+  visitLabel(Label node) => new Label(visit(node.identifier), node.colonToken);
+
+  visitLabeledStatement(LabeledStatement node) => new LabeledStatement(
+      visit(node.labels), visit(node.statement));
+
+  visitLiteralBool(LiteralBool node) => new LiteralBool(
+      node.token, node.handler);
+
+  visitLiteralDouble(LiteralDouble node) => new LiteralDouble(
+      node.token, node.handler);
+
+  visitLiteralInt(LiteralInt node) => new LiteralInt(node.token, node.handler);
+
+  visitLiteralList(LiteralList node) => new LiteralList(
+      visit(node.typeArguments), visit(node.elements), node.constKeyword);
+
+  visitLiteralMap(LiteralMap node) => new LiteralMap(
+      visit(node.typeArguments), visit(node.entries), node.constKeyword);
+
+  visitLiteralMapEntry(LiteralMapEntry node) => new LiteralMapEntry(
+      visit(node.key), node.colonToken, visit(node.value));
+
+  visitLiteralNull(LiteralNull node) => new LiteralNull(node.token);
+
+  visitLiteralString(LiteralString node) => new LiteralString(
+      node.token, node.dartString);
+
+  visitModifiers(Modifiers node) => new Modifiers(visit(node.nodes));
+
+  visitNamedArgument(NamedArgument node) => new NamedArgument(
+      visit(node.name), node.colonToken, visit(node.expression));
+
+  visitNewExpression(NewExpression node) => new NewExpression(
+      node.newToken, visit(node.send));
+
+  visitNodeList(NodeList node) {
+    // Special case for classes which exist in hierarchy, but not
+    // in the visitor.
+    if (node is Prefix) {
+      return node.nodes.isEmpty() ?
+          new Prefix() : new Prefix.singleton(visit(node.nodes.head));
+    }
+    if (node is Postfix) {
+      return node.nodes.isEmpty() ?
+          new Postfix() : new Postfix.singleton(visit(node.nodes.head));
+    }
+    LinkBuilder<Node> builder = new LinkBuilder<Node>();
+    for (Node n in node.nodes) {
+      builder.addLast(visit(n));
+    }
+    return new NodeList(
+      node.beginToken, builder.toLink(), node.endToken, node.delimiter);
+  }
+
+  visitOperator(Operator node) => new Operator(node.token);
+
+  visitParenthesizedExpression(ParenthesizedExpression node) =>
+      new ParenthesizedExpression(visit(node.expression), node.beginToken);
+
+  visitReturn(Return node) => new Return(
+      node.beginToken, node.endToken, visit(node.expression));
+
+  visitScriptTag(ScriptTag node) => new ScriptTag(
+      visit(node.tag), visit(node.argument),
+      visit(node.prefixIdentifier), visit(node.prefix),
+      node.beginToken, node.endToken);
+
+  visitSend(Send node) => new Send(
+      visit(node.receiver), visit(node.selector), visit(node.argumentsNode));
+
+  visitSendSet(SendSet node) => new SendSet(
+      visit(node.receiver), visit(node.selector),
+      visit(node.assignmentOperator), visit(node.argumentsNode));
+
+  visitStringInterpolation(StringInterpolation node) =>
+      new StringInterpolation(visit(node.string), visit(node.parts));
+
+  visitStringInterpolationPart(StringInterpolationPart node) =>
+      new StringInterpolationPart(visit(node.expression), visit(node.string));
+
+  visitStringJuxtaposition(StringJuxtaposition node) =>
+      new StringJuxtaposition(visit(node.first), visit(node.second));
+
+  visitSwitchCase(SwitchCase node) => new SwitchCase(
+      visit(node.labelsAndCases), node.defaultKeyword, visit(node.statements),
+      node.startToken);
+
+  visitSwitchStatement(SwitchStatement node) => new SwitchStatement(
+      visit(node.parenthesizedExpression), visit(node.cases),
+      node.switchKeyword);
+
+  visitThrow(Throw node) => new Throw(
+      visit(node.expression), node.throwToken, node.endToken);
+
+  visitTryStatement(TryStatement node) => new TryStatement(
+      visit(node.tryBlock), visit(node.catchBlocks), visit(node.finallyBlock),
+      node.tryKeyword, node.finallyKeyword);
+
+  visitTypeAnnotation(TypeAnnotation node) => new TypeAnnotation(
+      visit(node.typeName), visit(node.typeArguments));
+
+  visitTypedef(Typedef node) => new Typedef(
+      visit(node.returnType), visit(node.name), visit(node.typeParameters),
+      visit(node.formals), node.typedefKeyword, node.endToken);
+
+  visitTypeVariable(TypeVariable node) => new TypeVariable(
+      visit(node.name), visit(node.bound));
+
+  visitVariableDefinitions(VariableDefinitions node) => new VariableDefinitions(
+      visit(node.type), visit(node.modifiers), visit(node.definitions),
+      node.endToken);
+
+  visitWhile(While node) => new While(
+      visit(node.condition), visit(node.body), node.whileKeyword);
+}