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 111 matching lines @@
 
   // Factory to create correct DownCast variant.
   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) {
       // 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, reason: reason);
     }
     if (expression is FunctionExpression) {
       // 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)) {
+          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}";
 }