Fix warnings on implicit casts

pkg/analyzer/lib/src/task/strong/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.
 // TODO(jmesserly): this was ported from package:dev_compiler, and needs to be
 // refactored to fit into analyzer.
 library analyzer.src.task.strong.info;
 
@@ skipping 136 matching lines @@
       // fromT should be an exact type - this will almost certainly fail at
       // runtime.
       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);
     }
 
+    // TODO(vsm): Change this to an assert when we have generic methods and
+    // fix TypeRules._coerceTo to disallow implicit sideways casts.
+    if (!rules.isSubTypeOf(toT, fromT)) {
+      assert(toT.isSubtypeOf(fromT) || fromT.isAssignableTo(toT));
+      return new DownCastComposite(rules, expression, cast);
+    }
+
     // 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);
+      if (fromT is InterfaceType) {
+        // For class types, we'd like to allow non-generic down casts, e.g.,
+        // Iterable<T> to List<T>.  The intuition here is that raw (generic)
+        // casts are problematic, and we should complain about those.
+        var typeArgs = fromT.typeArguments;
+        if (typeArgs.isEmpty || typeArgs.any((t) => t.isDynamic)) {

[Leaf, 2015/10/20 22:30:35]

I don't think we know that fromT is generic here do we?  And I think we only
want to warn if it is?  So for example, if we have:

class A<T extends int> {
   T foo(int x) => x;
}

I think this will give a warning, but if I replace int with List<int> it won't?

+          return new DownCastComposite(rules, expression, cast);
+        }
+      } else {
+        return new DownCastComposite(rules, expression, cast);
+      }
     }
 
     // Dynamic cast
     if (fromT.isDynamic) {
       return new DynamicCast(rules, expression, cast);
     }
 
     // Assignment cast
     var parent = expression.parent;
     if (parent is VariableDeclaration && (parent.initializer == expression)) {
@@ skipping 291 matching lines @@
 /// Better to have `super` at the end, as required by the Dart style guide:
 /// <http://goo.gl/q1T4BB>
 ///
 /// For now this is the only pattern we support.
 class InvalidSuperInvocation extends StaticError {
   InvalidSuperInvocation(SuperConstructorInvocation node) : super(node);
 
   @override String get message => "super call must be last in an initializer "
       "list (see http://goo.gl/q1T4BB): {0}";
 }