Better error messages

lib/src/info.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.
 
 /// Defines static information collected by the type checker and used later by
 /// emitters to generate code.
 library dev_compiler.src.info;
 
 import 'dart:mirrors';
 
@@ skipping 194 matching lines @@
   }
 
   Cast get cast => _cast;
 
   DartType _getConvertedType() => _cast.toType;
 
   String get message => '$expression ($baseType) will need runtime check '
       'to cast to type $convertedType';
 
   // Factory to create correct DownCast variant.
-  static StaticInfo create(TypeRules rules, Expression expression, Cast cast) {
+  static StaticInfo create(TypeRules rules, Expression expression, Cast cast,
+      {String reason}) {
     final fromT = cast.fromType;
     final toT = cast.toType;
 
     // toT <:_R fromT => to <: fromT
     // NB: classes with call methods are subtypes of function
     // types, but the function type is not assignable to the class
     assert(toT.isSubtypeOf(fromT) || fromT.isAssignableTo(toT));
 
     // Handle null call specially.
     if (expression is NullLiteral) {
       if (rules.isNonNullableType(toT)) {
-        return new StaticTypeError(rules, expression, toT);
+        reason = "null is invalid as a $toT";
+        return new StaticTypeError(rules, expression, toT, reason: reason);
       } else {
         // We should only get here if some coercion is required.
         assert(rules.maybeNonNullableType(toT));
         // TODO(vsm): Create a NullCast for this once we revisit nonnullability.
         return new DownCastImplicit(rules, expression, cast);
       }
     }
 
     // Inference "casts":
     if (expression is Literal) {
       // fromT should be an exact type - this will almost certainly fail at
       // runtime.
-      return new StaticTypeError(rules, expression, toT);
+      return new StaticTypeError(rules, expression, toT, reason: reason);
     }
     if (expression is FunctionExpression) {
       // fromT should be an exact type - this will almost certainly fail at
       // runtime.
       return new InferableClosure(rules, expression, cast);
     }
     if (expression is InstanceCreationExpression) {
       // fromT should be an exact type - this will almost certainly fail at
       // runtime.
-      return new StaticTypeError(rules, expression, toT);
+      return new StaticTypeError(rules, expression, toT, reason: reason);
     }
 
     // Composite cast: these are more likely to fail.
     if (!rules.isGroundType(toT)) {
       // This cast is (probably) due to our different treatment of dynamic.
       // It may be more likely to fail at runtime.
       return new DownCastComposite(rules, expression, cast);
     }
 
     // Dynamic cast
@@ skipping 228 matching lines @@
   final AstNode node;
 
   StaticError(this.node);
 
   Level get level => Level.SEVERE;
 }
 
 class StaticTypeError extends StaticError {
   final DartType baseType;
   final DartType expectedType;
+  String reason = null;
 
-  StaticTypeError(TypeRules rules, Expression expression, this.expectedType)
+  StaticTypeError(TypeRules rules, Expression expression, this.expectedType,
+      {this.reason})
       : baseType = rules.getStaticType(expression),
         super(expression);
 
   String get message =>
-      'Type check failed: $node ($baseType) is not of type $expectedType';
+      'Type check failed: $node ($baseType) is not of type $expectedType' +
+          ((reason == null) ? '' : ' because $reason');
 }
 
 class InvalidVariableDeclaration extends StaticError {
   final DartType expectedType;
 
   InvalidVariableDeclaration(
       TypeRules rules, AstNode declaration, this.expectedType)
       : super(declaration);
 
   String get message => 'Type check failed: null is not of type $expectedType';
@@ skipping 202 matching lines @@
   for (var cls in declarations.where((d) => d is ClassMirror)) {
     if (cls.isSubtypeOf(infoMirror)) {
       allTypes.add(cls);
       baseTypes.add(cls.superclass);
     }
   }
   allTypes.removeAll(baseTypes);
   return new List<Type>.from(allTypes.map((mirror) => mirror.reflectedType))
     ..sort((t1, t2) => '$t1'.compareTo('$t2'));
 }();