Rationalize coercions

lib/src/checker/rules.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.checker.rules;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 
@@ skipping 375 matching lines @@
     final r1s = fromT.normalParameterTypes;
     final o1s = fromT.optionalParameterTypes;
     final n1s = fromT.namedParameterTypes;
     final ret1 = fromT.returnType;
 
     final r2s = toT.normalParameterTypes;
     final o2s = toT.optionalParameterTypes;
     final n2s = toT.namedParameterTypes;
     final ret2 = toT.returnType;
 
-    Coercion ret = _coerceTo(ret1, ret2, true);
+    Coercion ret = _coerceTo(ret1, ret2, options.wrapClosures);
 
     // Reject if one has named and the other has optional
     if (n1s.length > 0 && o2s.length > 0) return Coercion.error();
     if (n2s.length > 0 && o1s.length > 0) return Coercion.error();
 
     Map<String, Coercion> ns = new Map<String, Coercion>();
     // toT has named parameters
     if (n2s.length > 0) {
       // Coerce each named parameter from toT to the expected
       // type in fromT (note the contravariance)
@@ skipping 42 matching lines @@
   // wrapper coercion is produced using _wrapTo (see above)
   // Returns the error coercion if the types cannot be coerced
   // according to our current criteria.
   Coercion _coerceTo(DartType fromT, DartType toT, [bool wrap = false]) {
     // We can use anything as void
     if (toT.isVoid) return Coercion.identity(toT);
 
     // fromT <: toT, no coercion needed
     if (isSubTypeOf(fromT, toT)) return Coercion.identity(toT);
 
-    // Downcasting from dynamic to object always succeeds,
-    // no coercion needed.
-    if (fromT.isDynamic && toT == provider.objectType) {
-      return Coercion.identity(toT);
-    }
-
     // For now, we always wrap closures.
     if (wrap && fromT is FunctionType && toT is FunctionType) {
       return _wrapTo(fromT, toT);
     }
 
     // For now, reject conversions between function types and
     // call method objects.  We could choose to allow casts here.
     // Wrapping a function type to assign it to a call method
     // object will never succeed.  Wrapping the other way could
     // be allowed.
@@ skipping 12 matching lines @@
     // Iterable<T> for some concrete T (e.g. Object).  These are unrelated
     // in the restricted system, but List<dynamic> <: Iterable<T> in dart.
     if (options.relaxedCasts && fromT.isAssignableTo(toT)) {
       return Coercion.cast(fromT, toT);
     }
     return Coercion.error();
   }
 
   StaticInfo checkAssignment(Expression expr, DartType toT, bool constContext) {
     final fromT = getStaticType(expr);
-    final Coercion c = _coerceTo(fromT, toT, true);
+    final Coercion c = _coerceTo(fromT, toT, options.wrapClosures);
     if (c is Identity) return null;
     if (c is CoercionError) return new StaticTypeError(this, expr, toT);
     if (constContext && !options.allowConstCasts) {
       return new StaticTypeError(this, expr, toT);
     }
     if (c is Cast) return DownCast.create(this, expr, c);
     if (c is Wrapper) return ClosureWrap.create(this, expr, c, toT);
     assert(false);
     return null;
   }
@@ skipping 36 matching lines @@
       if (element is FunctionElement || element is MethodElement) {
         // An original declaration.
         return false;
       }
     }
 
     var ft = t as FunctionType;
     return _anyParameterType(ft, (pt) => pt.isDynamic);
   }
 }