fix #26122, classify strong mode errors correctly

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.
 
 library analyzer.test.src.task.strong.checker_test;
 
 import '../../../reflective_tests.dart';
 import 'strong_test_helper.dart';
 
 void main() {
@@ skipping 63 matching lines @@
 test() {
   A a = new A();
   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 + /*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/a;
   a = a - b;
   b = /*error: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;
+  x = x + /*error: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 = /*error: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];
+  a[/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/y];
 }
 ''');
   }
 
   void test_castsInConditions() {
     checkFile('''
 main() {
   bool b = true;
   num x = b ? 1 : 2.3;
   int y = /*info:ASSIGNMENT_CAST*/b ? 1 : 2.3;
@@ skipping 27 matching lines @@
 class A {}
 class B {}
 
 abstract class I1 {
     m(A a);
 }
 abstract class Base implements I1 {}
 
 class T1 extends Base {
   /*error:INVALID_METHOD_OVERRIDE*/m(
-      /*warning:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
+      /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
 }
 ''');
   }
 
   void test_classOverrideOfGrandInterface_interfaceOfConcreteSuperclass() {
     checkFile('''
 class A {}
 class B {}
 
 abstract class I1 {
     m(A a);
 }
 
-class /*warning:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE*/Base
+class /*error:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE*/Base
     implements I1 {}
 
 class T1 extends Base {
     // not reported technically because if the class is concrete,
     // it should implement all its interfaces and hence it is
     // sufficient to check overrides against it.
-    m(/*warning:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
+    m(/*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
 }
 ''');
   }
 
   void test_classOverrideOfGrandInterface_interfaceOfInterfaceOfChild() {
     checkFile('''
 class A {}
 class B {}
 
 abstract class I1 {
     m(A a);
 }
 abstract class I2 implements I1 {}
 
 class T1 implements I2 {
   /*error:INVALID_METHOD_OVERRIDE*/m(
-      /*warning:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
+      /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
 }
 ''');
   }
 
   void test_classOverrideOfGrandInterface_mixinOfInterfaceOfChild() {
     checkFile('''
 class A {}
 class B {}
 
 abstract class M1 {
     m(A a);
 }
 abstract class I2 extends Object with M1 {}
 
 class T1 implements I2 {
   /*error:INVALID_METHOD_OVERRIDE*/m(
-      /*warning:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
+      /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
 }
 ''');
   }
 
   void test_classOverrideOfGrandInterface_superclassOfInterfaceOfChild() {
     checkFile('''
 class A {}
 class B {}
 
 abstract class I1 {
     m(A a);
 }
 abstract class I2 extends I1 {}
 
 class T1 implements I2 {
   /*error:INVALID_METHOD_OVERRIDE*/m(
-      /*warning:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
+      /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
 }
 ''');
   }
 
   void test_compoundAssignments() {
     checkFile('''
 class A {
   A operator *(B b) => null;
   A operator /(B b) => null;
   A operator ~/(B b) => null;
@@ skipping 45 matching lines @@
   A a = new A();
   B b = new B();
   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 += /*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/a;
   a -= b;
   /*error:STATIC_TYPE_ERROR*/b -= /*error: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;
-  a[/*warning:ARGUMENT_TYPE_NOT_ASSIGNABLE*/z] += d;
+  a[/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/z] += d;
   a[b] += /*info:DYNAMIC_CAST*/c;
-  a[b] += /*warning:ARGUMENT_TYPE_NOT_ASSIGNABLE*/z;
+  a[b] += /*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/z;
   /*info:DYNAMIC_INVOKE,info:DYNAMIC_INVOKE*/c[b] += d;
 }
 ''');
   }
 
   void test_constructorInvalid() {
     // Regression test for https://github.com/dart-lang/sdk/issues/26695
     checkFile('''
 class A {
   B({ /*error:FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR*/this.test: 1.0 }) {}
   final double test = 0.0;
 }
 ''');
   }
 
   void test_constructors() {
     checkFile('''
 const num z = 25;
 Object obj = "world";
 
 class A {
   int x;
   String y;
 
-  A(this.x) : this.y = /*warning:FIELD_INITIALIZER_NOT_ASSIGNABLE*/42;
+  A(this.x) : this.y = /*error:FIELD_INITIALIZER_NOT_ASSIGNABLE*/42;
 
   A.c1(p): this.x = /*info:DOWN_CAST_IMPLICIT*/z, this.y = /*info:DYNAMIC_CAST*/p;
 
   A.c2(this.x, this.y);
 
   A.c3(/*error:INVALID_PARAMETER_DECLARATION*/num this.x, String this.y);
 }
 
 class B extends A {
-  B() : super(/*warning:ARGUMENT_TYPE_NOT_ASSIGNABLE*/"hello");
+  B() : super(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/"hello");
 
-  B.c2(int x, String y) : super.c2(/*warning:ARGUMENT_TYPE_NOT_ASSIGNABLE*/y,
-                                   /*warning:ARGUMENT_TYPE_NOT_ASSIGNABLE*/x);
+  B.c2(int x, String y) : super.c2(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/y,
+                                   /*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/x);
 
   B.c3(num x, Object y) : super.c3(x, /*info:DOWN_CAST_IMPLICIT*/y);
 }
 
 void main() {
-   A a = new A.c2(/*info:DOWN_CAST_IMPLICIT*/z, /*warning:ARGUMENT_TYPE_NOT_ASSIGNABLE*/z);
-   var b = new B.c2(/*warning:ARGUMENT_TYPE_NOT_ASSIGNABLE*/"hello", /*info:DOWN_CAST_IMPLICIT*/obj);
+   A a = new A.c2(/*info:DOWN_CAST_IMPLICIT*/z, /*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/z);
+   var b = new B.c2(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/"hello", /*info:DOWN_CAST_IMPLICIT*/obj);
 }
 ''');
   }
 
   void test_conversionAndDynamicInvoke() {
     addFile(
         '''
 dynamic toString = (int x) => x + 42;
 dynamic hashCode = "hello";
 ''',
@@ skipping 82 matching lines @@
 }
 void main() {
   {
     B f = new B();
     int x;
     double y;
     x = f(3);
     x = /*error:INVALID_ASSIGNMENT*/f.col(3.0);
     y = /*error: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);
+    f(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/3.0);
+    f.col(/*error: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);
     y = /*info:DYNAMIC_CAST, info:DYNAMIC_INVOKE*/f(3);
     y = /*info:DYNAMIC_CAST, info:DYNAMIC_INVOKE*/f.col(3.0);
     /*info:DYNAMIC_INVOKE*/f(3.0);
@@ skipping 81 matching lines @@
   B f4;
 }
 
 class Child extends Base {
   /*error:INVALID_FIELD_OVERRIDE,error:INVALID_METHOD_OVERRIDE*/A get f1 => null;
   /*error:INVALID_FIELD_OVERRIDE*/C get f2 => null;
   /*error:INVALID_FIELD_OVERRIDE*/get f3 => null;
   /*error:INVALID_FIELD_OVERRIDE,error:INVALID_METHOD_OVERRIDE*/dynamic get f4 => null;
 }
 
-class /*warning:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR*/Child2 implements Base {
+class /*error:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR*/Child2 implements Base {
   /*error:INVALID_METHOD_OVERRIDE*/A get f1 => null;
   C get f2 => null;
   get f3 => null;
   /*error:INVALID_METHOD_OVERRIDE*/dynamic get f4 => null;
 }
 ''');
   }
 
   void test_fieldOverride_fuzzyArrows() {
     checkFile('''
@@ skipping 1193 matching lines @@
     checkFile('''
 class A {}
 class B extends A {}
 
 class Base<T extends B> {
   T foo() => null;
 }
 
 class Derived<S extends A> extends Base<B> {
   /*error:INVALID_METHOD_OVERRIDE*/S
-      /*warning:INVALID_METHOD_OVERRIDE_RETURN_TYPE*/foo() => null;
+      /*error:INVALID_METHOD_OVERRIDE_RETURN_TYPE*/foo() => null;
 }
 
 class Derived2<S extends B> extends Base<B> {
   S foo() => null;
 }
 ''');
   }
 
   void test_genericFunctionWrongNumberOfArguments() {
     checkFile(r'''
 /*=T*/ foo/*<T>*/(/*=T*/ x, /*=T*/ y) => x;
 /*=T*/ bar/*<T>*/({/*=T*/ x, /*=T*/ y}) => x;
 
 main() {
   String x;
   // resolving these shouldn't crash.
-  foo/*warning:EXTRA_POSITIONAL_ARGUMENTS*/(1, 2, 3);
-  x = foo/*warning:EXTRA_POSITIONAL_ARGUMENTS*/('1', '2', '3');
-  foo/*warning:NOT_ENOUGH_REQUIRED_ARGUMENTS*/(1);
-  x = foo/*warning:NOT_ENOUGH_REQUIRED_ARGUMENTS*/('1');
-  x = /*info:DYNAMIC_CAST*/foo/*warning:EXTRA_POSITIONAL_ARGUMENTS*/(1, 2, 3);
-  x = /*info:DYNAMIC_CAST*/foo/*warning:NOT_ENOUGH_REQUIRED_ARGUMENTS*/(1);
+  foo/*error:EXTRA_POSITIONAL_ARGUMENTS*/(1, 2, 3);
+  x = foo/*error:EXTRA_POSITIONAL_ARGUMENTS*/('1', '2', '3');
+  foo/*error:NOT_ENOUGH_REQUIRED_ARGUMENTS*/(1);
+  x = foo/*error:NOT_ENOUGH_REQUIRED_ARGUMENTS*/('1');
+  x = /*info:DYNAMIC_CAST*/foo/*error:EXTRA_POSITIONAL_ARGUMENTS*/(1, 2, 3);
+  x = /*info:DYNAMIC_CAST*/foo/*error:NOT_ENOUGH_REQUIRED_ARGUMENTS*/(1);
 
   // named arguments
-  bar(y: 1, x: 2, /*warning:UNDEFINED_NAMED_PARAMETER*/z: 3);
-  x = bar(/*warning:UNDEFINED_NAMED_PARAMETER*/z: '1', x: '2', y: '3');
+  bar(y: 1, x: 2, /*error:UNDEFINED_NAMED_PARAMETER*/z: 3);
+  x = bar(/*error:UNDEFINED_NAMED_PARAMETER*/z: '1', x: '2', y: '3');
   bar(y: 1);
-  x = bar(x: '1', /*warning:UNDEFINED_NAMED_PARAMETER*/z: 42);
-  x = /*info:DYNAMIC_CAST*/bar(y: 1, x: 2, /*warning:UNDEFINED_NAMED_PARAMETER*/z: 3);
+  x = bar(x: '1', /*error:UNDEFINED_NAMED_PARAMETER*/z: 42);
+  x = /*info:DYNAMIC_CAST*/bar(y: 1, x: 2, /*error:UNDEFINED_NAMED_PARAMETER*/z: 3);
   x = /*info:DYNAMIC_CAST*/bar(x: 1);
 }
 ''');
   }
 
   void test_genericMethodOverride() {
     checkFile('''
 class Future<T> {
   /*=S*/ then/*<S>*/(/*=S*/ onValue(T t)) => null;
 }
@@ skipping 343 matching lines @@
     checkFile('''
 class A {}
 class B {}
 
 class Base {
     A f;
 }
 
 class T1 extends Base {
   /*warning:MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE, error:INVALID_FIELD_OVERRIDE, error:INVALID_METHOD_OVERRIDE*/B get
-      /*warning:INVALID_GETTER_OVERRIDE_RETURN_TYPE*/f => null;
+      /*error:INVALID_GETTER_OVERRIDE_RETURN_TYPE*/f => null;
 }
 
 class T2 extends Base {
   /*warning:MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE, error:INVALID_FIELD_OVERRIDE, error:INVALID_METHOD_OVERRIDE*/set f(
-      /*warning:INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE*/B b) => null;
+      /*error:INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE*/B b) => null;
 }
 
 class T3 extends Base {
   /*error:INVALID_FIELD_OVERRIDE, error:INVALID_METHOD_OVERRIDE*/final B
-      /*warning:FINAL_NOT_INITIALIZED, warning:INVALID_GETTER_OVERRIDE_RETURN_TYPE*/f;
+      /*warning:FINAL_NOT_INITIALIZED, error:INVALID_GETTER_OVERRIDE_RETURN_TYPE*/f;
 }
 class T4 extends Base {
   // two: one for the getter one for the setter.
   /*error:INVALID_FIELD_OVERRIDE, error:INVALID_METHOD_OVERRIDE, error:INVALID_METHOD_OVERRIDE*/B
-      /*warning:INVALID_GETTER_OVERRIDE_RETURN_TYPE, warning:INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE*/f;
+      /*error:INVALID_GETTER_OVERRIDE_RETURN_TYPE, error:INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE*/f;
 }
 
-class /*warning:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE*/T5 implements Base {
+class /*error:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE*/T5 implements Base {
   /*warning:MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE, error:INVALID_METHOD_OVERRIDE*/B get
-      /*warning:INVALID_GETTER_OVERRIDE_RETURN_TYPE*/f => null;
+      /*error:INVALID_GETTER_OVERRIDE_RETURN_TYPE*/f => null;
 }
 
-class /*warning:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE*/T6 implements Base {
+class /*error:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE*/T6 implements Base {
   /*warning:MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE, error:INVALID_METHOD_OVERRIDE*/set f(
-      /*warning:INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE*/B b) => null;
+      /*error:INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE*/B b) => null;
 }
 
-class /*warning:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE*/T7 implements Base {
+class /*error:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE*/T7 implements Base {
   /*error:INVALID_METHOD_OVERRIDE*/final B
-      /*warning:INVALID_GETTER_OVERRIDE_RETURN_TYPE*/f = null;
+      /*error:INVALID_GETTER_OVERRIDE_RETURN_TYPE*/f = null;
 }
 class T8 implements Base {
   // two: one for the getter one for the setter.
   /*error:INVALID_METHOD_OVERRIDE, error:INVALID_METHOD_OVERRIDE*/B
-      /*warning:INVALID_GETTER_OVERRIDE_RETURN_TYPE, warning:INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE*/f;
+      /*error:INVALID_GETTER_OVERRIDE_RETURN_TYPE, error:INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE*/f;
 }
 ''');
   }
 
   void test_invalidOverrides_childOverride2() {
     checkFile('''
 class A {}
 class B {}
 
 class Base {
     m(A a) {}
 }
 
 class Test extends Base {
   /*error:INVALID_METHOD_OVERRIDE*/m(
-        /*warning:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
+        /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
 }
 ''');
   }
 
   void test_invalidOverrides_classOverrideOfInterface() {
     checkFile('''
 class A {}
 class B {}
 
 abstract class I {
     m(A a);
 }
 
 class T1 implements I {
   /*error:INVALID_METHOD_OVERRIDE*/m(
-      /*warning:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
+      /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
 }
 ''');
   }
 
   void test_invalidOverrides_doubleOverride() {
     checkFile('''
 class A {}
 class B {}
 
 class Grandparent {
     m(A a) {}
 }
 class Parent extends Grandparent {
     m(A a) {}
 }
 
 class Test extends Parent {
     // Reported only once
     /*error:INVALID_METHOD_OVERRIDE*/m(
-        /*warning:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
+        /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
 }
 ''');
   }
 
   void test_invalidOverrides_doubleOverride2() {
     checkFile('''
 class A {}
 class B {}
 
 class Grandparent {
     m(A a) {}
 }
 class Parent extends Grandparent {
   /*error:INVALID_METHOD_OVERRIDE*/m(
-      /*warning:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
+      /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
 }
 
 class Test extends Parent {
     m(B a) {}
 }
 ''');
   }
 
   void test_invalidOverrides_grandChildOverride() {
     checkFile('''
 class A {}
 class B {}
 
 class Grandparent {
     m(A a) {}
     int x;
 }
 class Parent extends Grandparent {
 }
 
 class Test extends Parent {
     /*error:INVALID_METHOD_OVERRIDE*/m(
-          /*warning:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
+          /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
     /*error:INVALID_FIELD_OVERRIDE*/int x;
 }
 ''');
   }
 
   void test_invalidOverrides_mixinOverrideOfInterface() {
     checkFile('''
 class A {}
 class B {}
 
@@ skipping 310 matching lines @@
 
   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
+class /*error:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE*/Base
     implements I1 {}
 
 class M {
     m(B a) {}
 }
 
 class /*error:INCONSISTENT_METHOD_INHERITANCE*/T1 extends Base
     with M {}
 ''');
   }
@@ skipping 154 matching lines @@
 }
 
 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 {
   /*error:INVALID_METHOD_OVERRIDE*/m(
-      /*warning:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
+      /*error: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 /*error:INCONSISTENT_METHOD_INHERITANCE*/T2
     /*error: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 {
   /*error:INVALID_METHOD_OVERRIDE*/m(
-      /*warning:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
+      /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
 }
 
 class /*error:INCONSISTENT_METHOD_INHERITANCE*/T2
     extends Object with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M
     implements I1 {}
 ''');
   }
 
   void
       test_noDuplicateReportsFromOverridingInterfaces_typeOverridesSomeMethodInMultipleInterfaces() {
     checkFile('''
 class A {}
 class B {}
 
 abstract class I1 {
     m(A a);
 }
 abstract class I2 implements I1 {
     m(A a);
 }
 
 class Base {}
 
 class T1 implements I2 {
   /*error:INVALID_METHOD_OVERRIDE*/m(
-      /*warning:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
+      /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
 }
 ''');
   }
 
   void test_nullCoalescingOperator() {
     checkFile('''
 class A {}
 class C<T> {}
 main() {
   A a, b;
@@ skipping 21 matching lines @@
 
   int _m1() => null;
 }
 
 class GrandChild extends main.Child {
   /*error:INVALID_FIELD_OVERRIDE*/var _f2;
   /*error:INVALID_FIELD_OVERRIDE*/var _f3;
   var _f4;
 
   /*error:INVALID_METHOD_OVERRIDE*/String
-      /*warning:INVALID_METHOD_OVERRIDE_RETURN_TYPE*/_m1() => null;
+      /*error:INVALID_METHOD_OVERRIDE_RETURN_TYPE*/_m1() => null;
 }
 ''',
         name: '/helper.dart');
     checkFile('''
 import 'helper.dart' as helper;
 
 class Child extends helper.Base {
   /*error:INVALID_FIELD_OVERRIDE*/var f1;
   var _f2;
   var _f4;
 
   String _m1() => null;
 }
 ''');
   }
 
   void test_redirectingConstructor() {
     checkFile('''
 class A {
   A(A x) {}
-  A.two() : this(/*warning:ARGUMENT_TYPE_NOT_ASSIGNABLE*/3);
+  A.two() : this(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/3);
 }
 ''');
   }
 
   void test_relaxedCasts() {
     checkFile('''
 class A {}
 
 class L<T> {}
 class M<T> extends L<T> {}
@@ skipping 179 matching lines @@
     checkFile('''
 class A {}
 class B {}
 
 abstract class I1 {
     m(A a);
 }
 
 abstract class Base implements I1 {
   /*error:INVALID_METHOD_OVERRIDE*/m(
-      /*warning:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
+      /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
 }
 
 class T1 extends Base {
     // we consider the base class incomplete because it is
     // abstract, so we report the error here too.
     // TODO(sigmund): consider tracking overrides in a fine-grain
     // manner, then this and the double-overrides would not be
     // reported.
     /*error:INVALID_METHOD_OVERRIDE*/m(B a) {}
 }
 ''');
   }
 
   void test_superclassOverrideOfGrandInterface_interfaceOfConcreteSuperclass() {
     checkFile('''
 class A {}
 class B {}
 
 abstract class I1 {
     m(A a);
 }
 
 class Base implements I1 {
   /*error:INVALID_METHOD_OVERRIDE*/m(
-      /*warning:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
+      /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
 }
 
 class T1 extends Base {
     m(B a) {}
 }
 ''');
   }
 
   void test_superclassOverrideOfGrandInterface_interfaceOfInterfaceOfChild() {
     checkFile('''
@@ skipping 51 matching lines @@
 class /*error:INCONSISTENT_METHOD_INHERITANCE*/T1
     /*error: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);
+  B() : super(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/3);
 }
 ''');
   }
 
   void test_ternaryOperator() {
     checkFile('''
 abstract class Comparable<T> {
   int compareTo(T other);
   static int compare(Comparable a, Comparable b) => a.compareTo(b);
 }
@@ skipping 40 matching lines @@
   }
 
   void test_typeCheckingLiterals() {
     checkFile('''
 test() {
   num n = 3;
   int i = 3;
   String s = "hello";
   {
      List<int> l = <int>[i];
-     l = <int>[/*warning:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/s];
+     l = <int>[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/s];
      l = <int>[/*info:DOWN_CAST_IMPLICIT*/n];
-     l = <int>[i, /*info:DOWN_CAST_IMPLICIT*/n, /*warning:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/s];
+     l = <int>[i, /*info:DOWN_CAST_IMPLICIT*/n, /*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/s];
   }
   {
      List l = /*info:INFERRED_TYPE_LITERAL*/[i];
      l = /*info:INFERRED_TYPE_LITERAL*/[s];
      l = /*info:INFERRED_TYPE_LITERAL*/[n];
      l = /*info:INFERRED_TYPE_LITERAL*/[i, n, s];
   }
   {
      Map<String, int> m = <String, int>{s: i};
-     m = <String, int>{s: /*warning:MAP_VALUE_TYPE_NOT_ASSIGNABLE*/s};
+     m = <String, int>{s: /*error:MAP_VALUE_TYPE_NOT_ASSIGNABLE*/s};
      m = <String, int>{s: /*info:DOWN_CAST_IMPLICIT*/n};
      m = <String, int>{s: i,
                        s: /*info:DOWN_CAST_IMPLICIT*/n,
-                       s: /*warning:MAP_VALUE_TYPE_NOT_ASSIGNABLE*/s};
+                       s: /*error:MAP_VALUE_TYPE_NOT_ASSIGNABLE*/s};
   }
  // TODO(leafp): We can't currently test for key errors since the
  // error marker binds to the entire entry.
   {
      Map m = /*info:INFERRED_TYPE_LITERAL*/{s: i};
      m = /*info:INFERRED_TYPE_LITERAL*/{s: s};
      m = /*info:INFERRED_TYPE_LITERAL*/{s: n};
      m = /*info:INFERRED_TYPE_LITERAL*/
          {s: i,
           s: n,
@@ skipping 205 matching lines @@
     checkFile('''
 class Foo {
   Foo() : /*error:REDIRECT_GENERATIVE_TO_MISSING_CONSTRUCTOR*/this.init();
 }
  ''');
   }
 
   void test_unboundTypeName() {
     checkFile('''
 void main() {
-   /*warning:UNDEFINED_CLASS should be error*/AToB y;
+   /*error:UNDEFINED_CLASS*/AToB y;
 }
 ''');
   }
 
   void test_unboundVariable() {
     checkFile('''
 void main() {
-   dynamic y = /*warning:UNDEFINED_IDENTIFIER should be error*/unboundVariable;
+   dynamic y = /*error:UNDEFINED_IDENTIFIER*/unboundVariable;
 }
 ''');
   }
 
   void test_voidSubtyping() {
     // Regression test for https://github.com/dart-lang/sdk/issues/25069
     checkFile('''
 typedef int Foo();
 void foo() {}
 void main () {
   Foo x = /*error:INVALID_ASSIGNMENT,info:USE_OF_VOID_RESULT*/foo();
 }
 ''');
   }
 }