Rationalize coercions

test/checker/inferred_type_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.
 
 /// Tests for type inference.
 library dev_compiler.test.inferred_type_test;
 
 import 'package:unittest/unittest.dart';
 
 import 'package:dev_compiler/src/testing.dart';
@@ skipping 23 matching lines @@
       }
     '''
     });
   });
 
   // Error when declared type is `int` and assigned null.
   testChecker({
     '/main.dart': '''
       test1() {
         int x = 3;
-        x = /*warning:DownCastLiteral*/null;
+        x = /*severe:StaticTypeError*/null;
       }
     '''
   }, nonnullableTypes: <String>['int', 'double']);
 
   // Error when inferred type is `int` and assigned null.
   testChecker({
     '/main.dart': '''
       test1() {
         var x = 3;
-        x = /*warning:DownCastLiteral*/null;
+        x = /*severe:StaticTypeError*/null;
       }
     '''
   }, nonnullableTypes: <String>['int', 'double']);
 
   // No error when declared type is `num` and assigned null.
   testChecker({
     '/main.dart': '''
       test1() {
         num x = 3;
         x = null;
@@ skipping 195 matching lines @@
           import 'main.dart';
           var x = 2; // ok to infer
       ''',
       '/main.dart': '''
           import 'a.dart';
           var y = x; // not ok to infer yet
 
           test1() {
             int t = 3;
             t = x;
-            t = /*info:DownCast*/y;
+            t = /*info:DynamicCast*/y;
           }
     '''
     }, inferTransitively: false);
 
     testChecker({
       '/a.dart': '''
           import 'main.dart';
           class A { static var x = 2; }
       ''',
       '/main.dart': '''
           import 'a.dart';
           class B { static var y = A.x; }
 
           test1() {
             int t = 3;
             t = A.x;
-            t = /*info:DownCast*/B.y;
+            t = /*info:DynamicCast*/B.y;
           }
     '''
     }, inferTransitively: false);
   });
 
   test('infer from variables in cycle libs when flag is on', () {
     testChecker({
       '/a.dart': '''
           import 'main.dart';
           var x = 2; // ok to infer
@@ skipping 42 matching lines @@
             static final b1 = 1;
             final b2 = 1;
           }
       ''',
       '/main.dart': '''
           import "a.dart";
 
           test1() {
             int x = 0;
             // inference in A disabled (flag is off)
-            x = /*info:DownCast*/A.a1;
-            x = /*info:DownCast*/new A().a2;
+            x = /*info:DynamicCast*/A.a1;
+            x = /*info:DynamicCast*/new A().a2;
           }
     '''
     }, inferTransitively: false);
   });
 
   test('can infer also from static and instance fields (flag on)', () {
     testChecker({
       '/a.dart': '''
           import 'b.dart';
           class A {
@@ skipping 83 matching lines @@
             x = A.a1;
             x = new A().a2;
 
             // Within a cycle we allow inference when the RHS is well known, but
             // not when it depends on other fields within the cycle
             x = C.c1;
             x = D.d1;
             x = D.d2;
             x = new C().c2;
             x = new D().d3;
-            x = /*info:DownCast*/new D().d4;
+            x = /*info:DynamicCast*/new D().d4;
 
 
             // Similarly if the library contains parts.
             x = E.e1;
             x = E.e2;
             x = E.e3;
             x = new E().e4;
-            x = /*info:DownCast*/new E().e5;
+            x = /*info:DynamicCast*/new E().e5;
             x = new E().e6;
             x = F.f1;
             x = new F().f2;
           }
     '''
     }, inferTransitively: true);
   });
 
   test('infer from complex expressions if the outer-most value is precise', () {
     testChecker({
@@ skipping 58 matching lines @@
         final t1 = new A();
         final t2 = new A().x;
         final t3 = new B();
         final t4 = new B().y;
 
         test1() {
           int i = 0;
           A a;
           B b;
           a = t1;
-          i = /*info:DownCast*/t2;
+          i = /*info:DynamicCast*/t2;
           b = t3;
-          i = /*info:DownCast*/t4;
+          i = /*info:DynamicCast*/t4;
           i = new B().y; // B.y was inferred though
         }
     '''
     }, inferTransitively: false);
 
     // but flags can enable this behavior.
     testChecker({
       '/a.dart': '''
         class A {
           var x = 3;
         }
       ''',
       '/main.dart': '''
         import 'a.dart';
         class B {
           var y = 3;
         }
         final t1 = new A();
         final t2 = new A().x;
         final t3 = new B();
         final t4 = new B().y;
 
         test1() {
           int i = 0;
           A a;
           B b;
           a = t1;
           i = t2;
           b = t3;
-          i = /*info:DownCast*/t4;
+          i = /*info:DynamicCast*/t4;
           i = new B().y; // B.y was inferred though
         }
     '''
     }, inferTransitively: true);
   });
 
   test('infer types on loop indices', () {
     // foreach loop
     testChecker({
       '/main.dart': '''
       class Foo {
         int bar = 42;
       }
 
       test() {
         var l = List<Foo>();
         for (var x in list) {
-          String y = /*info:DownCast should be severe:StaticTypeError*/x;
+          String y = /*info:DynamicCast should be severe:StaticTypeError*/x;
         }
       }
       '''
     });
 
     // for loop, with inference
     testChecker({
       '/main.dart': '''
       test() {
         for (var i = 0; i < 10; i++) {
@@ skipping 22 matching lines @@
 
     // Same code with dynamic yields warnings
     testChecker({
       '/main.dart': '''
       class A {
         int x = 2;
       }
 
       test() {
         dynamic a = new A();
-        A b = /*info:DownCast*/a;
+        A b = /*info:DynamicCast*/a;
         print(/*warning:DynamicInvoke*/a.x);
         print((/*warning:DynamicInvoke*/a.x) + 2);
       }
     '''
     });
   });
 
   test('propagate inference transitively ', () {
     testChecker({
       '/main.dart': '''
@@ skipping 45 matching lines @@
       '/main.dart': '''
         class A {
           int x = 2;
         }
 
         class B extends A {
           /*severe:InferableOverride*/get x => 3;
         }
 
         foo() {
-          String y = /*info:DownCast*/new B().x;
-          int z = /*info:DownCast*/new B().x;
+          String y = /*info:DynamicCast*/new B().x;
+          int z = /*info:DynamicCast*/new B().x;
         }
     '''
     }, inferFromOverrides: false);
 
     testChecker({
       '/main.dart': '''
         class A {
           int x = 2;
         }
 
@@ skipping 12 matching lines @@
       '/main.dart': '''
         class A {
           int x = 2;
         }
 
         class B implements A {
           /*severe:InferableOverride*/get x => 3;
         }
 
         foo() {
-          String y = /*info:DownCast*/new B().x;
-          int z = /*info:DownCast*/new B().x;
+          String y = /*info:DynamicCast*/new B().x;
+          int z = /*info:DynamicCast*/new B().x;
         }
     '''
     }, inferFromOverrides: false);
 
     testChecker({
       '/main.dart': '''
         class A {
           int x = 2;
         }
 
@@ skipping 15 matching lines @@
         '/main.dart': '''
           class A<T> {
             T x;
           }
 
           class B implements A<int> {
             /*severe:InvalidMethodOverride*/dynamic get x => 3;
           }
 
           foo() {
-            String y = /*info:DownCast*/new B().x;
-            int z = /*info:DownCast*/new B().x;
+            String y = /*info:DynamicCast*/new B().x;
+            int z = /*info:DynamicCast*/new B().x;
           }
       '''
       }, inferFromOverrides: infer);
     }
 
     testChecker({
       '/main.dart': '''
         class A<T> {
           T x;
         }
 
         class B implements A<int> {
           /*severe:InferableOverride*/get x => 3;
         }
 
         foo() {
-          String y = /*info:DownCast*/new B().x;
-          int z = /*info:DownCast*/new B().x;
+          String y = /*info:DynamicCast*/new B().x;
+          int z = /*info:DynamicCast*/new B().x;
         }
     '''
     }, inferFromOverrides: false);
     testChecker({
       '/main.dart': '''
         class A<T> {
           T x;
           T w;
         }
 
@@ skipping 125 matching lines @@
         '/main.dart': '''
           class A {
             int x = 2;
           }
 
           class B implements A {
             /*severe:InvalidMethodOverride*/dynamic get x => 3;
           }
 
           foo() {
-            String y = /*info:DownCast*/new B().x;
-            int z = /*info:DownCast*/new B().x;
+            String y = /*info:DynamicCast*/new B().x;
+            int z = /*info:DynamicCast*/new B().x;
           }
       '''
       }, inferFromOverrides: infer);
     }
   });
 
   test('conflicts can happen', () {
     testChecker({
       '/main.dart': '''
         class I1 {
@@ skipping 60 matching lines @@
       '/main.dart': '''
         class A {
           var x;
         }
 
         class B extends A {
           var x = 2;
         }
 
         foo() {
-          String y = /*info:DownCast*/new B().x;
-          int z = /*info:DownCast*/new B().x;
+          String y = /*info:DynamicCast*/new B().x;
+          int z = /*info:DynamicCast*/new B().x;
         }
     '''
     }, inferFromOverrides: true);
 
     testChecker({
       '/main.dart': '''
         class A {
           final x;
         }
 
@@ skipping 17 matching lines @@
         }
 
         class B extends A {
           var x = 2, y = 3, z, w = 2;
         }
 
         foo() {
           String s;
           int i;
 
-          s = /*info:DownCast*/new B().x;
+          s = /*info:DynamicCast*/new B().x;
           s = /*severe:StaticTypeError*/new B().y;
           s = new B().z;
           s = /*severe:StaticTypeError*/new B().w;
 
-          i = /*info:DownCast*/new B().x;
+          i = /*info:DynamicCast*/new B().x;
           i = new B().y;
           i = /*severe:StaticTypeError*/new B().z;
           i = new B().w;
         }
     '''
     }, inferFromOverrides: true);
   });
 
   test('infer consts transitively', () {
     testChecker({
@@ skipping 99 matching lines @@
           static final T foo = m1(m2(m3('', '')));
           static T m1(String m) { return null; }
           static String m2(e) { return ''; }
         }
 
 
     '''
     }, inferFromOverrides: true, inferTransitively: true);
   });
 }