Inference casts to dynamic, fuzzy types handled

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 21 matching lines @@
   final Wrapper wrapper;
   _LocatedWrapper(this.wrapper, this.loc);
 }
 
 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");
+    }
+  }
+
+  @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 rawType = (e.staticType.element as ClassElement).type;
     e.staticType = rawType.substitute4(targs);
   }
+
+  @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 UnitCoercionReifier extends analyzer.GeneralizingAstVisitor<Object>
     with ConversionVisitor<Object> {
   CoercionManager _cm;
   final TypeManager _tm;
   final VariableManager _vm;
   SourceFile _file;
@@ skipping 628 matching lines @@
   Expression _typeExpression(TypeName t) {
     if (t.typeArguments != null && t.typeArguments.length > 0) {
       var w = AstBuilder.identifierFromString("_");
       var fp = AstBuilder.simpleFormal(w, t);
       var f = AstBuilder.blockFunction(<FormalParameter>[fp], <Statement>[]);
       return new RuntimeOperation("type", <Expression>[f]);
     }
     return t.name;
   }
 }