Better error messages

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 475 matching lines @@
       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, options.wrapClosures);
     if (c is Identity) return null;
     if (c is CoercionError) return new StaticTypeError(this, expr, toT);
-    if (options.inferDownwards && inferrer.inferExpression(expr, toT)) {
-      return InferredType.create(this, expr, toT);
+    var reason = null;
+    if (options.inferDownwards) {
+      var errors = <String>[];
+      var ok = inferrer.inferExpression(expr, toT, errors);
+      if (ok) return InferredType.create(this, expr, toT);
+      reason = (errors.isNotEmpty) ? errors.first : null;
     }
     if (constContext && !options.allowConstCasts) {
-      return new StaticTypeError(this, expr, toT);
+      reason = (reason == null) ? "Cast not allowed in const context" : reason;
+      return new StaticTypeError(this, expr, toT, reason: reason);
     }
-    if (c is Cast) return DownCast.create(this, expr, c);
+    if (c is Cast) return DownCast.create(this, expr, c, reason: reason);
     if (c is Wrapper) return ClosureWrap.create(this, expr, c, toT);
     assert(false);
     return null;
   }
 
   DartType elementType(Element e) {
     return (e as dynamic).type;
   }
 
   bool isDynamic(DartType t) => options.ignoreTypes || t.isDynamic;
@@ skipping 47 matching lines @@
   void annotateListLiteral(ListLiteral e, List<DartType> targs) {}
 
   /// Called for each map literal which gets inferred
   void annotateMapLiteral(MapLiteral e, List<DartType> targs) {}
 
   /// Called for each new/const which gets inferred
   void annotateInstanceCreationExpression(
       InstanceCreationExpression e, List<DartType> targs) {}
 
   /// Downward inference
-  bool inferExpression(Expression e, DartType t) {
-    if (e is Conversion) return inferExpression(e.node, t);
+  bool inferExpression(Expression e, DartType t, List<String> errors) {
+    if (e is Conversion) return inferExpression(e.node, t, errors);
     if (rules.isSubTypeOf(rules.getStaticType(e), t)) return true;
-    if (e is FunctionExpression) return _inferFunctionExpression(e, t);
-    if (e is ListLiteral) return _inferListLiteral(e, t);
-    if (e is MapLiteral) return _inferMapLiteral(e, t);
-    if (e is NamedExpression) return _inferNamedExpression(e, t);
+    if (e is FunctionExpression) return _inferFunctionExpression(e, t, errors);
+    if (e is ListLiteral) return _inferListLiteral(e, t, errors);
+    if (e is MapLiteral) return _inferMapLiteral(e, t, errors);
+    if (e is NamedExpression) return _inferNamedExpression(e, t, errors);
     if (e is InstanceCreationExpression) return _inferInstanceCreationExpression(
-        e, t);
+        e, t, errors);
+    errors.add("$e cannot be typed as $t");
     return false;
   }
 
   /// If t1 = I<dynamic, ..., dynamic>, then look for a supertype
   /// of t1 of the form K<S0, ..., Sm> where t2 = K<S0', ..., Sm'>
   /// If the supertype exists, use the constraints S0 <: S0', ... Sm <: Sm'
   /// to derive a concrete instantation for I of the form <T0, ..., Tn>,
   /// such that I<T0, .., Tn> <: t2
   List<DartType> _matchTypes(InterfaceType t1, InterfaceType t2) {
     if (t1 == t2) return t2.typeArguments;
@@ skipping 65 matching lines @@
     if (!match(t1.element.type)) return null;
     var newT1 = t1.element.type.substitute4(actuals);
     // If we found a solution, return it.
     if (rules.isSubTypeOf(newT1, t2)) return actuals;
     return null;
   }
 
   /// These assume that e is not already a subtype of t
 
   bool _inferInstanceCreationExpression(
-      InstanceCreationExpression e, DartType t) {
+      InstanceCreationExpression e, DartType t, errors) {
     var arguments = e.argumentList.arguments;
     var rawType = rules.getStaticType(e);
     // rawType is the instantiated type of the instance
     if (rawType is! InterfaceType) return false;
     var type = (rawType as InterfaceType);
     if (type.typeParameters == null ||
         type.typeParameters.length == 0) return false;
     if (e.constructorName.type == null) return false;
     // classTypeName is the type name of the class being instantiated
     var classTypeName = e.constructorName.type;
@@ skipping 20 matching lines @@
     var fType = baseType.substitute2(targs, tparams);
     {
       var rTypes = fType.normalParameterTypes;
       var oTypes = fType.optionalParameterTypes;
       var pTypes = new List.from(rTypes)..addAll(oTypes);
       var pArgs = arguments.where((x) => x is! NamedExpression);
       var pi = 0;
       for (var arg in pArgs) {
         if (pi >= pTypes.length) return false;
         var argType = pTypes[pi];
-        if (!inferExpression(arg, argType)) return false;
+        if (!inferExpression(arg, argType, errors)) return false;
         pi++;
       }
       var nTypes = fType.namedParameterTypes;
       for (var arg0 in arguments) {
         if (arg0 is! NamedExpression) continue;
         var arg = arg0 as NamedExpression;
         SimpleIdentifier nameNode = arg.name.label;
         String name = nameNode.name;
         var argType = nTypes[name];
         if (argType == null) return false;
-        if (!inferExpression(arg, argType)) return false;
+        if (!inferExpression(arg, argType, errors)) return false;
       }
     }
     annotateInstanceCreationExpression(e, targs);
     return true;
   }
 
