remove unused allowConstCast option

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;
 
 import 'package:dev_compiler/devc.dart' show AbstractCompiler;
 import 'package:dev_compiler/src/checker/rules.dart';
 import 'package:dev_compiler/src/info.dart';
-import 'package:dev_compiler/src/options.dart' show CompilerOptions;
 
 import 'ast_builder.dart';
 
 final _log = new logger.Logger('dev_compiler.reify_coercions');
 
 // TODO(leafp) Factor this out or use an existing library
 class Tuple2<T0, T1> {
   final T0 e0;
   final T1 e1;
   Tuple2(this.e0, this.e1);
@@ skipping 64 matching lines @@
 }
 
 // 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> {
   final CoercionManager _cm;
   final TypeManager _tm;
   final VariableManager _vm;
   final LibraryUnit _library;
-  bool _skipCoercions = false;
   final _Inference _inferrer;
-  final CompilerOptions _options;
 
-  CoercionReifier._(this._cm, this._tm, this._vm, this._library, this._inferrer,
-      this._options);
+  CoercionReifier._(
+      this._cm, this._tm, this._vm, this._library, this._inferrer);
 
   factory CoercionReifier(LibraryUnit library, AbstractCompiler compiler) {
     var vm = new VariableManager();
     var tm = new TypeManager(library.library.element.enclosingElement, vm);
     var cm = new CoercionManager(vm, tm);
     var inferrer = new _Inference(compiler.rules, tm);
-    var options = compiler.options;
-    return new CoercionReifier._(cm, tm, vm, library, inferrer, options);
+    return new CoercionReifier._(cm, tm, vm, library, inferrer);
   }
 
   // This should be the entry point for this class.  Entering via the
   // visit functions directly may not do the right thing with respect
   // to discharging the collected definitions.
   // Returns the set of new type identifiers added by the reifier
   Map<Identifier, NewTypeIdDesc> reify() {
     _library.partsThenLibrary.forEach(generateUnit);
     return _tm.addedTypes;
   }
@@ skipping 11 matching lines @@
     assert(b);
     if (!NodeReplacer.replace(node, expr)) {
       _log.severe("Failed to replace node for InferredType");
     }
     expr.accept(this);
     return null;
   }
 
   @override
   Object visitDownCast(DownCast node) {
-    if (_skipCoercions && !_options.allowConstCasts) {
-      _log.severe("Skipping runtime downcast in constant context");
-      return null;
-    }
     Expression castNode = _cm.coerceExpression(node.node, node.cast);
     if (!NodeReplacer.replace(node, castNode)) {
       _log.severe("Failed to replace node for DownCast");
     }
     castNode.accept(this);
     return null;
   }
 
   // TODO(leafp): Bind the coercions at the top level
   @override
   Object visitClosureWrapBase(ClosureWrapBase node) {
-    if (_skipCoercions && !_options.allowConstCasts) {
-      _log.severe("Skipping coercion wrap in constant context");
-      return null;
-    }
     Expression newE = _cm.coerceExpression(node.node, node.wrapper);
     if (!NodeReplacer.replace(node, newE)) {
       _log.severe("Failed to replace node for Closure Wrap");
     }
     newE.accept(this);
     return null;
   }
 
-  @override
-  Object visitNode(AstNode n) {
-    var o = _skipCoercions;
-    if (!o) {
-      if (n is VariableDeclarationList) {
-        _skipCoercions = o || n.isConst;
-      } else if (n is VariableDeclaration) {
-        _skipCoercions = o || n.isConst;
-      } else if (n is FormalParameter) {
-        _skipCoercions = o || n.isConst;
-      } else if (n is InstanceCreationExpression) {
-        _skipCoercions = o || n.isConst;
-      } else if (n is ConstructorDeclaration) {
-        _skipCoercions = o || n.element.isConst;
-      }
-    }
-    Object ret = super.visitNode(n);
-    _skipCoercions = o;
-    return ret;
-  }
-
   Object visitCompilationUnit(CompilationUnit unit) {
     _cm.enterCompilationUnit(unit);
     Object ret = super.visitCompilationUnit(unit);
     _cm.exitCompilationUnit(unit);
     return ret;
   }
 
   @override
   Object visitClassDeclaration(ClassDeclaration cl) {
     _cm.enterClass();
@@ skipping 511 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;
   }
 }