Make implicit casts hints

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:test/test.dart';
 
 import '../testing.dart';
@@ skipping 25 matching lines @@
               _v = /*info:InferredType should be pass*/(isValidKey != null) ? _v : ((v) => true);
           }
         }
         void main() {
           Object obj = 42;
           dynamic dyn = 42;
           int i = 42;
 
           // Check the boolean conversion of the condition.
           print((/*severe:StaticTypeError*/i) ? false : true);
-          print((/*warning:DownCastImplicit*/obj) ? false : true);
+          print((/*info:DownCastImplicit*/obj) ? false : true);
           print((/*info:DynamicCast*/dyn) ? false : true);
         }
       '''
   });
 
   testChecker('if/for/do/while statements use boolean conversion', {
     '/main.dart': '''
       main() {
         dynamic d = 42;
         Object obj = 42;
         int i = 42;
         bool b = false;
 
         if (b) {}
         if (/*info:DynamicCast*/dyn) {}
-        if (/*warning:DownCastImplicit*/obj) {}
+        if (/*info:DownCastImplicit*/obj) {}
         if (/*severe:StaticTypeError*/i) {}
 
         while (b) {}
         while (/*info:DynamicCast*/dyn) {}
-        while (/*warning:DownCastImplicit*/obj) {}
+        while (/*info:DownCastImplicit*/obj) {}
         while (/*severe:StaticTypeError*/i) {}
 
         do {} while (b);
         do {} while (/*info:DynamicCast*/dyn);
-        do {} while (/*warning:DownCastImplicit*/obj);
+        do {} while (/*info:DownCastImplicit*/obj);
         do {} while (/*severe:StaticTypeError*/i);
 
         for (;b;) {}
         for (;/*info:DynamicCast*/dyn;) {}
-        for (;/*warning:DownCastImplicit*/obj;) {}
+        for (;/*info:DownCastImplicit*/obj;) {}
         for (;/*severe:StaticTypeError*/i;) {}
       }
     '''
   });
 
   testChecker('dynamic invocation', {
     '/main.dart': '''
 
       class A {
         dynamic call(dynamic x) => x;
@@ skipping 143 matching lines @@
 
         void main() {
           int /*severe:InvalidVariableDeclaration*/x;
           double /*severe:InvalidVariableDeclaration*/y;
           num z;
           bool b;
 
           // int is non-nullable
           x = /*severe:StaticTypeError*/null;
           x = 42;
-          x = /*warning:DownCastImplicit*/z;
+          x = /*info:DownCastImplicit*/z;
 
           // double is non-nullable
           y = /*severe:StaticTypeError*/null;
           y = /*severe:StaticTypeError*/42;
           y = 42.0;
-          y = /*warning:DownCastImplicit*/z;
+          y = /*info:DownCastImplicit*/z;
 
           // num is nullable
           z = null;
           z = x;
           z = y;
 
           // bool is nullable
           b = null;
           b = true;
         }
       '''
   }, nonnullableTypes: <String>[
     'int',
     'double'
   ]);
 
   testChecker('Primitives and generics', {
     '/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:DownCastImplicit*/null;
+          T foo() => /*info: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 = /*warning:DownCastImplicit*/null]) {
+          void baz(T x, [T /*severe:InvalidVariableDeclaration*/y, T z = /*info:DownCastImplicit*/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:DownCastImplicit*/null;
+          T foo() => /*info:DownCastImplicit*/null;
         }
       '''
   }, nonnullableTypes: <String>[
     'int',
     'double'
   ]);
 
   testChecker('Constructors', {
     '/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 = /*warning:DownCastImplicit*/z, this.y = /*info:DynamicCast*/p;
+        A.c1(p): this.x = /*info: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, /*warning:DownCastImplicit*/y);
+        B.c3(num x, Object y) : super.c3(x, /*info:DownCastImplicit*/y);
       }
 
       void main() {
-         A a = new A.c2(/*warning:DownCastImplicit*/z, /*severe:StaticTypeError*/z);
-         var b = new B.c2(/*severe:StaticTypeError*/"hello", /*warning:DownCastImplicit*/obj);
+         A a = new A.c2(/*info:DownCastImplicit*/z, /*severe:StaticTypeError*/z);
+         var b = new B.c2(/*severe:StaticTypeError*/"hello", /*info:DownCastImplicit*/obj);
       }
    '''
   });
 
   testChecker('Unbound variable', {
     '/main.dart': '''
       void main() {
          dynamic y = /*pass should be severe:StaticTypeError*/unboundVariable;
       }
    '''
@@ skipping 68 matching lines @@
          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 = /*warning:DownCastImplicit*/a;
+         b = /*info:DownCastImplicit*/a;
       }
    '''
   });
 
   testChecker('Ground type subtyping: assigning a subclass', {
     '/main.dart': '''
 
       class A {}
       class B extends A {}
       class C extends A {}
@@ skipping 32 matching lines @@
          B left;
          C right;
          D bot;
          {
            top = top;
            top = left;
            top = right;
            top = bot;
          }
          {
-           left = /*warning:DownCastImplicit*/top;
+           left = /*info:DownCastImplicit*/top;
            left = left;
            left = /*severe:StaticTypeError*/right;
            left = bot;
          }
          {
-           right = /*warning:DownCastImplicit*/top;
+           right = /*info:DownCastImplicit*/top;
            right = /*severe:StaticTypeError*/left;
            right = right;
            right = bot;
          }
          {
-           bot = /*warning:DownCastImplicit*/top;
-           bot = /*warning:DownCastImplicit*/left;
-           bot = /*warning:DownCastImplicit*/right;
+           bot = /*info:DownCastImplicit*/top;
+           bot = /*info:DownCastImplicit*/left;
+           bot = /*info:DownCastImplicit*/right;
            bot = bot;
          }
       }
    '''
   });
 
   testChecker('Function typing and subtyping: int and object', {
     '/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) => /*warning:DownCastImplicit*/x;
+      int _bot(Object x) => /*info:DownCastImplicit*/x;
       int bot(Object x) => x as int;
 
       void main() {
         { // Check typedef equality
           Left f = left;
           Left2 g = f;
         }
         {
           Top f;
           f = top;
@@ skipping 32 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) => /*warning:DownCastImplicit*/x;
+      B _bot(A x) => /*info: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 416 matching lines @@
            f = n2n;
            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 = /*warning:DownCastImplicit*/i2i as Object;
-           f = /*warning:DownCastImplicit*/n2n as Function;
+           f = /*info:DownCastImplicit*/i2i as Object;
+           f = /*info:DownCastImplicit*/n2n as Function;
          }
          {
            B f;
            f = /*severe:StaticTypeError*/new A();
            f = new B();
            f = /*severe:StaticTypeError*/i2i;
            f = /*severe:StaticTypeError*/n2n;
-           f = /*warning:DownCastImplicit*/i2i as Object;
-           f = /*warning:DownCastImplicit*/n2n as Function;
+           f = /*info:DownCastImplicit*/i2i as Object;
+           f = /*info:DownCastImplicit*/n2n as Function;
          }
          {
            Function f;
            f = new A();
            f = new B();
            f = i2i;
            f = n2n;
-           f = /*warning:DownCastImplicit*/i2i as Object;
+           f = /*info:DownCastImplicit*/i2i as Object;
            f = (n2n as Function);
          }
       }
    '''
   });
 
   testChecker('Function typing and subtyping: void', {
     '/main.dart': '''
 
       class A {
@@ skipping 99 matching lines @@
 
         // M<T> <: M<S> iff T :< S
         mOfCs = /*warning:DownCastComposite*/mOfAs;
         mOfCs = /*severe:StaticTypeError*/mOfBs;
         mOfCs = mOfCs;
 
         // N </: L<C>
         mOfCs = /*severe:StaticTypeError*/ns;
 
         // Concrete subclass subtyping
-        ns = /*warning:DownCastImplicit*/lOfAs;
+        ns = /*info:DownCastImplicit*/lOfAs;
         ns = /*severe:StaticTypeError*/lOfBs;
         ns = /*severe:StaticTypeError*/lOfCs;
-        ns = /*warning:DownCastImplicit*/mOfAs;
+        ns = /*info:DownCastImplicit*/mOfAs;
         ns = /*severe:StaticTypeError*/mOfBs;
         ns = /*severe:StaticTypeError*/mOfCs;
         ns = ns;
       }
    '''
       },
       relaxedCasts: false);
 
   testChecker(
       'Relaxed casts',
@@ skipping 43 matching lines @@
           lOfAs = /*severe:StaticTypeError*/mOfOs;
           lOfAs = mOfAs;
           lOfAs = /*warning:DownCastComposite*/lOfDs;
           lOfAs = /*warning:DownCastComposite*/lOfOs;
           lOfAs = lOfAs;
         }
         {
           mOfDs = mOfDs;
           mOfDs = mOfOs;
           mOfDs = mOfAs;
-          mOfDs = /*warning:DownCastImplicit*/lOfDs;
-          mOfDs = /*warning:DownCastImplicit*/lOfOs;
-          mOfDs = /*warning:DownCastImplicit*/lOfAs;
+          mOfDs = /*info:DownCastImplicit*/lOfDs;
+          mOfDs = /*info:DownCastImplicit*/lOfOs;
+          mOfDs = /*info:DownCastImplicit*/lOfAs;
         }
         {
           mOfOs = mOfDs;
           mOfOs = mOfOs;
           mOfOs = mOfAs;
-          mOfOs = /*warning:DownCastImplicit*/lOfDs;
-          mOfOs = /*warning:DownCastImplicit*/lOfOs;
+          mOfOs = /*info:DownCastImplicit*/lOfDs;
+          mOfOs = /*info:DownCastImplicit*/lOfOs;
           mOfOs = /*severe:StaticTypeError*/lOfAs;
         }
         {
           mOfAs = /*warning:DownCastComposite*/mOfDs;
           mOfAs = /*warning:DownCastComposite*/mOfOs;
           mOfAs = mOfAs;
           mOfAs = /*warning:DownCastComposite*/lOfDs;
           mOfAs = /*warning:DownCastComposite*/lOfOs;
           mOfAs = /*warning:DownCastComposite*/lOfAs;
         }
@@ skipping 32 matching lines @@
 
   testChecker('Type checking literals', {
     '/main.dart': '''
           test() {
             num n = 3;
             int i = 3;
             String s = "hello";
             {
                List<int> l = <int>[i];
                l = <int>[/*severe:StaticTypeError*/s];
-               l = <int>[/*warning:DownCastImplicit*/n];
-               l = <int>[i, /*warning:DownCastImplicit*/n, /*severe:StaticTypeError*/s];
+               l = <int>[/*info:DownCastImplicit*/n];
+               l = <int>[i, /*info: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: /*warning:DownCastImplicit*/n};
+               m = <String, int>{s: /*info:DownCastImplicit*/n};
                m = <String, int>{s: i,
-                                 s: /*warning:DownCastImplicit*/n,
+                                 s: /*info: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};
             }
           }
    '''
   });
 
   testChecker('casts in constant contexts', {
     '/main.dart': '''
           class A {
             static const num n = 3.0;
             static const int i = /*info:AssignmentCast*/n;
             final int fi;
-            const A(num a) : this.fi = /*warning:DownCastImplicit*/a;
+            const A(num a) : this.fi = /*info:DownCastImplicit*/a;
           }
           class B extends A {
-            const B(Object a) : super(/*warning:DownCastImplicit*/a);
+            const B(Object a) : super(/*info:DownCastImplicit*/a);
           }
           void foo(Object o) {
-            var a = const A(/*warning:DownCastImplicit*/o);
+            var a = const A(/*info:DownCastImplicit*/o);
           }
      '''
   });
 
   testChecker('casts in conditionals', {
     '/main.dart': '''
           main() {
             bool b = true;
             num x = b ? 1 : 2.3;
             int y = /*info:AssignmentCast*/b ? 1 : 2.3;
@@ skipping 364 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 = /*warning:DownCastImplicit*/x + z;
-            x += /*warning:DownCastImplicit*/z;
-            y = /*warning:DownCastImplicit*/y + z;
-            y += /*warning:DownCastImplicit*/z;
+            x = /*info:DownCastImplicit*/x + z;
+            x += /*info:DownCastImplicit*/z;
+            y = /*info:DownCastImplicit*/y + z;
+            y += /*info:DownCastImplicit*/z;
 
             dynamic w = 42;
             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;
@@ skipping 933 matching lines @@
         num myMax(num x, num y) => max(x, y);
 
         main() {
           // Okay if static types match.
           printInt(max(1, 2));
           printInt(min(1, 2));
           printDouble(max(1.0, 2.0));
           printDouble(min(1.0, 2.0));
 
           // No help for user-defined functions from num->num->num.
-          printInt(/*warning:DownCastImplicit*/myMax(1, 2));
+          printInt(/*info:DownCastImplicit*/myMax(1, 2));
           printInt(myMax(1, 2) as int);
 
           // Mixing int and double means return type is num.
-          printInt(/*warning:DownCastImplicit*/max(1, 2.0));
-          printInt(/*warning:DownCastImplicit*/min(1, 2.0));
-          printDouble(/*warning:DownCastImplicit*/max(1, 2.0));
-          printDouble(/*warning:DownCastImplicit*/min(1, 2.0));
+          printInt(/*info:DownCastImplicit*/max(1, 2.0));
+          printInt(/*info:DownCastImplicit*/min(1, 2.0));
+          printDouble(/*info:DownCastImplicit*/max(1, 2.0));
+          printDouble(/*info:DownCastImplicit*/min(1, 2.0));
 
           // Types other than int and double are not accepted.
           printInt(
-              /*warning:DownCastImplicit*/min(
+              /*info:DownCastImplicit*/min(
                   /*severe:StaticTypeError*/"hi",
                   /*severe:StaticTypeError*/"there"));
         }
     '''
     });
   });
 }