Rationalize coercions

test/checker/checker_test.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.
 
 /// General type checking tests
 library dev_compiler.test.checker_test;
 
 import 'package:unittest/unittest.dart';
 
 import 'package:dev_compiler/src/testing.dart';
@@ skipping 11 matching lines @@
 
         void baz1(y) => x + y;
         static baz2(y) => y + y;
       }
 
       void foo(String str) {
         print(str);
       }
 
       void bar(a) {
-        foo(/*info:DownCast,warning:DynamicInvoke*/a.x);
+        foo(/*info:DynamicCast,warning:DynamicInvoke*/a.x);
       }
 
       typedef DynFun(x);
       typedef StrFun(String x);
 
       var bar1 = bar;
 
       void main() {
         var a = new A();
         bar(a);
@@ skipping 42 matching lines @@
         void bar(int w, {int x = /*severe:StaticTypeError*/null, int /*severe:InvalidVariableDeclaration*/y, int z: 0}) {
         }
 
         void main() {
           int /*severe:InvalidVariableDeclaration*/x;
           double /*severe:InvalidVariableDeclaration*/y;
           num z;
           bool b;
 
           // int is non-nullable
-          // TODO(vsm): This should be an error, not a warning.
-          x = /*warning:DownCastLiteral*/null;
+          x = /*severe:StaticTypeError*/null;
           x = 42;
-          x = /*info:DownCast*/z;
+          x = /*warning:DownCastImplicit*/z;
 
           // double is non-nullable
-          // TODO(vsm): This should be an error, not a warning.
-          y = /*warning:DownCastLiteral*/null;
+          y = /*severe:StaticTypeError*/null;
           y = /*severe:StaticTypeError*/42;
           y = 42.0;
-          y = /*info:DownCast*/z;
+          y = /*warning:DownCastImplicit*/z;
 
           // num is nullable
           z = null;
           z = x;
           z = y;
 
           // bool is nullable
           b = null;
           b = true;
         }
       '''
     }, nonnullableTypes: <String>['int', 'double']);
   });
 
   test('Primitives and generics', () {
     testChecker({
       '/main.dart': '''
         class A<T> {
           // TODO(vsm): This needs a static info indicating a runtime
           // check at construction.
           T x;
 
           // TODO(vsm): Should this be a different type of DownCast?
-          T foo() => /*warning:DownCastLiteral*/null;
+          T foo() => /*warning:DownCastImplicit*/null;
 
           void bar() {
             int /*severe:InvalidVariableDeclaration*/x;
             num y;
             // TODO(vsm): This should be a runtime check:
             // Transformed to: T z = cast(null, T)
             T /*severe:InvalidVariableDeclaration*/z;
           }
 
           void baz(T x, [T /*severe:InvalidVariableDeclaration*/y, T z = /*severe:StaticTypeError*/null]) {
           }
         }
 
         class B<T extends List> {
           T x;
 
           // T cannot be primitive.
           T foo() => null;
         }
 
         class C<T extends num> {
           // TODO(vsm): This needs a static info indicating a runtime
           // check at construction.
           T x;
 
           // TODO(vsm): Should this be a different type of DownCast?
-          T foo() => /*warning:DownCastLiteral*/null;
+          T foo() => /*warning:DownCastImplicit*/null;
         }
       '''
     }, nonnullableTypes: <String>['int', 'double']);
   });
 
   test('Constructors', () {
     testChecker({
       '/main.dart': '''
       const num z = 25;
       Object obj = "world";
 
       class A {
         int x;
         String y;
 
         A(this.x) : this.y = /*severe:StaticTypeError*/42;
 
-        A.c1(p): this.x = /*info:DownCast*/z, this.y = /*info:DownCast*/p;
+        A.c1(p): this.x = /*warning:DownCastImplicit*/z, this.y = /*info:DynamicCast*/p;
 
         A.c2(this.x, this.y);
 
         A.c3(/*severe:InvalidParameterDeclaration*/num this.x, String this.y);
       }
 
       class B extends A {
         B() : super(/*severe:StaticTypeError*/"hello");
 
         B.c2(int x, String y) : super.c2(/*severe:StaticTypeError*/y, 
                                          /*severe:StaticTypeError*/x);
 
-        B.c3(num x, Object y) : super.c3(x, /*info:DownCast*/y);
+        B.c3(num x, Object y) : super.c3(x, /*warning:DownCastImplicit*/y);
       }
 
       void main() {
-         A a = new A.c2(/*info:DownCast*/z, /*severe:StaticTypeError*/z);
-         var b = new B.c2(/*severe:StaticTypeError*/"hello", /*info:DownCast*/obj);
+         A a = new A.c2(/*warning:DownCastImplicit*/z, /*severe:StaticTypeError*/z);
+         var b = new B.c2(/*severe:StaticTypeError*/"hello", /*warning:DownCastImplicit*/obj);
       }
    '''
     });
   });
 
   test('Unbound variable', () {
     testChecker({
       '/main.dart': '''
       void main() {
          dynamic y = /*pass should be severe:StaticTypeError*/unboundVariable;
@@ skipping 47 matching lines @@
 
       void main() {
          dynamic y;
          Object o;
          int i = 0;
          double d = 0.0;
          num n;
          A a;
          B b;
          o = y;
-         i = /*info:DownCast*/y;
-         d = /*info:DownCast*/y;
-         n = /*info:DownCast*/y;
-         a = /*info:DownCast*/y;
-         b = /*info:DownCast*/y;
+         i = /*info:DynamicCast*/y;
+         d = /*info:DynamicCast*/y;
+         n = /*info:DynamicCast*/y;
+         a = /*info:DynamicCast*/y;
+         b = /*info:DynamicCast*/y;
       }
    '''
     });
   });
 
   test('Ground type subtyping: assigning a class', () {
     testChecker({
       '/main.dart': '''
 
       class A {}
       class B extends A {}
 
       void main() {
          dynamic y;
          Object o;
          int i = 0;
          double d = 0.0;
          num n;
          A a;
          B b;
          y = a;
          o = a;
          i = /*severe:StaticTypeError*/a;
          d = /*severe:StaticTypeError*/a;
          n = /*severe:StaticTypeError*/a;
          a = a;
-         b = /*info:DownCast*/a;
+         b = /*warning:DownCastImplicit*/a;
       }
    '''
     });
   });
 
   test('Ground type subtyping: assigning a subclass', () {
     testChecker({
       '/main.dart': '''
 
       class A {}
@@ skipping 36 matching lines @@
          B left;
          C right;
          D bot;
          {
            top = top;
            top = left;
            top = right;
            top = bot;
          }
          {
-           left = /*info:DownCast*/top;
+           left = /*warning:DownCastImplicit*/top;
            left = left;
            left = /*severe:StaticTypeError*/right;
            left = bot;
          }
          {
-           right = /*info:DownCast*/top;
+           right = /*warning:DownCastImplicit*/top;
            right = /*severe:StaticTypeError*/left;
            right = right;
            right = bot;
          }
          {
-           bot = /*info:DownCast*/top;
-           bot = /*info:DownCast*/left;
-           bot = /*info:DownCast*/right;
+           bot = /*warning:DownCastImplicit*/top;
+           bot = /*warning:DownCastImplicit*/left;
+           bot = /*warning:DownCastImplicit*/right;
            bot = bot;
          }
       }
    '''
     });
   });
 
   test('Function typing and subtyping: int and object', () {
     testChecker({
       '/main.dart': '''
 
       typedef Object Top(int x);      // Top of the lattice
       typedef int Left(int x);        // Left branch
       typedef int Left2(int x);       // Left branch
       typedef Object Right(Object x); // Right branch
       typedef int Bot(Object x);      // Bottom of the lattice
 
       Object top(int x) => x;
       int left(int x) => x;
       Object right(Object x) => x;
-      int _bot(Object x) => /*info:DownCast*/x;
+      int _bot(Object x) => /*warning:DownCastImplicit*/x;
       int bot(Object x) => x as int;
 
       void main() {
         { // Check typedef equality
           Left f = left;
           Left2 g = f;
         }
         // TODO(leafp) Decide on ClosureWrap vs DownCast (or error).
         {
           Top f;
@@ skipping 35 matching lines @@
       class A {}
       class B extends A {}
 
       typedef A Top(B x);   // Top of the lattice
       typedef B Left(B x);  // Left branch
       typedef B Left2(B x); // Left branch
       typedef A Right(A x); // Right branch
       typedef B Bot(A x);   // Bottom of the lattice
 
       B left(B x) => x;
-      B _bot(A x) => /*info:DownCast*/x;
+      B _bot(A x) => /*warning:DownCastImplicit*/x;
       B bot(A x) => x as B;
       A top(B x) => x;
       A right(A x) => x;
 
       void main() {
         { // Check typedef equality
           Left f = left;
           Left2 g = f;
         }
         {
@@ skipping 36 matching lines @@
       class A {}
 
       typedef dynamic Top(dynamic x);     // Top of the lattice
       typedef dynamic Left(A x);          // Left branch
       typedef A Right(dynamic x);         // Right branch
       typedef A Bottom(A x);              // Bottom of the lattice
 
       dynamic left(A x) => x;
       A bot(A x) => x;
       dynamic top(dynamic x) => x;
-      A right(dynamic x) => /*info:DownCast*/x;
+      A right(dynamic x) => /*info:DynamicCast*/x;
 
       void main() {
         {
           Top f;
           f = top;
           f = left;
           f = right;
           f = bot;
         }
         {
@@ skipping 352 matching lines @@
       }
       int i2i(int x) => x;
       num n2n(num x) => x;
       void main() {
          {
            I2I f;
            f = new A();
            f = /*severe:StaticTypeError*/new B();
            f = i2i;
            f = /*warning:ClosureWrap*/n2n;
-           f = /*warning:DownCast*/(i2i as Object);
-           f = /*warning:DownCast*/(n2n as Function);
+           f = /*warning:DownCastComposite*/(i2i as Object);
+           f = /*warning:DownCastComposite*/(n2n as Function);
          }
          {
            N2N f;
            f = /*severe:StaticTypeError*/new A();
            f = new B();
            f = /*warning:ClosureWrap*/i2i;
            f = n2n;
-           f = /*warning:DownCast*/(i2i as Object);
-           f = /*warning:DownCast*/(n2n as Function);
+           f = /*warning:DownCastComposite*/(i2i as Object);
+           f = /*warning:DownCastComposite*/(n2n as Function);
          }
          {
            A f;
            f = new A();
            f = /*severe:StaticTypeError*/new B();
            f = /*severe:StaticTypeError*/i2i;
            f = /*severe:StaticTypeError*/n2n;
-           f = /*info:DownCast*/(i2i as Object);
-           f = /*info:DownCast*/(n2n as Function);
+           f = /*warning:DownCastImplicit*/(i2i as Object);
+           f = /*warning:DownCastImplicit*/(n2n as Function);
          }
          {
            B f;
            f = /*severe:StaticTypeError*/new A();
            f = new B();
            f = /*severe:StaticTypeError*/i2i;
            f = /*severe:StaticTypeError*/n2n;
-           f = /*info:DownCast*/(i2i as Object);
-           f = /*info:DownCast*/(n2n as Function);
+           f = /*warning:DownCastImplicit*/(i2i as Object);
+           f = /*warning:DownCastImplicit*/(n2n as Function);
          }
          {
            Function f;
            f = new A();
            f = new B();
            f = i2i;
            f = n2n;
-           f = /*info:DownCast*/(i2i as Object);
+           f = /*warning:DownCastImplicit*/(i2i as Object);
            f = (n2n as Function);
          }
       }
    '''
     });
   });
 
   test('Function typing and subtyping: void', () {
     testChecker({
       '/main.dart': '''
@@ skipping 81 matching lines @@
 
         // M<S> <: L<S>
         lOfCs = /*severe:StaticTypeError*/mOfAs;
         lOfCs = /*severe:StaticTypeError*/mOfBs;
         lOfCs = mOfCs;
 
         // N </: L<C>
         lOfCs = /*severe:StaticTypeError*/ns;
 
         // M<T> <: L<S> iff S = dynamic or S=T
-        mOfAs = /*info:DownCast*/lOfAs;
+        mOfAs = /*warning:DownCastComposite*/lOfAs;
         mOfAs = /*severe:StaticTypeError*/lOfBs;
         mOfAs = /*severe:StaticTypeError*/lOfCs;
 
         // M<S> <: M<S> iff S = dynamic or S=T
         mOfAs = mOfAs;
         mOfAs = /*severe:StaticTypeError*/mOfBs;
         mOfAs = /*severe:StaticTypeError*/mOfCs;
 
         // N <: M<A>
         mOfAs = ns;
 
         // M<T> <: L<S> iff S = dynamic or S=T
         mOfBs = /*severe:StaticTypeError*/lOfAs;
-        mOfBs = /*info:DownCast*/lOfBs;
+        mOfBs = /*warning:DownCastComposite*/lOfBs;
         mOfBs = /*severe:StaticTypeError*/lOfCs;
 
         // M<S> <: M<S> iff S = dynamic or S=T
         mOfBs = /*severe:StaticTypeError*/mOfAs;
         mOfBs = mOfBs;
         mOfBs = /*severe:StaticTypeError*/mOfCs;
 
         // N </: M<B>
         mOfBs = /*severe:StaticTypeError*/ns;
 
         // M<T> <: L<S> iff S = dynamic or S=T
         mOfCs = /*severe:StaticTypeError*/lOfAs;
         mOfCs = /*severe:StaticTypeError*/lOfBs;
-        mOfCs = /*info:DownCast*/lOfCs;
+        mOfCs = /*warning:DownCastComposite*/lOfCs;
 
         // M<S> <: M<S> iff S = dynamic or S=T
         mOfCs = /*severe:StaticTypeError*/mOfAs;
         mOfCs = /*severe:StaticTypeError*/mOfBs;
         mOfCs = mOfCs;
 
         // N </: L<C>
         mOfCs = /*severe:StaticTypeError*/ns;
 
         // Concrete subclass subtyping
-        ns = /*info:DownCast*/lOfAs;
+        ns = /*warning:DownCastImplicit*/lOfAs;
         ns = /*severe:StaticTypeError*/lOfBs;
         ns = /*severe:StaticTypeError*/lOfCs;
-        ns = /*info:DownCast*/mOfAs;
+        ns = /*warning:DownCastImplicit*/mOfAs;
         ns = /*severe:StaticTypeError*/mOfBs;
         ns = /*severe:StaticTypeError*/mOfCs;
         ns = ns;
       }
    '''
     }, covariantGenerics: false, relaxedCasts: false);
   });
 
   test('Generic subtyping: covariant raw types', () {
     testChecker({
@@ skipping 42 matching lines @@
         lOfDynamics = lOfBs;
         lOfDynamics = lOfCs;
         lOfDynamics = mRaw;
         lOfDynamics = mOfDynamics;
         lOfDynamics = mOfAs;
         lOfDynamics = mOfBs;
         lOfDynamics = mOfCs;
         lOfDynamics = ns;
 
         // L<T> <: L<S> iff S = dynamic or S=T
-        lOfAs = /*warning:DownCastDynamic*/lRaw;
-        lOfAs = /*warning:DownCastDynamic*/lOfDynamics;
+        lOfAs = /*warning:DownCastComposite*/lRaw;
+        lOfAs = /*warning:DownCastComposite*/lOfDynamics;
 
         // M<dynamic> </:/> L<A>
         lOfAs = /*severe:StaticTypeError*/mRaw;
         lOfAs = /*severe:StaticTypeError*/mOfDynamics;
 
         // L<T> <: L<S> iff S = dynamic or S=T
-        lOfBs = /*warning:DownCastDynamic*/lRaw;
-        lOfBs = /*warning:DownCastDynamic*/lOfDynamics;
+        lOfBs = /*warning:DownCastComposite*/lRaw;
+        lOfBs = /*warning:DownCastComposite*/lOfDynamics;
 
         // M<dynamic> </:/> L<B>
         lOfBs = /*severe:StaticTypeError*/mRaw;
         lOfBs = /*severe:StaticTypeError*/mOfDynamics;
 
         // L<T> <: L<S> iff S = dynamic or S=T
-        lOfCs = /*warning:DownCastDynamic*/lRaw;
-        lOfCs = /*warning:DownCastDynamic*/lOfDynamics;
+        lOfCs = /*warning:DownCastComposite*/lRaw;
+        lOfCs = /*warning:DownCastComposite*/lOfDynamics;
 
         // M<dynamic> </:/> L<C>
         lOfCs = /*severe:StaticTypeError*/mRaw;
         lOfCs = /*severe:StaticTypeError*/mOfDynamics;
 
         // Raw type subtyping
-        mRaw = /*info:DownCast*/lRaw;
-        mRaw = /*info:DownCast*/lOfDynamics;
+        mRaw = /*warning:DownCastImplicit*/lRaw;
+        mRaw = /*warning:DownCastImplicit*/lOfDynamics;
         mRaw = /*severe:StaticTypeError*/lOfAs;
         mRaw = /*severe:StaticTypeError*/lOfBs;
         mRaw = /*severe:StaticTypeError*/lOfCs;
         mRaw = mRaw;
         mRaw = mOfDynamics;
         mRaw = mOfAs;
         mRaw = mOfBs;
         mRaw = mOfCs;
         mRaw = ns;
 
         // M<dynamic> == M
-        mOfDynamics = /*info:DownCast*/lRaw;
-        mOfDynamics = /*info:DownCast*/lOfDynamics;
+        mOfDynamics = /*warning:DownCastImplicit*/lRaw;
+        mOfDynamics = /*warning:DownCastImplicit*/lOfDynamics;
         mOfDynamics = /*severe:StaticTypeError*/lOfAs;
         mOfDynamics = /*severe:StaticTypeError*/lOfBs;
         mOfDynamics = /*severe:StaticTypeError*/lOfCs;
         mOfDynamics = mRaw;
         mOfDynamics = mOfDynamics;
         mOfDynamics = mOfAs;
         mOfDynamics = mOfBs;
         mOfDynamics = mOfCs;
         mOfDynamics = ns;
 
         // M<T> <: L<S> iff S = dynamic or S=T
-        mOfAs = /*info:DownCast*/lRaw;
-        mOfAs = /*info:DownCast*/lOfDynamics;
+        mOfAs = /*warning:DownCastComposite*/lRaw;
+        mOfAs = /*warning:DownCastComposite*/lOfDynamics;
 
         // M<dynamic> </:/> M<A>
-        mOfAs = /*warning:DownCastDynamic*/mRaw;
-        mOfAs = /*warning:DownCastDynamic*/mOfDynamics;
+        mOfAs = /*warning:DownCastComposite*/mRaw;
+        mOfAs = /*warning:DownCastComposite*/mOfDynamics;
 
         // M<T> <: L<S> iff S = dynamic or S=T
-        mOfBs = /*info:DownCast*/lRaw;
-        mOfBs = /*info:DownCast*/lOfDynamics;
+        mOfBs = /*warning:DownCastComposite*/lRaw;
+        mOfBs = /*warning:DownCastComposite*/lOfDynamics;
 
         // M<dynamic> </:/> M<B>
-        mOfBs = /*warning:DownCastDynamic*/mRaw;
-        mOfBs = /*warning:DownCastDynamic*/mOfDynamics;
+        mOfBs = /*warning:DownCastComposite*/mRaw;
+        mOfBs = /*warning:DownCastComposite*/mOfDynamics;
 
         // M<T> <: L<S> iff S = dynamic or S=T
-        mOfCs = /*info:DownCast*/lRaw;
-        mOfCs = /*info:DownCast*/lOfDynamics;
+        mOfCs = /*warning:DownCastComposite*/lRaw;
+        mOfCs = /*warning:DownCastComposite*/lOfDynamics;
 
         // M<dynamic> </:/> M<C>
-        mOfCs = /*warning:DownCastDynamic*/mRaw;
-        mOfCs = /*warning:DownCastDynamic*/mOfDynamics;
+        mOfCs = /*warning:DownCastComposite*/mRaw;
+        mOfCs = /*warning:DownCastComposite*/mOfDynamics;
 
         // Concrete subclass subtyping
-        ns = /*info:DownCast*/lRaw;
-        ns = /*info:DownCast*/lOfDynamics;
-        ns = /*info:DownCast*/mRaw;
-        ns = /*info:DownCast*/mOfDynamics;
+        ns = /*warning:DownCastImplicit*/lRaw;
+        ns = /*warning:DownCastImplicit*/lOfDynamics;
+        ns = /*warning:DownCastImplicit*/mRaw;
+        ns = /*warning:DownCastImplicit*/mOfDynamics;
       }
    '''
     }, covariantGenerics: false, relaxedCasts: false);
   });
 
   test('Generic subtyping: covariant raw types with multiple parameters', () {
     testChecker({
       '/main.dart': '''
 
       class A {}
@@ skipping 41 matching lines @@
         // L<dynamic, dynamic>
         lOfDD = lRaw;
         lOfDD = lOfD_;
         lOfDD = lOfA_;
         lOfDD = lOfDA;
         lOfDD = lOfAD;
         lOfDD = lOfDD;
         lOfDD = lOfAA;
 
         // L<dynamic, A>
-        lOfDA = /*warning:DownCastDynamic*/lRaw;
-        lOfDA = /*warning:DownCastDynamic*/lOfD_;
-        lOfDA = /*warning:DownCastDynamic*/lOfA_;
+        lOfDA = /*warning:DownCastComposite*/lRaw;
+        lOfDA = /*warning:DownCastComposite*/lOfD_;
+        lOfDA = /*warning:DownCastComposite*/lOfA_;
         lOfDA = lOfDA;
         lOfDA = /*severe:StaticTypeError*/lOfAD;
-        lOfDA = /*warning:DownCastDynamic*/lOfDD;
+        lOfDA = /*warning:DownCastComposite*/lOfDD;
         lOfDA = lOfAA;
 
         // L<A, dynamic>
-        lOfAD = /*warning:DownCastDynamic*/lRaw;
-        lOfAD = /*warning:DownCastDynamic*/lOfD_;
-        lOfAD = /*warning:DownCastDynamic*/lOfA_;
+        lOfAD = /*warning:DownCastComposite*/lRaw;
+        lOfAD = /*warning:DownCastComposite*/lOfD_;
+        lOfAD = /*warning:DownCastComposite*/lOfA_;
         lOfAD = /*severe:StaticTypeError*/lOfDA;
         lOfAD = lOfAD;
-        lOfAD = /*warning:DownCastDynamic*/lOfDD;
+        lOfAD = /*warning:DownCastComposite*/lOfDD;
         lOfAD = lOfAA;
 
         // L<A> == L<dynamic, dynamic>
         lOfA_ = lRaw;
         lOfA_ = lOfD_;
         lOfA_ = lOfA_;
         lOfA_ = lOfDA;
         lOfA_ = lOfAD;
         lOfA_ = lOfDD;
         lOfA_ = lOfAA;
 
         // L<A, A>
-        lOfAA = /*warning:DownCastDynamic*/lRaw;
-        lOfAA = /*warning:DownCastDynamic*/lOfD_;
-        lOfAA = /*warning:DownCastDynamic*/lOfA_;
-        lOfAA = /*warning:DownCastDynamic*/lOfDA;
-        lOfAA = /*warning:DownCastDynamic*/lOfAD;
-        lOfAA = /*warning:DownCastDynamic*/lOfDD;
+        lOfAA = /*warning:DownCastComposite*/lRaw;
+        lOfAA = /*warning:DownCastComposite*/lOfD_;
+        lOfAA = /*warning:DownCastComposite*/lOfA_;
+        lOfAA = /*warning:DownCastComposite*/lOfDA;
+        lOfAA = /*warning:DownCastComposite*/lOfAD;
+        lOfAA = /*warning:DownCastComposite*/lOfDD;
         lOfAA = lOfAA;
       }
    '''
     }, covariantGenerics: false, relaxedCasts: false);
   });
 
   test('Covariant generic subtyping: invariance', () {
     testChecker({
       '/main.dart': '''
 
@@ skipping 23 matching lines @@
 
         // M<T> <: L<S> iff T <: S
         lOfAs = mOfAs;
         lOfAs = mOfBs;
         lOfAs = mOfCs;
 
         // N <: L<A>
         lOfAs = ns;
 
         // L<T> <: L<S> iff S <: T
-        lOfBs = /*info:DownCast*/lOfAs;
+        lOfBs = /*warning:DownCastComposite*/lOfAs;
         lOfBs = lOfBs;
         lOfBs = /*severe:StaticTypeError*/lOfCs;
 
         // M<T> <: L<S> iff T <: S
         lOfBs = /*severe:StaticTypeError*/mOfAs;
         lOfBs = mOfBs;
         lOfBs = /*severe:StaticTypeError*/mOfCs;
 
         // N </: L<B>
         lOfBs = /*severe:StaticTypeError*/ns;
 
         // L<T> <: L<S> iff S <: T
-        lOfCs = /*info:DownCast*/lOfAs;
+        lOfCs = /*warning:DownCastComposite*/lOfAs;
         lOfCs = /*severe:StaticTypeError*/lOfBs;
         lOfCs = lOfCs;
 
         // M<T> <: L<S> iff T <: S
         lOfCs = /*severe:StaticTypeError*/mOfAs;
         lOfCs = /*severe:StaticTypeError*/mOfBs;
         lOfCs = mOfCs;
 
         // N </: L<C>
         lOfCs = /*severe:StaticTypeError*/ns;
 
         // M<T> <: L<S> iff T <: S
-        mOfAs = /*info:DownCast*/lOfAs;
+        mOfAs = /*warning:DownCastComposite*/lOfAs;
         mOfAs = /*severe:StaticTypeError*/lOfBs;
         mOfAs = /*severe:StaticTypeError*/lOfCs;
 
         // M<T> <: M<S> iff T <: S
         mOfAs = mOfAs;
         mOfAs = mOfBs;
         mOfAs = mOfCs;
 
         // N <: M<A>
         mOfAs = ns;
 
         // M<T> <: L<S> iff T <: S
-        mOfBs = /*info:DownCast*/lOfAs;
-        mOfBs = /*info:DownCast*/lOfBs;
+        mOfBs = /*warning:DownCastComposite*/lOfAs;
+        mOfBs = /*warning:DownCastComposite*/lOfBs;
         mOfBs = /*severe:StaticTypeError*/lOfCs;
 
         // M<T> <: M<S> iff T <: S
-        mOfBs = /*info:DownCast*/mOfAs;
+        mOfBs = /*warning:DownCastComposite*/mOfAs;
         mOfBs = mOfBs;
         mOfBs = /*severe:StaticTypeError*/mOfCs;
 
         // N </: M<B>
         mOfBs = /*severe:StaticTypeError*/ns;
 
         // M<T> <: L<S> iff T <: S
-        mOfCs = /*info:DownCast*/lOfAs;
+        mOfCs = /*warning:DownCastComposite*/lOfAs;
         mOfCs = /*severe:StaticTypeError*/lOfBs;
-        mOfCs = /*info:DownCast*/lOfCs;
+        mOfCs = /*warning:DownCastComposite*/lOfCs;
 
         // M<T> <: M<S> iff T :< S
-        mOfCs = /*info:DownCast*/mOfAs;
+        mOfCs = /*warning:DownCastComposite*/mOfAs;
         mOfCs = /*severe:StaticTypeError*/mOfBs;
         mOfCs = mOfCs;
 
         // N </: L<C>
         mOfCs = /*severe:StaticTypeError*/ns;
 
         // Concrete subclass subtyping
-        ns = /*info:DownCast*/lOfAs;
+        ns = /*warning:DownCastImplicit*/lOfAs;
         ns = /*severe:StaticTypeError*/lOfBs;
         ns = /*severe:StaticTypeError*/lOfCs;
-        ns = /*info:DownCast*/mOfAs;
+        ns = /*warning:DownCastImplicit*/mOfAs;
         ns = /*severe:StaticTypeError*/mOfBs;
         ns = /*severe:StaticTypeError*/mOfCs;
         ns = ns;
       }
    '''
     }, covariantGenerics: true, relaxedCasts: false);
   });
 
   test('Relaxed casts', () {
     testChecker({
@@ skipping 31 matching lines @@
         }
         {
           lOfOs = mOfDs;
           lOfOs = mOfOs;
           lOfOs = mOfAs;
           lOfOs = lOfDs;
           lOfOs = lOfOs;
           lOfOs = lOfAs;
         }
         {
-          lOfAs = /*warning:DownCastDynamic*/mOfDs;
+          lOfAs = /*warning:DownCastComposite*/mOfDs;
           lOfAs = /*severe:StaticTypeError*/mOfOs;
           lOfAs = mOfAs;
-          lOfAs = /*warning:DownCastDynamic*/lOfDs;
-          lOfAs = /*info:DownCast*/lOfOs;
+          lOfAs = /*warning:DownCastComposite*/lOfDs;
+          lOfAs = /*warning:DownCastComposite*/lOfOs;
           lOfAs = lOfAs;
         }
         {
           mOfDs = mOfDs;
           mOfDs = mOfOs;
           mOfDs = mOfAs;
-          mOfDs = /*info:DownCast*/lOfDs;
-          mOfDs = /*info:DownCast*/lOfOs;
-          mOfDs = /*info:DownCast*/lOfAs;
+          mOfDs = /*warning:DownCastImplicit*/lOfDs;
+          mOfDs = /*warning:DownCastImplicit*/lOfOs;
+          mOfDs = /*warning:DownCastImplicit*/lOfAs;
         }
         {
           mOfOs = mOfDs;
           mOfOs = mOfOs;
           mOfOs = mOfAs;
-          mOfOs = /*info:DownCast*/lOfDs;
-          mOfOs = /*info:DownCast*/lOfOs;
+          mOfOs = /*warning:DownCastImplicit*/lOfDs;
+          mOfOs = /*warning:DownCastImplicit*/lOfOs;
           mOfOs = /*severe:StaticTypeError*/lOfAs;
         }
         {
-          mOfAs = /*warning:DownCastDynamic*/mOfDs;
-          mOfAs = /*info:DownCast*/mOfOs;
+          mOfAs = /*warning:DownCastComposite*/mOfDs;
+          mOfAs = /*warning:DownCastComposite*/mOfOs;
           mOfAs = mOfAs;
-          mOfAs = /*info:DownCast*/lOfDs;
-          mOfAs = /*info:DownCast*/lOfOs;
-          mOfAs = /*info:DownCast*/lOfAs;
+          mOfAs = /*warning:DownCastComposite*/lOfDs;
+          mOfAs = /*warning:DownCastComposite*/lOfOs;
+          mOfAs = /*warning:DownCastComposite*/lOfAs;
         }
 
       }
    '''
     }, covariantGenerics: true, relaxedCasts: true);
   });
 
   test('Subtyping literals', () {
     testChecker({
       '/main.dart': '''
           test() {
             Iterable i1 = [1, 2, 3];
             i1 = <int>[1, 2, 3];
 
             List l1 = [1, 2, 3];
             l1 = <int>[1, 2, 3];
 
-            Iterable<int> i2 = /*warning:DownCastLiteral*/[1, 2, 3];
-            i2 = /*warning:DownCastDynamic*/i1;
-            i2 = /*warning:DownCastDynamic*/l1;
+            Iterable<int> i2 = /*warning:InferableLiteral*/[1, 2, 3];
+            i2 = /*warning:DownCastComposite*/i1;
+            i2 = /*warning:DownCastComposite*/l1;
             i2 = <int>[1, 2, 3];
 
-            List<int> l2 = /*warning:DownCastLiteral*/[1, 2, 3];
-            l2 = /*info:DownCast*/i1;
-            l2 = /*warning:DownCastDynamic*/l1;
+            List<int> l2 = /*warning:InferableLiteral*/[1, 2, 3];
+            l2 = /*warning:DownCastComposite*/i1;
+            l2 = /*warning:DownCastComposite*/l1;
 
-            l2 = /*warning:DownCastExact*/new List();
-            l2 = /*warning:DownCastExact*/new List(10);
-            l2 = /*warning:DownCastExact*/new List.filled(10, 42);
+            l2 = /*warning:InferableAllocation*/new List();
+            l2 = /*warning:InferableAllocation*/new List(10);
+            l2 = /*warning:InferableAllocation*/new List.filled(10, 42);
           }
    '''
     });
   });
 
   test('Type checking literals', () {
     testChecker({
       '/main.dart': '''
           test() {
             num n = 3;
             int i = 3;
             String s = "hello";
             {
                List<int> l = <int>[i];
                l = <int>[/*severe:StaticTypeError*/s];
-               l = <int>[/*info:DownCast*/n];
-               l = <int>[i, /*info:DownCast*/n, /*severe:StaticTypeError*/s];
+               l = <int>[/*warning:DownCastImplicit*/n];
+               l = <int>[i, /*warning:DownCastImplicit*/n, /*severe:StaticTypeError*/s];
             }
             {
                List l = [i];
                l = [s];
                l = [n];
                l = [i, n, s];
             }
             {
                Map<String, int> m = <String, int>{s: i};
                m = <String, int>{s: /*severe:StaticTypeError*/s};
-               m = <String, int>{s: /*info:DownCast*/n};
+               m = <String, int>{s: /*warning:DownCastImplicit*/n};
                m = <String, int>{s: i,
-                                 s: /*info:DownCast*/n,
+                                 s: /*warning:DownCastImplicit*/n,
                                  s: /*severe:StaticTypeError*/s};
             }
            // TODO(leafp): We can't currently test for key errors since the
            // error marker binds to the entire entry.
             {
                Map m = {s: i};
                m = {s: s};
                m = {s: n};
                m = {s: i,
                     s: n,
                     s: s};
                m = {i: s,
                     n: s,
                     s: s};
             }
           }
    '''
     });
   });
 
   test('casts in constant contexts', () {
-    String mk(String error) => '''
+    String mk(String error1, String error2) => '''
           class A {
             static const num n = 3.0;
-            static const int i = /*$error*/n;
+            static const int i = /*$error2*/n;
             final int fi;
-            const A(num a) : this.fi = /*$error*/a;
+            const A(num a) : this.fi = /*$error1*/a;
           }
           class B extends A {
-            const B(Object a) : super(/*$error*/a);
+            const B(Object a) : super(/*$error1*/a);
           }
           void foo(Object o) {
-            var a = const A(/*$error*/o);
+            var a = const A(/*$error1*/o);
           }
      ''';
-    testChecker({'/main.dart': mk("severe:StaticTypeError")},
+    testChecker(
+        {'/main.dart': mk("severe:StaticTypeError", "severe:StaticTypeError")},
         allowConstCasts: false);
-    testChecker({'/main.dart': mk("info:DownCast")}, allowConstCasts: true);
+    testChecker(
+        {'/main.dart': mk("warning:DownCastImplicit", "info:AssignmentCast")},
+        allowConstCasts: true);
   });
 
   test('casts in conditionals', () {
     testChecker({
       '/main.dart': '''
           main() {
             bool b = true;
             num x = b ? 1 : 2.3;
-            int y = /*info:DownCast*/b ? 1 : 2.3;
+            int y = /*info:AssignmentCast*/b ? 1 : 2.3;
             String z = !b ? "hello" : null;
             z = b ? null : "hello";
           }
       '''
     });
   });
 
   test('redirecting constructor', () {
     testChecker({
       '/main.dart': '''
@@ skipping 239 matching lines @@
             A operator -(B b) {}
           }
 
           foo() => new A();
 
           test() {
             A a = new A();
             B b = new B();
             var c = foo();
             a = a * b;
-            a = a * /*pass should be info:DownCast*/c;
+            a = a * /*pass should be warning:DownCastImplicit*/c;
             a = a / b;
             a = a ~/ b;
             a = a % b;
             a = a + b;
             a = a + /*pass should be severe:StaticTypeError*/a;
             a = a - b;
             b = /*severe:StaticTypeError*/b - b;
             a = a << b;
             a = a >> b;
             a = a & b;
@@ skipping 34 matching lines @@
             (/*severe:StaticTypeError*/x += 3.14);
 
             double y = 0.0;
             y += 5;
             y += 3.14;
 
             num z = 0;
             z += 5;
             z += 3.14;
 
-            x = /*info:DownCast*/x + z;
-            x += /*info:DownCast*/z;
-            y = /*info:DownCast*/y + z;
-            y += /*info:DownCast*/z;
+            x = /*warning:DownCastImplicit*/x + z;
+            x += /*warning:DownCastImplicit*/z;
+            y = /*warning:DownCastImplicit*/y + z;
+            y += /*warning:DownCastImplicit*/z;
 
             dynamic w = 42;
-            x += /*info:DownCast*/w;
-            y += /*info:DownCast*/w;
-            z += /*info:DownCast*/w;
+            x += /*info:DynamicCast*/w;
+            y += /*info:DynamicCast*/w;
+            z += /*info:DynamicCast*/w;
 
             A a = new A();
             B b = new B();
             var c = foo();
             a = a * b;
             a *= b;
-            a *= /*info:DownCast*/c;
+            a *= /*info:DynamicCast*/c;
             a /= b;
             a ~/= b;
             a %= b;
             a += b;
             a += /*severe:StaticTypeError*/a;
             a -= b;
             (/*severe:StaticTypeError*/b -= b);
             a <<= b;
             a >>= b;
             a &= b;
@@ skipping 876 matching lines @@
             f = bar as II2D;
             f = bar as DD2I;
             f = bar as DI2D;
             f = bar as ID2D;
             f = bar as DD2D;
           }
       '''
     });
   });
 }