Revert "Revert "Refactor strong mode to use standard Analyzer errors""

pkg/analyzer/test/src/task/strong/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.
 
-// TODO(jmesserly): this file needs to be refactored, it's a port from
-// package:dev_compiler's tests
-/// General type checking tests
 library analyzer.test.src.task.strong.checker_test;
 
 import '../../../reflective_tests.dart';
 import 'strong_test_helper.dart';
 
 void main() {
   initStrongModeTests();
   runReflectiveTests(CheckerTest);
 }
 
 @reflectiveTest
 class CheckerTest {
   void test_awaitForInCastsStreamElementToVariable() {
     checkFile('''
 import 'dart:async';
 main() async {
   // Don't choke if sequence is not stream.
-  await for (var i in /*warning:FOR_IN_OF_INVALID_TYPE*/1234) {}
+  await for (var i in /*severe:FOR_IN_OF_INVALID_TYPE*/1234) {}
 
   // Dynamic cast.
   await for (String /*info:DYNAMIC_CAST*/s in new Stream<dynamic>()) {}
 
   // Identity cast.
   await for (String s in new Stream<String>()) {}
 
   // Untyped.
   await for (var s in new Stream<String>()) {}
 
@@ skipping 43 matching lines @@
   B b = new B();
   var c = foo();
   a = a * b;
   a = a * /*info:DYNAMIC_CAST*/c;
   a = a / b;
   a = a ~/ b;
   a = a % b;
   a = a + b;
   a = a + /*warning:ARGUMENT_TYPE_NOT_ASSIGNABLE*/a;
   a = a - b;
-  b = /*warning:INVALID_ASSIGNMENT*/b - b;
+  b = /*severe:INVALID_ASSIGNMENT*/b - b;
   a = a << b;
   a = a >> b;
   a = a & b;
   a = a ^ b;
   a = a | b;
   c = (/*info:DYNAMIC_INVOKE*/c + b);
 
   String x = 'hello';
   int y = 42;
   x = x + x;
   x = x + /*info:DYNAMIC_CAST*/c;
   x = x + /*warning:ARGUMENT_TYPE_NOT_ASSIGNABLE*/y;
 
   bool p = true;
   p = p && p;
   p = p && /*info:DYNAMIC_CAST*/c;
   p = (/*info:DYNAMIC_CAST*/c) && p;
   p = (/*info:DYNAMIC_CAST*/c) && /*info:DYNAMIC_CAST*/c;
-  p = /*warning:NON_BOOL_OPERAND*/y && p;
+  p = /*severe:NON_BOOL_OPERAND*/y && p;
   p = c == y;
 
   a = a[b];
   a = a[/*info:DYNAMIC_CAST*/c];
   c = (/*info:DYNAMIC_INVOKE*/c[b]);
   a[/*warning:ARGUMENT_TYPE_NOT_ASSIGNABLE*/y];
 }
 ''');
   }
 
@@ skipping 173 matching lines @@
   var c = foo();
   a = a * b;
   a *= b;
   a *= /*info:DYNAMIC_CAST*/c;
   a /= b;
   a ~/= b;
   a %= b;
   a += b;
   a += /*warning:ARGUMENT_TYPE_NOT_ASSIGNABLE*/a;
   a -= b;
-  /*severe:STATIC_TYPE_ERROR*/b -= /*warning:INVALID_ASSIGNMENT*/b;
+  /*severe:STATIC_TYPE_ERROR*/b -= /*severe:INVALID_ASSIGNMENT*/b;
   a <<= b;
   a >>= b;
   a &= b;
   a ^= b;
   a |= b;
   /*info:DYNAMIC_INVOKE*/c += b;
 
   var d = new D();
   a[b] += d;
   a[/*info:DYNAMIC_CAST*/c] += d;
@@ skipping 127 matching lines @@
 class B {
   int call(int x) => x;
   double col(double x) => x;
 }
 void main() {
   {
     B f = new B();
     int x;
     double y;
     x = f(3);
-    x = /*warning:INVALID_ASSIGNMENT*/f.col(3.0);
-    y = /*warning:INVALID_ASSIGNMENT*/f(3);
+    x = /*severe:INVALID_ASSIGNMENT*/f.col(3.0);
+    y = /*severe:INVALID_ASSIGNMENT*/f(3);
     y = f.col(3.0);
     f(/*warning:ARGUMENT_TYPE_NOT_ASSIGNABLE*/3.0);
     f.col(/*warning:ARGUMENT_TYPE_NOT_ASSIGNABLE*/3);
   }
   {
     Function f = new B();
     int x;
     double y;
     x = /*info:DYNAMIC_CAST, info:DYNAMIC_INVOKE*/f(3);
     x = /*info:DYNAMIC_CAST, info:DYNAMIC_INVOKE, info:INVALID_ASSIGNMENT*/f.col(3.0);
@@ skipping 14 matching lines @@
   }
   {
     dynamic g = new B();
     /*info:DYNAMIC_INVOKE*/g.call(/*info:ARGUMENT_TYPE_NOT_ASSIGNABLE*/32.0);
     /*info:DYNAMIC_INVOKE*/g.col(42.0);
     /*info:DYNAMIC_INVOKE*/g.foo(42.0);
     /*info:DYNAMIC_INVOKE*/g./*info:UNDEFINED_GETTER*/x;
     A f = new B();
     /*info:DYNAMIC_INVOKE*/f.col(42.0);
     /*info:DYNAMIC_INVOKE*/f.foo(42.0);
-    /*info:DYNAMIC_INVOKE*/f./*warning:UNDEFINED_GETTER*/x;
+    /*info:DYNAMIC_INVOKE*/f./*severe:UNDEFINED_GETTER*/x;
   }
 }
 ''');
   }
 
   void test_factoryConstructorDowncast() {
     checkFile(r'''
 class Animal {
   Animal();
   factory Animal.cat() => new Cat();
@@ skipping 126 matching lines @@
   /*severe:INVALID_METHOD_OVERRIDE*/void set f4(dynamic value) {}
   set f5(B value) {}
 }
 ''');
   }
 
   void test_forInCastsIterateElementToVariable() {
     checkFile('''
 main() {
   // Don't choke if sequence is not iterable.
-  for (var i in /*warning:FOR_IN_OF_INVALID_TYPE*/1234) {}
+  for (var i in /*severe:FOR_IN_OF_INVALID_TYPE*/1234) {}
 
   // Dynamic cast.
   for (String /*info:DYNAMIC_CAST*/s in <dynamic>[]) {}
 
   // Identity cast.
   for (String s in <String>[]) {}
 
   // Untyped.
   for (var s in <String>[]) {}
 
@@ skipping 12 matching lines @@
   Object o;
   for (var i in /*info:DOWN_CAST_IMPLICIT*/o) {}
 }
 ''');
   }
 
   void test_forLoopVariable() {
     checkFile('''
 foo() {
   for (int i = 0; i < 10; i++) {
-    i = /*warning:INVALID_ASSIGNMENT*/"hi";
+    i = /*severe:INVALID_ASSIGNMENT*/"hi";
   }
 }
 bar() {
   for (var i = 0; i < 10; i++) {
     int j = i + 1;
   }
 }
 ''');
   }
 
   void test_functionModifiers_async() {
     checkFile('''
 import 'dart:async';
 import 'dart:math' show Random;
 
 dynamic x;
 
 foo1() async => x;
 Future foo2() async => x;
 Future<int> foo3() async => /*info:DYNAMIC_CAST*/x;
 Future<int> foo4() async => new Future<int>.value(/*info:DYNAMIC_CAST*/x);
 Future<int> foo5() async =>
-    /*warning:RETURN_OF_INVALID_TYPE*/new Future<String>.value(/*info:DYNAMIC_CAST*/x);
+    /*severe:RETURN_OF_INVALID_TYPE*/new Future<String>.value(/*info:DYNAMIC_CAST*/x);
 
 bar1() async { return x; }
 Future bar2() async { return x; }
 Future<int> bar3() async { return /*info:DYNAMIC_CAST*/x; }
 Future<int> bar4() async { return new Future<int>.value(/*info:DYNAMIC_CAST*/x); }
 Future<int> bar5() async {
-  return /*warning:RETURN_OF_INVALID_TYPE*/new Future<String>.value(/*info:DYNAMIC_CAST*/x);
+  return /*severe:RETURN_OF_INVALID_TYPE*/new Future<String>.value(/*info:DYNAMIC_CAST*/x);
 }
 
 int y;
 Future<int> z;
 
 baz() async {
   int a = /*info:DYNAMIC_CAST*/await x;
   int b = await y;
   int c = await z;
-  String d = /*warning:INVALID_ASSIGNMENT*/await z;
+  String d = /*severe:INVALID_ASSIGNMENT*/await z;
 }
 
 Future<bool> get issue_264 async {
   await 42;
   if (new Random().nextBool()) {
     return true;
   } else {
     return new Future<bool>.value(false);
   }
 }
 ''');
   }
 
   void test_functionModifiers_asyncStar() {
     checkFile('''
 import 'dart:async';
 
 dynamic x;
 
 bar1() async* { yield x; }
 Stream bar2() async* { yield x; }
 Stream<int> bar3() async* { yield /*info:DYNAMIC_CAST*/x; }
-Stream<int> bar4() async* { yield /*warning:YIELD_OF_INVALID_TYPE*/new Stream<int>(); }
+Stream<int> bar4() async* { yield /*severe:YIELD_OF_INVALID_TYPE*/new Stream<int>(); }
 
 baz1() async* { yield* /*info:DYNAMIC_CAST*/x; }
 Stream baz2() async* { yield* /*info:DYNAMIC_CAST*/x; }
 Stream<int> baz3() async* { yield* /*warning:DOWN_CAST_COMPOSITE*/x; }
 Stream<int> baz4() async* { yield* new Stream<int>(); }
 Stream<int> baz5() async* { yield* /*info:INFERRED_TYPE_ALLOCATION*/new Stream(); }
 ''');
   }
 
   void test_functionModifiers_syncStar() {
     checkFile('''
 dynamic x;
 
 bar1() sync* { yield x; }
 Iterable bar2() sync* { yield x; }
 Iterable<int> bar3() sync* { yield /*info:DYNAMIC_CAST*/x; }
-Iterable<int> bar4() sync* { yield /*warning:YIELD_OF_INVALID_TYPE*/bar3(); }
+Iterable<int> bar4() sync* { yield /*severe:YIELD_OF_INVALID_TYPE*/bar3(); }
 
 baz1() sync* { yield* /*info:DYNAMIC_CAST*/x; }
 Iterable baz2() sync* { yield* /*info:DYNAMIC_CAST*/x; }
 Iterable<int> baz3() sync* { yield* /*warning:DOWN_CAST_COMPOSITE*/x; }
 Iterable<int> baz4() sync* { yield* bar3(); }
 Iterable<int> baz5() sync* { yield* /*info:INFERRED_TYPE_ALLOCATION*/new List(); }
 ''');
   }
 
   void test_functionTypingAndSubtyping_classes() {
@@ skipping 738 matching lines @@
    FN n;
    FRR rr;
    FRO ro;
    FRN rn;
    FOO oo;
    FNN nn;
    FNNN nnn;
 
    r = r;
    r = o;
-   r = /*warning:INVALID_ASSIGNMENT*/n;
-   r = /*warning:INVALID_ASSIGNMENT*/rr;
+   r = /*severe:INVALID_ASSIGNMENT*/n;
+   r = /*severe:INVALID_ASSIGNMENT*/rr;
    r = ro;
    r = rn;
    r = oo;
-   r = /*warning:INVALID_ASSIGNMENT*/nn;
-   r = /*warning:INVALID_ASSIGNMENT*/nnn;
+   r = /*severe:INVALID_ASSIGNMENT*/nn;
+   r = /*severe:INVALID_ASSIGNMENT*/nnn;
 
    o = /*warning:DOWN_CAST_COMPOSITE*/r;
    o = o;
-   o = /*warning:INVALID_ASSIGNMENT*/n;
-   o = /*warning:INVALID_ASSIGNMENT*/rr;
-   o = /*warning:INVALID_ASSIGNMENT*/ro;
-   o = /*warning:INVALID_ASSIGNMENT*/rn;
+   o = /*severe:INVALID_ASSIGNMENT*/n;
+   o = /*severe:INVALID_ASSIGNMENT*/rr;
+   o = /*severe:INVALID_ASSIGNMENT*/ro;
+   o = /*severe:INVALID_ASSIGNMENT*/rn;
    o = oo;
-   o = /*warning:INVALID_ASSIGNMENT*/nn;
-   o = /*warning:INVALID_ASSIGNMENT*/nnn;
+   o = /*severe:INVALID_ASSIGNMENT*/nn;
+   o = /*severe:INVALID_ASSIGNMENT*/nnn;
 
-   n = /*warning:INVALID_ASSIGNMENT*/r;
-   n = /*warning:INVALID_ASSIGNMENT*/o;
+   n = /*severe:INVALID_ASSIGNMENT*/r;
+   n = /*severe:INVALID_ASSIGNMENT*/o;
    n = n;
-   n = /*warning:INVALID_ASSIGNMENT*/rr;
-   n = /*warning:INVALID_ASSIGNMENT*/ro;
-   n = /*warning:INVALID_ASSIGNMENT*/rn;
-   n = /*warning:INVALID_ASSIGNMENT*/oo;
+   n = /*severe:INVALID_ASSIGNMENT*/rr;
+   n = /*severe:INVALID_ASSIGNMENT*/ro;
+   n = /*severe:INVALID_ASSIGNMENT*/rn;
+   n = /*severe:INVALID_ASSIGNMENT*/oo;
    n = nn;
    n = nnn;
 
-   rr = /*warning:INVALID_ASSIGNMENT*/r;
-   rr = /*warning:INVALID_ASSIGNMENT*/o;
-   rr = /*warning:INVALID_ASSIGNMENT*/n;
+   rr = /*severe:INVALID_ASSIGNMENT*/r;
+   rr = /*severe:INVALID_ASSIGNMENT*/o;
+   rr = /*severe:INVALID_ASSIGNMENT*/n;
    rr = rr;
    rr = ro;
-   rr = /*warning:INVALID_ASSIGNMENT*/rn;
+   rr = /*severe:INVALID_ASSIGNMENT*/rn;
    rr = oo;
-   rr = /*warning:INVALID_ASSIGNMENT*/nn;
-   rr = /*warning:INVALID_ASSIGNMENT*/nnn;
+   rr = /*severe:INVALID_ASSIGNMENT*/nn;
+   rr = /*severe:INVALID_ASSIGNMENT*/nnn;
 
    ro = /*warning:DOWN_CAST_COMPOSITE*/r;
-   ro = /*warning:INVALID_ASSIGNMENT*/o;
-   ro = /*warning:INVALID_ASSIGNMENT*/n;
+   ro = /*severe:INVALID_ASSIGNMENT*/o;
+   ro = /*severe:INVALID_ASSIGNMENT*/n;
    ro = /*warning:DOWN_CAST_COMPOSITE*/rr;
    ro = ro;
-   ro = /*warning:INVALID_ASSIGNMENT*/rn;
+   ro = /*severe:INVALID_ASSIGNMENT*/rn;
    ro = oo;
-   ro = /*warning:INVALID_ASSIGNMENT*/nn;
-   ro = /*warning:INVALID_ASSIGNMENT*/nnn;
+   ro = /*severe:INVALID_ASSIGNMENT*/nn;
+   ro = /*severe:INVALID_ASSIGNMENT*/nnn;
 
    rn = /*warning:DOWN_CAST_COMPOSITE*/r;
-   rn = /*warning:INVALID_ASSIGNMENT*/o;
-   rn = /*warning:INVALID_ASSIGNMENT*/n;
-   rn = /*warning:INVALID_ASSIGNMENT*/rr;
-   rn = /*warning:INVALID_ASSIGNMENT*/ro;
+   rn = /*severe:INVALID_ASSIGNMENT*/o;
+   rn = /*severe:INVALID_ASSIGNMENT*/n;
+   rn = /*severe:INVALID_ASSIGNMENT*/rr;
+   rn = /*severe:INVALID_ASSIGNMENT*/ro;
    rn = rn;
-   rn = /*warning:INVALID_ASSIGNMENT*/oo;
-   rn = /*warning:INVALID_ASSIGNMENT*/nn;
-   rn = /*warning:INVALID_ASSIGNMENT*/nnn;
+   rn = /*severe:INVALID_ASSIGNMENT*/oo;
+   rn = /*severe:INVALID_ASSIGNMENT*/nn;
+   rn = /*severe:INVALID_ASSIGNMENT*/nnn;
 
    oo = /*warning:DOWN_CAST_COMPOSITE*/r;
    oo = /*warning:DOWN_CAST_COMPOSITE*/o;
-   oo = /*warning:INVALID_ASSIGNMENT*/n;
+   oo = /*severe:INVALID_ASSIGNMENT*/n;
    oo = /*warning:DOWN_CAST_COMPOSITE*/rr;
    oo = /*warning:DOWN_CAST_COMPOSITE*/ro;
-   oo = /*warning:INVALID_ASSIGNMENT*/rn;
+   oo = /*severe:INVALID_ASSIGNMENT*/rn;
    oo = oo;
-   oo = /*warning:INVALID_ASSIGNMENT*/nn;
-   oo = /*warning:INVALID_ASSIGNMENT*/nnn;
+   oo = /*severe:INVALID_ASSIGNMENT*/nn;
+   oo = /*severe:INVALID_ASSIGNMENT*/nnn;
 
-   nn = /*warning:INVALID_ASSIGNMENT*/r;
-   nn = /*warning:INVALID_ASSIGNMENT*/o;
+   nn = /*severe:INVALID_ASSIGNMENT*/r;
+   nn = /*severe:INVALID_ASSIGNMENT*/o;
    nn = /*warning:DOWN_CAST_COMPOSITE*/n;
-   nn = /*warning:INVALID_ASSIGNMENT*/rr;
-   nn = /*warning:INVALID_ASSIGNMENT*/ro;
-   nn = /*warning:INVALID_ASSIGNMENT*/rn;
-   nn = /*warning:INVALID_ASSIGNMENT*/oo;
+   nn = /*severe:INVALID_ASSIGNMENT*/rr;
+   nn = /*severe:INVALID_ASSIGNMENT*/ro;
+   nn = /*severe:INVALID_ASSIGNMENT*/rn;
+   nn = /*severe:INVALID_ASSIGNMENT*/oo;
    nn = nn;
    nn = nnn;
 
-   nnn = /*warning:INVALID_ASSIGNMENT*/r;
-   nnn = /*warning:INVALID_ASSIGNMENT*/o;
+   nnn = /*severe:INVALID_ASSIGNMENT*/r;
+   nnn = /*severe:INVALID_ASSIGNMENT*/o;
    nnn = /*warning:DOWN_CAST_COMPOSITE*/n;
-   nnn = /*warning:INVALID_ASSIGNMENT*/rr;
-   nnn = /*warning:INVALID_ASSIGNMENT*/ro;
-   nnn = /*warning:INVALID_ASSIGNMENT*/rn;
-   nnn = /*warning:INVALID_ASSIGNMENT*/oo;
+   nnn = /*severe:INVALID_ASSIGNMENT*/rr;
+   nnn = /*severe:INVALID_ASSIGNMENT*/ro;
+   nnn = /*severe:INVALID_ASSIGNMENT*/rn;
+   nnn = /*severe:INVALID_ASSIGNMENT*/oo;
    nnn = /*warning:DOWN_CAST_COMPOSITE*/nn;
    nnn = nnn;
 }
 ''');
   }
 
   void test_functionTypingAndSubtyping_objectsWithCallMethods() {
     checkFile('''
 typedef int I2I(int x);
 typedef num N2N(num x);
 class A {
    int call(int x) => x;
 }
 class B {
    num call(num x) => x;
 }
 int i2i(int x) => x;
 num n2n(num x) => x;
 void main() {
    {
      I2I f;
      f = new A();
-     f = /*warning:INVALID_ASSIGNMENT*/new B();
+     f = /*severe:INVALID_ASSIGNMENT*/new B();
      f = i2i;
      f = /*severe:STATIC_TYPE_ERROR*/n2n;
      f = /*warning:DOWN_CAST_COMPOSITE*/i2i as Object;
      f = /*warning:DOWN_CAST_COMPOSITE*/n2n as Function;
    }
    {
      N2N f;
-     f = /*warning:INVALID_ASSIGNMENT*/new A();
+     f = /*severe:INVALID_ASSIGNMENT*/new A();
      f = new B();
      f = /*severe:STATIC_TYPE_ERROR*/i2i;
      f = n2n;
      f = /*warning:DOWN_CAST_COMPOSITE*/i2i as Object;
      f = /*warning:DOWN_CAST_COMPOSITE*/n2n as Function;
    }
    {
      A f;
      f = new A();
-     f = /*warning:INVALID_ASSIGNMENT*/new B();
-     f = /*warning:INVALID_ASSIGNMENT*/i2i;
-     f = /*warning:INVALID_ASSIGNMENT*/n2n;
+     f = /*severe:INVALID_ASSIGNMENT*/new B();
+     f = /*severe:INVALID_ASSIGNMENT*/i2i;
+     f = /*severe:INVALID_ASSIGNMENT*/n2n;
      f = /*info:DOWN_CAST_IMPLICIT*/i2i as Object;
      f = /*info:DOWN_CAST_IMPLICIT*/n2n as Function;
    }
    {
      B f;
-     f = /*warning:INVALID_ASSIGNMENT*/new A();
+     f = /*severe:INVALID_ASSIGNMENT*/new A();
      f = new B();
-     f = /*warning:INVALID_ASSIGNMENT*/i2i;
-     f = /*warning:INVALID_ASSIGNMENT*/n2n;
+     f = /*severe:INVALID_ASSIGNMENT*/i2i;
+     f = /*severe:INVALID_ASSIGNMENT*/n2n;
      f = /*info:DOWN_CAST_IMPLICIT*/i2i as Object;
      f = /*info:DOWN_CAST_IMPLICIT*/n2n as Function;
    }
    {
      Function f;
      f = new A();
      f = new B();
      f = i2i;
      f = n2n;
      f = /*info:DOWN_CAST_IMPLICIT*/i2i as Object;
@@ skipping 55 matching lines @@
 void main() {
   nonGenericFn(x) => null;
   {
     /*=R*/ f/*<P, R>*/(/*=P*/ p) => null;
     /*=T*/ g/*<S, T>*/(/*=S*/ s) => null;
 
     var local = f;
     local = g; // valid
 
     // Non-generic function cannot subtype a generic one.
-    local = /*warning:INVALID_ASSIGNMENT*/(x) => null;
-    local = /*warning:INVALID_ASSIGNMENT*/nonGenericFn;
+    local = /*severe:INVALID_ASSIGNMENT*/(x) => null;
+    local = /*severe:INVALID_ASSIGNMENT*/nonGenericFn;
   }
   {
     Iterable/*<R>*/ f/*<P, R>*/(List/*<P>*/ p) => null;
     List/*<T>*/ g/*<S, T>*/(Iterable/*<S>*/ s) => null;
 
     var local = f;
     local = g; // valid
 
     var local2 = g;
     local = local2;
     local2 = /*severe:STATIC_TYPE_ERROR*/f;
     local2 = /*warning:DOWN_CAST_COMPOSITE*/local;
 
     // Non-generic function cannot subtype a generic one.
-    local = /*warning:INVALID_ASSIGNMENT*/(x) => null;
-    local = /*warning:INVALID_ASSIGNMENT*/nonGenericFn;
+    local = /*severe:INVALID_ASSIGNMENT*/(x) => null;
+    local = /*severe:INVALID_ASSIGNMENT*/nonGenericFn;
   }
 }
 ''');
   }
 
   void test_functionTypingAndSubtyping_uninferredClosure() {
     checkFile('''
 typedef num Num2Num(num x);
 void main() {
   Num2Num g = /*info:INFERRED_TYPE_CLOSURE,severe:STATIC_TYPE_ERROR*/(int x) { return x; };
@@ skipping 128 matching lines @@
     checkFile('''
 main() {
   dynamic dyn = 42;
   Object obj = 42;
   int i = 42;
   bool b = false;
 
   if (b) {}
   if (/*info:DYNAMIC_CAST*/dyn) {}
   if (/*info:DOWN_CAST_IMPLICIT*/obj) {}
-  if (/*warning:NON_BOOL_CONDITION*/i) {}
+  if (/*severe:NON_BOOL_CONDITION*/i) {}
 
   while (b) {}
   while (/*info:DYNAMIC_CAST*/dyn) {}
   while (/*info:DOWN_CAST_IMPLICIT*/obj) {}
-  while (/*warning:NON_BOOL_CONDITION*/i) {}
+  while (/*severe:NON_BOOL_CONDITION*/i) {}
 
   do {} while (b);
   do {} while (/*info:DYNAMIC_CAST*/dyn);
   do {} while (/*info:DOWN_CAST_IMPLICIT*/obj);
-  do {} while (/*warning:NON_BOOL_CONDITION*/i);
+  do {} while (/*severe:NON_BOOL_CONDITION*/i);
 
   for (;b;) {}
   for (;/*info:DYNAMIC_CAST*/dyn;) {}
   for (;/*info:DOWN_CAST_IMPLICIT*/obj;) {}
-  for (;/*warning:NON_BOOL_CONDITION*/i;) {}
+  for (;/*severe:NON_BOOL_CONDITION*/i;) {}
 }
 ''');
   }
 
   void test_implicitCasts() {
     addFile('num n; int i = /*info:ASSIGNMENT_CAST*/n;');
     check();
-    addFile('num n; int i = /*severe:ASSIGNMENT_CAST*/n;');
+    // TODO(jmesserly): should not be emitting the hint as well as the error.
+    addFile(
+        'num n; int i = /*info:ASSIGNMENT_CAST,severe:INVALID_ASSIGNMENT*/n;');
     check(implicitCasts: false);
   }
 
   void test_invalidOverrides_baseClassOverrideToChildInterface() {
     checkFile('''
 class A {}
 class B {}
 
 abstract class I {
     m(A a);
 }
 
 class Base {
     m(B a) {}
 }
 
-class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1
-    /*severe:INVALID_METHOD_OVERRIDE*/extends Base implements I {}
+class /*severe:INCONSISTENT_METHOD_INHERITANCE*/T1
+    /*severe:INVALID_METHOD_OVERRIDE_FROM_BASE*/extends Base implements I {}
 ''');
   }
 
   void test_invalidOverrides_childOverride() {
     checkFile('''
 class A {}
 class B {}
 
 class Base {
     A f;
@@ skipping 138 matching lines @@
 class B {}
 
 abstract class I {
     m(A a);
 }
 
 class M {
     m(B a) {}
 }
 
-class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1
-    extends Object with /*severe:INVALID_METHOD_OVERRIDE*/M
+class /*severe:INCONSISTENT_METHOD_INHERITANCE*/T1
+    extends Object with /*severe:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M
     implements I {}
 ''');
   }
 
   void test_invalidOverrides_mixinOverrideToBase() {
     checkFile('''
 class A {}
 class B {}
 
 class Base {
     m(A a) {}
     int x;
 }
 
 class M1 {
     m(B a) {}
 }
 
 class M2 {
     int x;
 }
 
-class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1 extends Base
-    with /*severe:INVALID_METHOD_OVERRIDE*/M1 {}
-class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T2 extends Base
-    with /*severe:INVALID_METHOD_OVERRIDE*/M1, /*severe:INVALID_FIELD_OVERRIDE*/M2 {}
-class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T3 extends Base
-    with /*severe:INVALID_FIELD_OVERRIDE*/M2, /*severe:INVALID_METHOD_OVERRIDE*/M1 {}
+class /*severe:INCONSISTENT_METHOD_INHERITANCE*/T1 extends Base
+    with /*severe:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M1 {}
+class /*severe:INCONSISTENT_METHOD_INHERITANCE*/T2 extends Base
+    with /*severe:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M1, /*severe:INVALID_FIELD_OVERRIDE*/M2 {}
+class /*severe:INCONSISTENT_METHOD_INHERITANCE*/T3 extends Base
+    with /*severe:INVALID_FIELD_OVERRIDE*/M2, /*severe:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M1 {}
 ''');
   }
 
   void test_invalidOverrides_mixinOverrideToMixin() {
     checkFile('''
 class A {}
 class B {}
 
 class Base {
 }
 
 class M1 {
     m(B a) {}
     int x;
 }
 
 class M2 {
     m(A a) {}
     int x;
 }
 
-class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1 extends Base
+class /*severe:INCONSISTENT_METHOD_INHERITANCE*/T1 extends Base
     with M1,
-    /*severe:INVALID_METHOD_OVERRIDE,severe:INVALID_FIELD_OVERRIDE*/M2 {}
+    /*severe:INVALID_METHOD_OVERRIDE_FROM_MIXIN,severe:INVALID_FIELD_OVERRIDE*/M2 {}
 ''');
   }
 
   void test_invalidOverrides_noDuplicateMixinOverride() {
     // This is a regression test for a bug in an earlier implementation were
     // names were hiding errors if the first mixin override looked correct,
     // but subsequent ones did not.
     checkFile('''
 class A {}
 class B {}
 
 class Base {
     m(A a) {}
 }
 
 class M1 {
     m(A a) {}
 }
 
 class M2 {
     m(B a) {}
 }
 
 class M3 {
     m(B a) {}
 }
 
-class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1 extends Base
-    with M1, /*severe:INVALID_METHOD_OVERRIDE*/M2, M3 {}
+class /*severe:INCONSISTENT_METHOD_INHERITANCE*/T1 extends Base
+    with M1, /*severe:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M2, M3 {}
 ''');
   }
 
   void
       test_invalidOverrides_noErrorsIfSubclassCorrectlyOverrideBaseAndInterface() {
     // This is a case were it is incorrect to say that the base class
     // incorrectly overrides the interface.
     checkFile('''
 class A {}
 class B {}
 
 class Base {
     m(A a) {}
 }
 
 class I1 {
     m(B a) {}
 }
 
-class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1
-    /*severe:INVALID_METHOD_OVERRIDE*/extends Base
+class /*severe:INCONSISTENT_METHOD_INHERITANCE*/T1
+    /*severe:INVALID_METHOD_OVERRIDE_FROM_BASE*/extends Base
     implements I1 {}
 
 class T2 extends Base implements I1 {
     m(a) {}
 }
 
-class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T3
-    extends Object with /*severe:INVALID_METHOD_OVERRIDE*/Base
+class /*severe:INCONSISTENT_METHOD_INHERITANCE*/T3
+    extends Object with /*severe:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/Base
     implements I1 {}
 
 class T4 extends Object with Base implements I1 {
     m(a) {}
 }
 ''');
   }
 
   void test_invalidRuntimeChecks() {
     checkFile('''
@@ skipping 52 matching lines @@
   void test_leastUpperBounds() {
     checkFile('''
 typedef T Returns<T>();
 
 // regression test for https://github.com/dart-lang/sdk/issues/26094
 class A <S extends  Returns<S>, T extends Returns<T>> {
   int test(bool b) {
     S s;
     T t;
     if (b) {
-      return /*warning:RETURN_OF_INVALID_TYPE*/b ? s : t;
+      return /*severe:RETURN_OF_INVALID_TYPE*/b ? s : t;
     } else {
-      return /*warning:RETURN_OF_INVALID_TYPE*/s ?? t;
+      return /*severe:RETURN_OF_INVALID_TYPE*/s ?? t;
     }
   }
 }
 
 class B<S, T extends S> {
   T t;
   S s;
   int test(bool b) {
-    return /*warning:RETURN_OF_INVALID_TYPE*/b ? t : s;
+    return /*severe:RETURN_OF_INVALID_TYPE*/b ? t : s;
   }
 }
 
 class C {
   // Check that the least upper bound of two types with the same
   // class but different type arguments produces the pointwise
   // least upper bound of the type arguments
   int test1(bool b) {
     List<int> li;
     List<double> ld;
-    return /*warning:RETURN_OF_INVALID_TYPE*/b ? li : ld;
+    return /*severe:RETURN_OF_INVALID_TYPE*/b ? li : ld;
   }
   // TODO(leafp): This case isn't handled yet.  This test checks
   // the case where two related classes are instantiated with related
   // but different types.
   Iterable<num> test2(bool b) {
     List<int> li;
     Iterable<double> id;
     int x =
-        /*info:ASSIGNMENT_CAST should be warning:INVALID_ASSIGNMENT*/
+        /*info:ASSIGNMENT_CAST should be severe:INVALID_ASSIGNMENT*/
         b ? li : id;
     return /*warning:DOWN_CAST_COMPOSITE should be pass*/b ? li : id;
   }
 }
 ''');
   }
 
   void test_loadLibrary() {
     addFile('''library lib1;''', name: '/lib1.dart');
     checkFile(r'''
