fixes #259, clone ast before mutation

lib/src/info.dart

 // Copyright (c) 2015, 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.
 
 /// Defines static information collected by the type checker and used later by
 /// emitters to generate code.
 library dev_compiler.src.info;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/error.dart';
+import 'package:analyzer/src/generated/parser.dart';
 
 import 'package:dev_compiler/src/checker/rules.dart';
 import 'package:dev_compiler/src/utils.dart' as utils;
 
 /// Represents a summary of the results collected by running the program
 /// checker.
 class CheckerResults {
   final List<LibraryInfo> libraries;
   final TypeRules rules;
   final bool failure;
@@ skipping 24 matching lines @@
 
   Iterable<CompilationUnit> get libraryThenParts sync* {
     yield library;
     yield* parts;
   }
 
   Iterable<CompilationUnit> get partsThenLibrary sync* {
     yield* parts;
     yield library;
   }
+
+  /// Creates a clone of this library's AST.
+  LibraryUnit clone() {
+    return new LibraryUnit(
+        _cloneUnit(library), parts.map(_cloneUnit).toList(growable: false));
+  }
+
+  static CompilationUnit _cloneUnit(CompilationUnit oldNode) {
+    var newNode = oldNode.accept(new _AstCloner());
+    ResolutionCopier.copyResolutionData(oldNode, newNode);
+    return newNode;
+  }
+}
+
+class _AstCloner extends AstCloner {
+  void _cloneProperties(AstNode clone, AstNode node) {
+    if (clone != null) {
+      CoercionInfo.set(clone, CoercionInfo.get(node));
+      DynamicInvoke.set(clone, DynamicInvoke.get(node));
+    }
+  }
+
+  @override
+  AstNode cloneNode(AstNode node) {
+    var clone = super.cloneNode(node);
+    _cloneProperties(clone, node);
+    return clone;
+  }
+
+  @override
+  List cloneNodeList(List list) {
+    var clone = super.cloneNodeList(list);
+    for (int i = 0, len = list.length; i < len; i++) {
+      _cloneProperties(clone[i], list[i]);
+    }
+    return clone;
+  }
 }
 
 // The abstract type of coercions mapping one type to another.
 // This class also exposes static builder functions which
 // check for errors and reduce redundant coercions to the identity.
 abstract class Coercion {
   final DartType fromType;
   final DartType toType;
   Coercion(this.fromType, this.toType);
   static Coercion cast(DartType fromT, DartType toT) => new Cast(fromT, toT);
@@ skipping 468 matching lines @@
 /// Better to have `super` at the end, as required by the Dart style guide:
 /// <http://goo.gl/q1T4BB>
 ///
 /// For now this is the only pattern we support.
 class InvalidSuperInvocation extends StaticError {
   InvalidSuperInvocation(SuperConstructorInvocation node) : super(node);
 
   @override String get message => "super call must be last in an initializer "
       "list (see http://goo.gl/q1T4BB): {0}";
 }