fixes #209, remove tree mutation from CodeChecker

lib/src/codegen/js_codegen.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.js_codegen;
 
 import 'dart:collection' show HashSet, HashMap, SplayTreeSet;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 31 matching lines @@
 // dart_runtime.js file and comments.
 // TODO(jmesserly): ideally we'd have a "dynamic call" dart library we can
 // import and generate calls to, rather than dart_runtime.js
 const DPUT = 'dput';
 const DLOAD = 'dload';
 const DINDEX = 'dindex';
 const DSETINDEX = 'dsetindex';
 const DCALL = 'dcall';
 const DSEND = 'dsend';
 
-class JSCodegenVisitor extends GeneralizingAstVisitor with ConversionVisitor {
+class JSCodegenVisitor extends GeneralizingAstVisitor {
   final AbstractCompiler compiler;
   final CompilerOptions options;
   final TypeRules rules;
   final LibraryInfo libraryInfo;
 
   /// Entry point uri
   final Uri root;
 
   /// The global extension type table.
   final HashSet<ClassElement> _extensionTypes;
@@ skipping 163 matching lines @@
   // TODO(jmesserly): this is a temporary workaround for `Symbol` in core,
   // until we have better name tracking.
   String get _SYMBOL {
     var name = currentLibrary.name;
     if (name == 'dart.core' || name == 'dart._internal') return 'dart.JsSymbol';
     return 'Symbol';
   }
 
   bool isPublic(String name) => !name.startsWith('_');
 
-  /// Conversions that we don't handle end up here.
-  @override
-  visitConversion(Conversion node) {
-    throw 'Unlowered conversion ${node.runtimeType}: $node';
-  }
-
   @override
   visitAsExpression(AsExpression node) {
     var from = getStaticType(node.expression);
     var to = node.type.type;
 
     // All Dart number types map to a JS double.
     if (rules.isNumType(from) &&
         (rules.isIntType(to) || rules.isDoubleType(to))) {
       // TODO(jmesserly): a lot of these checks are meaningless, as people use
       // `num` to mean "any kind of number" rather than "could be null".
@@ skipping 1560 matching lines @@
     // TODO(vsm): Revisit whether we really need this when we get
     // better non-nullability in the type system.
 
     if (expr is Literal && expr is! NullLiteral) return true;
     if (expr is IsExpression) return true;
     if (expr is ThisExpression) return true;
     if (expr is SuperExpression) return true;
     if (expr is ParenthesizedExpression) {
       return _isNonNullableExpression(expr.expression);
     }
-    if (expr is Conversion) {
-      return _isNonNullableExpression(expr.expression);
-    }
     if (expr is SimpleIdentifier) {
       // Type literals are not null.
       Element e = expr.staticElement;
       if (e is ClassElement || e is FunctionTypeAliasElement) return true;
     }
     DartType type = null;
     if (expr is BinaryExpression) {
       switch (expr.operator.type) {
         case TokenType.EQ_EQ:
         case TokenType.BANG_EQ:
@@ skipping 916 matching lines @@
 
 /// A special kind of element created by the compiler, signifying a temporary
 /// variable. These objects use instance equality, and should be shared
 /// everywhere in the tree where they are treated as the same variable.
 class TemporaryVariableElement extends LocalVariableElementImpl {
   TemporaryVariableElement.forNode(Identifier name) : super.forNode(name);
 
   int get hashCode => identityHashCode(this);
   bool operator ==(Object other) => identical(this, other);
 }