@@ skipping 62 matching lines @@
 
 abstract class I1 {
     m(A a);
 }
 abstract class Base implements I1 {}
 
 class M {
     m(B a) {}
 }
 
-class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1 extends Base
-    with /*severe:INVALID_METHOD_OVERRIDE*/M {}
+class /*severe:INCONSISTENT_METHOD_INHERITANCE*/T1 extends Base
+    with /*severe:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M {}
 ''');
   }
 
   void test_mixinOverrideOfGrandInterface_interfaceOfConcreteSuperclass() {
     checkFile('''
 class A {}
 class B {}
 
 abstract class I1 {
     m(A a);
 }
 
 class /*warning:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE*/Base
     implements I1 {}
 
 class M {
     m(B a) {}
 }
 
-class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1 extends Base
+class /*severe:INCONSISTENT_METHOD_INHERITANCE*/T1 extends Base
     with M {}
 ''');
   }
 
   void test_mixinOverrideOfGrandInterface_interfaceOfInterfaceOfChild() {
     checkFile('''
 class A {}
 class B {}
 
 abstract class I1 {
     m(A a);
 }
 abstract class I2 implements I1 {}
 
 class M {
     m(B a) {}
 }
 
-class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1
-    extends Object with /*severe:INVALID_METHOD_OVERRIDE*/M
+class /*severe:INCONSISTENT_METHOD_INHERITANCE*/T1
+    extends Object with /*severe:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M
     implements I2 {}
 ''');
   }
 
   void test_mixinOverrideOfGrandInterface_mixinOfInterfaceOfChild() {
     checkFile('''
 class A {}
 class B {}
 
 abstract class M1 {
     m(A a);
 }
 abstract class I2 extends Object with M1 {}
 
 class M {
     m(B a) {}
 }
 
-class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1
-    extends Object with /*severe:INVALID_METHOD_OVERRIDE*/M
+class /*severe:INCONSISTENT_METHOD_INHERITANCE*/T1
+    extends Object with /*severe:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M
     implements I2 {}
 ''');
   }
 
   void test_mixinOverrideOfGrandInterface_superclassOfInterfaceOfChild() {
     checkFile('''
 class A {}
 class B {}
 
 abstract class I1 {
     m(A a);
 }
 abstract class I2 extends I1 {}
 
 class M {
     m(B a) {}
 }
 
-class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1
-    extends Object with /*severe:INVALID_METHOD_OVERRIDE*/M
+class /*severe:INCONSISTENT_METHOD_INHERITANCE*/T1
+    extends Object with /*severe:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M
     implements I2 {}
 ''');
   }
 
   void
       test_noDuplicateReportsFromOverridingInterfaces_baseTypeAndMixinOverrideSameMethodInInterface() {
     checkFile('''
 class A {}
 class B {}
 
 abstract class I1 {
     m(A a);
 }
 
 class Base {
     m(B a) {}
 }
 
 class M {
     m(B a) {}
 }
 
 // Here we want to report both, because the error location is
 // different.
 // TODO(sigmund): should we merge these as well?
-class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1
-    /*severe:INVALID_METHOD_OVERRIDE*/extends Base
-    with /*severe:INVALID_METHOD_OVERRIDE*/M
+class /*severe:INCONSISTENT_METHOD_INHERITANCE*/T1
+    /*severe:INVALID_METHOD_OVERRIDE_FROM_BASE*/extends Base
+    with /*severe:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M
     implements I1 {}
 ''');
   }
 
   void
       test_noDuplicateReportsFromOverridingInterfaces_twoGrandTypesOverrideSameMethodInInterface() {
     checkFile('''
 class A {}
 class B {}
 
 abstract class I1 {
     m(A a);
 }
 
 class Grandparent {
     m(B a) {}
 }
 
 class Parent1 extends Grandparent {
     m(B a) {}
 }
 class Parent2 extends Grandparent {}
 
 // Note: otherwise both errors would be reported on this line
-class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1
-    /*severe:INVALID_METHOD_OVERRIDE*/extends Parent1
+class /*severe:INCONSISTENT_METHOD_INHERITANCE*/T1
+    /*severe:INVALID_METHOD_OVERRIDE_FROM_BASE*/extends Parent1
     implements I1 {}
