Update to latest analyzer

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:analyzer/src/task/strong/rules.dart';
+import 'package:analyzer/src/generated/type_system.dart'
+    show StrongTypeSystemImpl;
 import 'package:logging/logging.dart' as logger;
 
 import '../info.dart';
 
 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> {
@@ skipping 10 matching lines @@
   LibraryElement importedFrom;
 
   /// True => use/def in same library
   bool fromCurrent;
 
   /// True => not a source variable
   bool synthetic;
   NewTypeIdDesc({this.fromCurrent, this.importedFrom, this.synthetic});
 }
 
-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 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;
-  }
-
-  @override
-  void annotateMapLiteral(MapLiteral e, List<DartType> targs) {
-    var tNames = targs.map(_tm.typeNameFromDartType).toList();
-    e.typeArguments = AstBuilder.typeArgumentList(tNames);
-    var mapT = rules.provider.mapType.substitute4(targs);
-    e.staticType = mapT;
-  }
-
-  @override
-  void annotateInstanceCreationExpression(
-      InstanceCreationExpression e, List<DartType> targs) {
-    var tNames = targs.map(_tm.typeNameFromDartType).toList();
-    var cName = e.constructorName;
-    var id = cName.type.name;
-    var typeName = AstBuilder.typeName(id, tNames);
-    cName.type = typeName;
-    var newType =
-        (e.staticType.element as ClassElement).type.substitute4(targs);
-    e.staticType = newType;
-    typeName.type = newType;
-  }
-
-  @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> {
   final CoercionManager _cm;
   final TypeManager _tm;
   final VariableManager _vm;
   final LibraryUnit _library;
-  final _Inference _inferrer;
+  final StrongTypeSystemImpl _typeSystem;
 
   CoercionReifier._(
-      this._cm, this._tm, this._vm, this._library, this._inferrer);
+      this._cm, this._tm, this._vm, this._library, this._typeSystem);
 
-  factory CoercionReifier(LibraryUnit library, TypeRules rules) {
+  factory CoercionReifier(
+      LibraryUnit library, StrongTypeSystemImpl typeSystem) {
     var vm = new VariableManager();
     var tm = new TypeManager(library.library.element.enclosingElement, vm);
     var cm = new CoercionManager(vm, tm);
-    var inferrer = new _Inference(rules, tm);
-    return new CoercionReifier._(cm, tm, vm, library, inferrer);
+    return new CoercionReifier._(cm, tm, vm, library, typeSystem);
   }
 
   // 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(visitCompilationUnit);
     return _tm.addedTypes;
   }
 
   @override
   Object visitExpression(Expression node) {
     var info = CoercionInfo.get(node);
     if (info is InferredTypeBase) {
       return _visitInferredTypeBase(info, node);
     } else if (info is DownCast) {
       return _visitDownCast(info, node);
     }
     return super.visitExpression(node);
   }
 
   ///////////////// Private //////////////////////////////////
 
   Object _visitInferredTypeBase(InferredTypeBase node, Expression expr) {
-    var success = _inferrer.inferExpression(expr, node.type, <String>[]);
-    assert(success);
+    DartType t = node.type;
+    if (!_typeSystem.isSubtypeOf(_getStaticType(expr), t)) {
+      if (_getStaticType(expr).isDynamic) {
+        var cast = Coercion.cast(expr.staticType, t);
+        var info = new DynamicCast(_typeSystem, expr, cast);
+        CoercionInfo.set(expr, info);
+      }
+    }
     expr.visitChildren(this);
     return null;
   }
 
   Object _visitDownCast(DownCast node, Expression expr) {
     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);
     }
     return null;
   }
 
   Object visitCompilationUnit(CompilationUnit unit) {
     _cm.enterCompilationUnit(unit);
     Object ret = super.visitCompilationUnit(unit);
     _cm.exitCompilationUnit(unit);
     return ret;
   }
+
+  DartType _getStaticType(Expression expr) {
+    return expr.staticType ?? DynamicTypeImpl.instance;
+  }
 }
 
 // This provides a placeholder variable manager.  Currently it simply
 // mangles names in a way unlikely (but not guaranteed) to avoid
 // collisions with user variables.
 // TODO(leafp): Replace this with something real.
 class VariableManager {
   // TODO(leafp): Hack, not for real.
   int _id = 0;
 
@@ skipping 325 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;
   }
 }