-  bool _inferNamedExpression(NamedExpression e, DartType t) {
-    return inferExpression(e.expression, t);
+  bool _inferNamedExpression(NamedExpression e, DartType t, errors) {
+    return inferExpression(e.expression, t, errors);
   }
 
-  bool _inferFunctionExpression(FunctionExpression e, DartType t) {
+  bool _inferFunctionExpression(FunctionExpression e, DartType t, errors) {
     if (t is! FunctionType) return false;
     var returnT = (t as FunctionType).returnType;
     if (returnT.isDynamic) return false;
     var eType = e.staticType;
     if (eType is! FunctionType) return false;
     if (e.body is! ExpressionFunctionBody) return false;
     var body = (e.body as ExpressionFunctionBody).expression;
-    if (!inferExpression(body, returnT)) return false;
+    if (!inferExpression(body, returnT, errors)) return false;
     // TODO(leafp): Try narrowing the argument types if possible
     // to get better code in the function body.  This requires checking
     // that the body is well-typed at the more specific type.
     var element = (e.element as ExecutableElementImpl);
     var oldReturnT = element.returnType;
     element.returnType = returnT;
     // Work around dynamic as bottom for now by handling function literals
     // with dynamic arguments specially.  We already know the body is typable
     // at the chosen type, and if all args are dynamic, then function must be
     // typeable.
     if ((eType as FunctionType).parameters.every((x) => x.type.isDynamic)) {
       return true;
     }
     if (rules.isSubTypeOf(e.staticType, t)) return true;
     element.returnType = oldReturnT;
     return false;
   }
 
-  bool _inferListLiteral(ListLiteral e, DartType t) {
+  bool _inferListLiteral(ListLiteral e, DartType t, errors) {
     var dyn = rules.provider.dynamicType;
     var listT = rules.provider.listType.substitute4([dyn]);
     // List <: t (using dart rules) must be true
     if (!listT.isSubtypeOf(t)) return false;
     // The list literal must have no type arguments
     if (e.typeArguments != null) return false;
     if (t is! InterfaceType) return false;
     var targs = _matchTypes(listT, t);
     if (targs == null) return false;
     assert(targs.length == 1);
     var etype = targs[0];
     assert(!etype.isDynamic);
     var elements = e.elements;
-    var b = elements.every((e) => inferExpression(e, etype));
+    var b = elements.every((e) => inferExpression(e, etype, errors));
     if (b) annotateListLiteral(e, targs);
     return b;
   }
 
-  bool _inferMapLiteral(MapLiteral e, DartType t) {
+  bool _inferMapLiteral(MapLiteral e, DartType t, errors) {
     var dyn = rules.provider.dynamicType;
     var mapT = rules.provider.mapType.substitute4([dyn, dyn]);
     // Map <: t (using dart rules) must be true
     if (!mapT.isSubtypeOf(t)) return false;
     // The map literal must have no type arguments
     if (e.typeArguments != null) return false;
     if (t is! InterfaceType) return false;
     var targs = _matchTypes(mapT, t);
     if (targs == null) return false;
     assert(targs.length == 2);
     var kType = targs[0];
     var vType = targs[1];
     assert(!(kType.isDynamic && vType.isDynamic));
     var entries = e.entries;
     bool inferEntry(MapLiteralEntry entry) {
-      return inferExpression(entry.key, kType) &&
-          inferExpression(entry.value, vType);
+      return inferExpression(entry.key, kType, errors) &&
+          inferExpression(entry.value, vType, errors);
     }
     var b = entries.every(inferEntry);
     if (b) annotateMapLiteral(e, targs);
     return b;
   }
 }