-class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T2
-    /*severe:INVALID_METHOD_OVERRIDE*/extends Parent2
+class /*severe:INCONSISTENT_METHOD_INHERITANCE*/T2
+    /*severe:INVALID_METHOD_OVERRIDE_FROM_BASE*/extends Parent2
     implements I1 {}
 ''');
   }
 
   void
       test_noDuplicateReportsFromOverridingInterfaces_twoMixinsOverrideSameMethodInInterface() {
     checkFile('''
 class A {}
 class B {}
 
 abstract class I1 {
     m(A a);
 }
 
 class M1 {
     m(B a) {}
 }
 
 class M2 {
     m(B a) {}
 }
 
 // Here we want to report both, because the error location is
 // different.
 // TODO(sigmund): should we merge these as well?
-class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1 extends Object
-    with /*severe:INVALID_METHOD_OVERRIDE*/M1,
-    /*severe:INVALID_METHOD_OVERRIDE*/M2
+class /*severe:INCONSISTENT_METHOD_INHERITANCE*/T1 extends Object
+    with /*severe:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M1,
+    /*severe:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M2
     implements I1 {}
 ''');
   }
 
   void
       test_noDuplicateReportsFromOverridingInterfaces_typeAndBaseTypeOverrideSameMethodInInterface() {
     checkFile('''
 class A {}
 class B {}
 
 abstract class I1 {
     m(A a);
 }
 
 class Base {
     m(B a) {}
 }
 
 // Note: no error reported in `extends Base` to avoid duplicating
 // the error in T1.
 class T1 extends Base implements I1 {
   /*severe:INVALID_METHOD_OVERRIDE*/m(
       /*warning:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
 }
 
 // If there is no error in the class, we do report the error at
 // the base class:
-class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T2
-    /*severe:INVALID_METHOD_OVERRIDE*/extends Base
+class /*severe:INCONSISTENT_METHOD_INHERITANCE*/T2
+    /*severe:INVALID_METHOD_OVERRIDE_FROM_BASE*/extends Base
     implements I1 {}
 ''');
   }
 
   void
       test_noDuplicateReportsFromOverridingInterfaces_typeAndMixinOverrideSameMethodInInterface() {
     checkFile('''
 class A {}
 class B {}
 
 abstract class I1 {
     m(A a);
 }
 
 class M {
     m(B a) {}
 }
 
 class T1 extends Object with M implements I1 {
   /*severe:INVALID_METHOD_OVERRIDE*/m(
       /*warning:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
 }
 
-class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T2
-    extends Object with /*severe:INVALID_METHOD_OVERRIDE*/M
+class /*severe:INCONSISTENT_METHOD_INHERITANCE*/T2
+    extends Object with /*severe:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M
     implements I1 {}
 ''');
   }
 
   void
       test_noDuplicateReportsFromOverridingInterfaces_typeOverridesSomeMethodInMultipleInterfaces() {
     checkFile('''
 class A {}
 class B {}
 
@@ skipping 113 matching lines @@
     lOfOs = mOfDs;
     lOfOs = mOfOs;
     lOfOs = mOfAs;
     lOfOs = lOfDs;
     lOfOs = lOfOs;
     lOfOs = lOfAs;
     lOfOs = new L<Object>(); // Reset type propagation.
   }
   {
     lOfAs = /*warning:DOWN_CAST_COMPOSITE*/mOfDs;
-    lOfAs = /*warning:INVALID_ASSIGNMENT*/mOfOs;
+    lOfAs = /*severe:INVALID_ASSIGNMENT*/mOfOs;
     lOfAs = mOfAs;
     lOfAs = /*warning:DOWN_CAST_COMPOSITE*/lOfDs;
     lOfAs = /*info:DOWN_CAST_IMPLICIT*/lOfOs;
     lOfAs = lOfAs;
     lOfAs = new L<A>(); // Reset type propagation.
   }
   {
     mOfDs = mOfDs;
     mOfDs = mOfOs;
     mOfDs = mOfAs;
     mOfDs = /*info:DOWN_CAST_IMPLICIT*/lOfDs;
     mOfDs = /*info:DOWN_CAST_IMPLICIT*/lOfOs;
     mOfDs = /*warning:DOWN_CAST_COMPOSITE*/lOfAs;
     mOfDs = new M(); // Reset type propagation.
   }
   {
     mOfOs = mOfDs;
     mOfOs = mOfOs;
     mOfOs = mOfAs;
     mOfOs = /*info:DOWN_CAST_IMPLICIT*/lOfDs;
     mOfOs = /*info:DOWN_CAST_IMPLICIT*/lOfOs;
-    mOfOs = /*warning:INVALID_ASSIGNMENT*/lOfAs;
+    mOfOs = /*severe:INVALID_ASSIGNMENT*/lOfAs;
     mOfOs = new M<Object>(); // Reset type propagation.
   }
   {
     mOfAs = /*warning:DOWN_CAST_COMPOSITE*/mOfDs;
     mOfAs = /*info:DOWN_CAST_IMPLICIT*/mOfOs;
     mOfAs = mOfAs;
     mOfAs = /*warning:DOWN_CAST_COMPOSITE*/lOfDs;
     mOfAs = /*info:DOWN_CAST_IMPLICIT*/lOfOs;
     mOfAs = /*info:DOWN_CAST_IMPLICIT*/lOfAs;
   }
@@ skipping 26 matching lines @@
 }
  ''');
   }
 
   void test_setterReturnTypes() {
     checkFile('''
 void voidFn() => null;
 class A {
   set a(y) => 4;
   set b(y) => voidFn();
-  void set c(y) => /*warning:RETURN_OF_INVALID_TYPE*/4;
+  void set c(y) => /*severe:RETURN_OF_INVALID_TYPE*/4;
   void set d(y) => voidFn();
   /*warning:NON_VOID_RETURN_FOR_SETTER*/int set e(y) => 4;
   /*warning:NON_VOID_RETURN_FOR_SETTER*/int set f(y) =>
-      /*warning:RETURN_OF_INVALID_TYPE*/voidFn();
-  set g(y) {return /*warning:RETURN_OF_INVALID_TYPE*/4;}
-  void set h(y) {return /*warning:RETURN_OF_INVALID_TYPE*/4;}
+      /*severe:RETURN_OF_INVALID_TYPE*/voidFn();
+  set g(y) {return /*severe:RETURN_OF_INVALID_TYPE*/4;}
+  void set h(y) {return /*severe:RETURN_OF_INVALID_TYPE*/4;}
   /*warning:NON_VOID_RETURN_FOR_SETTER*/int set i(y) {return 4;}
 }
 ''');
   }
 
   void test_setterSetterOverride() {
     checkFile('''
 class A {}
 class B extends A {}
 class C extends B {}
@@ skipping 103 matching lines @@
 
 abstract class I1 {
     m(A a);
 }
 abstract class I2 implements I1 {}
 
 class Base {
     m(B a) {}
 }
 
-class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1
-    /*severe:INVALID_METHOD_OVERRIDE*/extends Base implements I2 {}
+class /*severe:INCONSISTENT_METHOD_INHERITANCE*/T1
+    /*severe:INVALID_METHOD_OVERRIDE_FROM_BASE*/extends Base implements I2 {}
 ''');
   }
 
   void test_superclassOverrideOfGrandInterface_mixinOfInterfaceOfChild() {
     checkFile('''
 class A {}
 class B {}
 
 abstract class M1 {
     m(A a);
 }
 abstract class I2 extends Object with M1 {}
 
 class Base {
     m(B a) {}
 }
 
-class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1
-    /*severe:INVALID_METHOD_OVERRIDE*/extends Base
+class /*severe:INCONSISTENT_METHOD_INHERITANCE*/T1
+    /*severe:INVALID_METHOD_OVERRIDE_FROM_BASE*/extends Base
     implements I2 {}
 ''');
   }
 
   void test_superclassOverrideOfGrandInterface_superclassOfInterfaceOfChild() {
     checkFile('''
 class A {}
 class B {}
 
 abstract class I1 {
     m(A a);
 }
 abstract class I2 extends I1 {}
 
 class Base {
     m(B a) {}
 }
 
-class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1
-    /*severe:INVALID_METHOD_OVERRIDE*/extends Base
+class /*severe:INCONSISTENT_METHOD_INHERITANCE*/T1
+    /*severe:INVALID_METHOD_OVERRIDE_FROM_BASE*/extends Base
     implements I2 {}
 ''');
   }
 
   void test_superConstructor() {
     checkFile('''
 class A { A(A x) {} }
 class B extends A {
   B() : super(/*warning:ARGUMENT_TYPE_NOT_ASSIGNABLE*/3);
 }
@@ skipping 34 matching lines @@
     v = (isValidKey != null)
          ? v : (/*info:INFERRED_TYPE_CLOSURE*/(_) => true);
   }
 }
 void main() {
   Object obj = 42;
   dynamic dyn = 42;
   int i = 42;
 
   // Check the boolean conversion of the condition.
-  print(/*warning:NON_BOOL_CONDITION*/i ? false : true);
+  print(/*severe:NON_BOOL_CONDITION*/i ? false : true);
   print((/*info:DOWN_CAST_IMPLICIT*/obj) ? false : true);
   print((/*info:DYNAMIC_CAST*/dyn) ? false : true);
 }
 ''');
   }
 
   void test_typeCheckingLiterals() {
     checkFile('''
 test() {
   num n = 3;
@@ skipping 37 matching lines @@
 }
 ''');
   }
 
   void test_typePromotionFromDynamic() {
     checkFile(r'''
 f() {
   dynamic x;
   if (x is int) {
     int y = x;
-    String z = /*warning:INVALID_ASSIGNMENT*/x;
+    String z = /*severe:INVALID_ASSIGNMENT*/x;
   }
 }
 g() {
   Object x;
   if (x is int) {
     int y = x;
-    String z = /*warning:INVALID_ASSIGNMENT*/x;
+    String z = /*severe:INVALID_ASSIGNMENT*/x;
   }
 }
 ''');
   }
 
   void test_typeSubtyping_assigningClass() {
     checkFile('''
 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 = /*warning:INVALID_ASSIGNMENT*/a;
