Tweaks to warning level and reporting

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 226 matching lines @@
 
     // 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, 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);
+      return new UninferredClosure(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, 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.
@@ skipping 50 matching lines @@
 
 //
 // Temporary "casts" of allocation sites - literals, constructor invocations,
 // and closures.  These should be handled by contextual inference.  In most
 // cases, inference will be sufficient, though in some it may unmask an actual
 // error: e.g.,
 //   List<int> l = [1, 2, 3]; // Inference succeeds
 //   List<String> l = [1, 2, 3]; // Inference reveals static type error
 // We're marking all as warnings for now.
 //
-
-// A "down cast" on a closure literal.
-class InferableClosure extends DownCast {
-  InferableClosure(TypeRules rules, FunctionExpression expression, Cast cast)
+// TODO(vsm,leafp): Remove this.
+class UninferredClosure extends DownCast {
+  UninferredClosure(TypeRules rules, FunctionExpression expression, Cast cast)
       : super._internal(rules, expression, cast);
 
   final Level level = Level.WARNING;
 }
 
 //
 // Implicit down casts.  These are only injected by the compiler by flag.
 //
 
 // A down cast to a non-ground type.  These behave differently from standard
@@ skipping 137 matching lines @@
       : super._internal(rules, expression, wrapper, wrappedType);
 }
 
 class DynamicInvoke extends Conversion {
   DynamicInvoke(TypeRules rules, Expression expression)
       : super(rules, expression);
 
   DartType _getConvertedType() => rules.provider.dynamicType;
 
   String get message => '$expression requires dynamic invoke';
-  Level get level => Level.WARNING;
+  Level get level => Level.INFO;
 
   accept(AstVisitor visitor) {
     if (visitor is ConversionVisitor) {
       return visitor.visitDynamicInvoke(this);
     } else {
       return expression.accept(visitor);
     }
   }
 }
 
@@ skipping 233 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'));
 }();