fixes #209, remove tree mutation from CodeChecker

lib/src/codegen/reify_coercions.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.
 
 library dev_compiler.src.codegen.reify_coercions;
 
 import 'package:analyzer/analyzer.dart' as analyzer;
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:logging/logging.dart' as logger;
@@ skipping 27 matching lines @@
 }
 
 class _Inference extends DownwardsInference {
   TypeManager _tm;
 
   _Inference(TypeRules rules, this._tm) : super(rules);
 
   @override
   void annotateCastFromDynamic(Expression e, DartType t) {
     var cast = Coercion.cast(e.staticType, t);
-    var node = new DynamicCast(rules, e, cast);
-    if (!NodeReplacer.replace(e, node)) {
-      _log.severe("Failed to replace node for DownCast");
-    }
+    var info = new DynamicCast(rules, e, cast);
+    CoercionInfo.set(e, info);
   }
 
   @override
   void annotateListLiteral(ListLiteral e, List<DartType> targs) {
     var tNames = targs.map(_tm.typeNameFromDartType).toList();
     e.typeArguments = AstBuilder.typeArgumentList(tNames);
     var listT = rules.provider.listType.substitute4(targs);
     e.staticType = listT;
   }
 
@@ skipping 21 matching lines @@
 
   @override
   void annotateFunctionExpression(FunctionExpression e, DartType returnType) {
     // Implicitly changes e.staticType
     (e.element as ExecutableElementImpl).returnType = returnType;
   }
 }
 
 // This class implements a pass which modifies (in place) the ast replacing
 // abstract coercion nodes with their dart implementations.
-class CoercionReifier extends analyzer.GeneralizingAstVisitor<Object>
-    with ConversionVisitor<Object> {
+class CoercionReifier extends analyzer.GeneralizingAstVisitor<Object> {
   final CoercionManager _cm;
   final TypeManager _tm;
   final VariableManager _vm;
   final LibraryUnit _library;
   final _Inference _inferrer;
 
   CoercionReifier._(
       this._cm, this._tm, this._vm, this._library, this._inferrer);
 
   factory CoercionReifier(LibraryUnit library, AbstractCompiler compiler) {
@@ skipping 10 matching lines @@
   // Returns the set of new type identifiers added by the reifier
   Map<Identifier, NewTypeIdDesc> reify() {
     _library.partsThenLibrary.forEach(generateUnit);
     return _tm.addedTypes;
   }
 
   void generateUnit(CompilationUnit unit) {
     visitCompilationUnit(unit);
   }
 
+  @override
+  Object visitExpression(Expression node) {
+    var info = CoercionInfo.get(node);
+    if (info is InferredTypeBase) {
+      return _visitInferredTypeBase(info);
+    } else if (info is DownCast) {
+      return _visitDownCast(info);
+    }
+    return super.visitExpression(node);
+  }
+
   ///////////////// Private //////////////////////////////////
 
-  @override
-  Object visitInferredTypeBase(InferredTypeBase node) {
+  Object _visitInferredTypeBase(InferredTypeBase node) {
     var expr = node.node;
-    var b = _inferrer.inferExpression(expr, node.type, <String>[]);
-    assert(b);
-    if (!NodeReplacer.replace(node, expr)) {
-      _log.severe("Failed to replace node for InferredType");
-    }
-    expr.accept(this);
+    var success = _inferrer.inferExpression(expr, node.type, <String>[]);
+    assert(success);
+    expr.visitChildren(this);
     return null;
   }
 
-  @override
-  Object visitDownCast(DownCast node) {
-    Expression castNode = _cm.coerceExpression(node.node, node.cast);
-    if (!NodeReplacer.replace(node, castNode)) {
-      _log.severe("Failed to replace node for DownCast");
+  Object _visitDownCast(DownCast node) {
+    var expr = node.node;
+    var parent = expr.parent;
+    expr.visitChildren(this);
+    Expression newE = _cm.coerceExpression(expr, node.cast);
+    if (!identical(expr, newE)) {
+      var replaced = parent.accept(new NodeReplacer(expr, newE));
+      // It looks like NodeReplacer will always return true.
+      // It does throw IllegalArgumentException though, if child is not found.
+      assert(replaced);
     }
-    castNode.accept(this);
     return null;
   }
 
   Object visitCompilationUnit(CompilationUnit unit) {
     _cm.enterCompilationUnit(unit);
     Object ret = super.visitCompilationUnit(unit);
     _cm.exitCompilationUnit(unit);
     return ret;
   }
 }
@@ skipping 334 matching lines @@
     var t = _mkNewTypeName(dType, id, args);
     return t;
   }
 
   TypeName _mkNewTypeName(DartType type, Identifier id, List<TypeName> args) {
     var t = AstBuilder.typeName(id, args);
     t.type = type;
     return t;
   }
 }