-   d = /*warning:INVALID_ASSIGNMENT*/a;
-   n = /*warning:INVALID_ASSIGNMENT*/a;
+   i = /*severe:INVALID_ASSIGNMENT*/a;
+   d = /*severe:INVALID_ASSIGNMENT*/a;
+   n = /*severe:INVALID_ASSIGNMENT*/a;
    a = a;
    b = /*info:DOWN_CAST_IMPLICIT*/a;
 }
 ''');
   }
 
   void test_typeSubtyping_assigningSubclass() {
     checkFile('''
 class A {}
 class B extends A {}
 class C extends A {}
 
 void main() {
    dynamic y;
    Object o;
    int i = 0;
    double d = 0.0;
    num n;
    A a;
    B b;
    C c;
    y = b;
    o = b;
-   i = /*warning:INVALID_ASSIGNMENT*/b;
-   d = /*warning:INVALID_ASSIGNMENT*/b;
-   n = /*warning:INVALID_ASSIGNMENT*/b;
+   i = /*severe:INVALID_ASSIGNMENT*/b;
+   d = /*severe:INVALID_ASSIGNMENT*/b;
+   n = /*severe:INVALID_ASSIGNMENT*/b;
    a = b;
    b = b;
-   c = /*warning:INVALID_ASSIGNMENT*/b;
+   c = /*severe:INVALID_ASSIGNMENT*/b;
 }
 ''');
   }
 
   void test_typeSubtyping_dynamicDowncasts() {
     checkFile('''
 class A {}
 class B extends A {}
 
 void main() {
@@ skipping 51 matching lines @@
    D bot;
    {
      top = top;
      top = left;
      top = right;
      top = bot;
    }
    {
      left = /*info:DOWN_CAST_IMPLICIT*/top;
      left = left;
-     left = /*warning:INVALID_ASSIGNMENT*/right;
+     left = /*severe:INVALID_ASSIGNMENT*/right;
      left = bot;
    }
    {
      right = /*info:DOWN_CAST_IMPLICIT*/top;
-     right = /*warning:INVALID_ASSIGNMENT*/left;
+     right = /*severe:INVALID_ASSIGNMENT*/left;
      right = right;
      right = bot;
    }
    {
      bot = /*info:DOWN_CAST_IMPLICIT*/top;
      bot = /*info:DOWN_CAST_IMPLICIT*/left;
      bot = /*info:DOWN_CAST_IMPLICIT*/right;
      bot = bot;
    }
 }
@@ skipping 12 matching lines @@
 foo() => new A();
 
 test() {
   A a = new A();
   var c = foo();
   dynamic d;
 
   ~a;
   (/*info:DYNAMIC_INVOKE*/~d);
 
-  !/*warning:NON_BOOL_NEGATION_EXPRESSION*/a;
+  !/*severe:NON_BOOL_NEGATION_EXPRESSION*/a;
   !/*info:DYNAMIC_CAST*/d;
 
   -a;
   (/*info:DYNAMIC_INVOKE*/-d);
 
   ++a;
   --a;
   (/*info:DYNAMIC_INVOKE*/++d);
   (/*info:DYNAMIC_INVOKE*/--d);
 
@@ skipping 28 matching lines @@
 }
 ''');
   }
 
   void test_voidSubtyping() {
     // Regression test for https://github.com/dart-lang/sdk/issues/25069
     checkFile('''
 typedef int Foo();
 void foo() {}
 void main () {
-  Foo x = /*warning:INVALID_ASSIGNMENT,info:USE_OF_VOID_RESULT*/foo();
+  Foo x = /*severe:INVALID_ASSIGNMENT,info:USE_OF_VOID_RESULT*/foo();
 }
 ''');
   }
 }