Don't report redundant type errors in strong mode.

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 'package:unittest/unittest.dart';
@@ skipping 31 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((/*severe:STATIC_TYPE_ERROR*/i) ? false : true);
+          print(/*warning:NON_BOOL_CONDITION*/i ? false : true);
           print((/*info:DOWN_CAST_IMPLICIT*/obj) ? false : true);
           print((/*info:DYNAMIC_CAST*/dyn) ? false : true);
         }
       ''');
   });
 
   test('if/for/do/while statements use boolean conversion', () {
     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 (/*severe:STATIC_TYPE_ERROR*/i) {}
+        if (/*warning:NON_BOOL_CONDITION*/i) {}
 
         while (b) {}
         while (/*info:DYNAMIC_CAST*/dyn) {}
         while (/*info:DOWN_CAST_IMPLICIT*/obj) {}
-        while (/*severe:STATIC_TYPE_ERROR*/i) {}
+        while (/*warning:NON_BOOL_CONDITION*/i) {}
 
         do {} while (b);
         do {} while (/*info:DYNAMIC_CAST*/dyn);
         do {} while (/*info:DOWN_CAST_IMPLICIT*/obj);
-        do {} while (/*severe:STATIC_TYPE_ERROR*/i);
+        do {} while (/*warning:NON_BOOL_CONDITION*/i);
 
         for (;b;) {}
         for (;/*info:DYNAMIC_CAST*/dyn;) {}
         for (;/*info:DOWN_CAST_IMPLICIT*/obj;) {}
-        for (;/*severe:STATIC_TYPE_ERROR*/i;) {}
+        for (;/*warning:NON_BOOL_CONDITION*/i;) {}
       }
     ''');
   });
 
   test('dynamic invocation', () {
     checkFile('''
-
       class A {
         dynamic call(dynamic x) => x;
       }
       class B extends A {
         int call(int x) => x;
         double col(double x) => x;
       }
       void main() {
         {
           B f = new B();
           int x;
           double y;
           x = f(3);
-          x = /*severe:STATIC_TYPE_ERROR*/f.col(3.0);
-          y = /*severe:STATIC_TYPE_ERROR*/f(3);
+          x = /*warning:INVALID_ASSIGNMENT*/f.col(3.0);
+          y = /*warning:INVALID_ASSIGNMENT*/f(3);
           y = f.col(3.0);
-          f(/*severe:STATIC_TYPE_ERROR*/3.0);
-          f.col(/*severe:STATIC_TYPE_ERROR*/3);
+          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*/f.col(3.0);
+          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));
-          (/*info:DYNAMIC_INVOKE*/f.col(3));
+          /*info:DYNAMIC_INVOKE*/f(3.0);
+          /*info:DYNAMIC_INVOKE*/f.col(/*info:ARGUMENT_TYPE_NOT_ASSIGNABLE*/3);

[Leaf, 2016/03/10 22:58:25]

Interesting.  I guess this is the propagated type info kicking in.

[Bob Nystrom, 2016/03/15 00:08:13]

Yeah, I think so. That's why it's an info and not a warning. Before this patch,
we weren't running ErrorVerifier at all in this test, so I'm guessing this hint
was there before too.

Added a comment.

         }
         {
           A f = new B();
           int x;
           double y;
           x = /*info:DYNAMIC_CAST, info:DYNAMIC_INVOKE*/f(3);
           y = /*info:DYNAMIC_CAST, info:DYNAMIC_INVOKE*/f(3);
-          (/*info:DYNAMIC_INVOKE*/f(3.0));
+          /*info:DYNAMIC_INVOKE*/f(3.0);
         }
         {
           dynamic g = new B();
-          (/*info:DYNAMIC_INVOKE*/g.call(32.0));
-          (/*info:DYNAMIC_INVOKE*/g.col(42.0));
-          (/*info:DYNAMIC_INVOKE*/g.foo(42.0));
-          (/*info:DYNAMIC_INVOKE*/g./*info:UNDEFINED_GETTER*/x);
+          /*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();
-          f.call(32.0);
-          (/*info:DYNAMIC_INVOKE*/f.col(42.0));
-          (/*info:DYNAMIC_INVOKE*/f.foo(42.0));
-          (/*info:DYNAMIC_INVOKE*/f./*warning:UNDEFINED_GETTER*/x);
+          f.call(/*info:ARGUMENT_TYPE_NOT_ASSIGNABLE*/32.0);
+          /*info:DYNAMIC_INVOKE*/f.col(42.0);
+          /*info:DYNAMIC_INVOKE*/f.foo(42.0);
+          /*info:DYNAMIC_INVOKE*/f./*warning:UNDEFINED_GETTER*/x;
         }
       }
     ''');
   });
 
   test('conversion and dynamic invoke', () {
     addFile(
         '''
       dynamic toString = (int x) => x + 42;
       dynamic hashCode = "hello";
       ''',
         name: '/helper.dart');
     checkFile('''
       import 'helper.dart' as helper;
 
       class A {
         String x = "hello world";
 
-        void baz1(y) => x + /*info:DYNAMIC_CAST*/y;
+        void baz1(y) { x + /*info:DYNAMIC_CAST*/y; }
         static baz2(y) => /*info:DYNAMIC_INVOKE*/y + y;
       }
 
       void foo(String str) {
         print(str);
       }
 
       class B {
         String toString([int arg]) => arg.toString();
       }
@@ skipping 57 matching lines @@
 
   test('Constructors', () {
     checkFile('''
       const num z = 25;
       Object obj = "world";
 
       class A {
         int x;
         String y;
 
-        A(this.x) : this.y = /*severe:STATIC_TYPE_ERROR*/42;
+        A(this.x) : this.y = /*warning: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(/*severe:INVALID_PARAMETER_DECLARATION*/num this.x, String this.y);
       }
 
       class B extends A {
-        B() : super(/*severe:STATIC_TYPE_ERROR*/"hello");
+        B() : super(/*warning:ARGUMENT_TYPE_NOT_ASSIGNABLE*/"hello");
 
-        B.c2(int x, String y) : super.c2(/*severe:STATIC_TYPE_ERROR*/y,
-                                         /*severe:STATIC_TYPE_ERROR*/x);
+        B.c2(int x, String y) : super.c2(/*warning:ARGUMENT_TYPE_NOT_ASSIGNABLE*/y,
+                                         /*warning: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, /*severe:STATIC_TYPE_ERROR*/z);
-         var b = new B.c2(/*severe:STATIC_TYPE_ERROR*/"hello", /*info:DOWN_CAST_IMPLICIT*/obj);
+         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);
       }
    ''');
   });
 
   test('Unbound variable', () {
     checkFile('''
       void main() {
          dynamic y = /*warning:UNDEFINED_IDENTIFIER should be error*/unboundVariable;
       }
    ''');
   });
 
   test('Unbound type name', () {
     checkFile('''
       void main() {
          /*warning:UNDEFINED_CLASS should be error*/AToB y;
       }
    ''');
   });
 
   // Regression test for https://github.com/dart-lang/sdk/issues/25069
   test('Void subtyping', () {
     checkFile('''
       typedef int Foo();
       void foo() {}
       void main () {
-        Foo x = /*severe:STATIC_TYPE_ERROR*/foo();
+        Foo x = /*warning:INVALID_ASSIGNMENT,info:USE_OF_VOID_RESULT*/foo();
       }
    ''');
   });
 
   group('Ground type subtyping:', () {
     test('dynamic is top', () {
       checkFile('''
 
       class A {}
       class B extends A {}
@@ skipping 49 matching lines @@
       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:STATIC_TYPE_ERROR*/a;
-         d = /*severe:STATIC_TYPE_ERROR*/a;
-         n = /*severe:STATIC_TYPE_ERROR*/a;
+         i = /*warning:INVALID_ASSIGNMENT*/a;
+         d = /*warning:INVALID_ASSIGNMENT*/a;
+         n = /*warning:INVALID_ASSIGNMENT*/a;
          a = a;
          b = /*info:DOWN_CAST_IMPLICIT*/a;
       }
    ''');
     });
 
     test('assigning a subclass', () {
       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 = /*severe:STATIC_TYPE_ERROR*/b;
-         d = /*severe:STATIC_TYPE_ERROR*/b;
-         n = /*severe:STATIC_TYPE_ERROR*/b;
+         i = /*warning:INVALID_ASSIGNMENT*/b;
+         d = /*warning:INVALID_ASSIGNMENT*/b;
+         n = /*warning:INVALID_ASSIGNMENT*/b;
          a = b;
          b = b;
-         c = /*severe:STATIC_TYPE_ERROR*/b;
+         c = /*warning:INVALID_ASSIGNMENT*/b;
       }
    ''');
     });
 
     test('interfaces', () {
       checkFile('''
 
       class A {}
       class B extends A {}
       class C extends A {}
       class D extends B implements C {}
 
       void main() {
          A top;
          B left;
          C right;
          D bot;
          {
            top = top;
            top = left;
            top = right;
            top = bot;
          }
          {
            left = /*info:DOWN_CAST_IMPLICIT*/top;
            left = left;
-           left = /*severe:STATIC_TYPE_ERROR*/right;
+           left = /*warning:INVALID_ASSIGNMENT*/right;
            left = bot;
          }
          {
            right = /*info:DOWN_CAST_IMPLICIT*/top;
-           right = /*severe:STATIC_TYPE_ERROR*/left;
+           right = /*warning: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;
          }
       }
    ''');
     });
   });
 
   group('Function typing and subtyping:', () {
     test('int and object', () {
       checkFile('''
 
       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 globalTop(int x) => x;
       int globalLeft(int x) => x;
       Object globalRight(Object x) => x;
-      int _bot(Object x) => /*info:DOWN_CAST_IMPLICIT*/x;
+      int bot_(Object x) => /*info:DOWN_CAST_IMPLICIT*/x;
       int globalBot(Object x) => x as int;
 
       void main() {
         // Note: use locals so we only know the type, not that it's a specific
         // function declaration. (we can issue better errors in that case.)
         var top = globalTop;
         var left = globalLeft;
         var right = globalRight;
         var bot = globalBot;
 
@@ skipping 39 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:DOWN_CAST_IMPLICIT*/x;
+      B bot_(A x) => /*info:DOWN_CAST_IMPLICIT*/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 341 matching lines @@
       class B extends A {}
 
       typedef T Function2<S, T>(S z);
 
       typedef A BToA(B x);  // Top of the base lattice
       typedef B AToB(A x);  // Bot of the base lattice
 
       BToA top(AToB f) => f;
       AToB left(AToB f) => f;
       BToA right(BToA f) => f;
-      AToB _bot(BToA f) => /*warning:DOWN_CAST_COMPOSITE*/f;
+      AToB bot_(BToA f) => /*warning:DOWN_CAST_COMPOSITE*/f;
       AToB bot(BToA f) => f as AToB;
 
       void main() {
         {
           Function2<AToB, BToA> f; // Top
           f = top;
           f = left;
           f = right;
           f = bot;
         }
@@ skipping 29 matching lines @@
       class B extends A {}
 
       typedef T Function2<S, T>(S z);
 
       typedef A BToA(B x);  // Top of the base lattice
       typedef B AToB(A x);  // Bot of the base lattice
 
       Function2<B, A> top(AToB f) => f;
       Function2<A, B> left(AToB f) => f;
       Function2<B, A> right(BToA f) => f;
-      Function2<A, B> _bot(BToA f) => /*warning:DOWN_CAST_COMPOSITE*/f;
+      Function2<A, B> bot_(BToA f) => /*warning:DOWN_CAST_COMPOSITE*/f;
       Function2<A, B> bot(BToA f) => f as Function2<A, B>;
 
       void main() {
         {
           Function2<AToB, BToA> f; // Top
           f = top;
           f = left;
           f = right;
           f = bot;
         }
@@ skipping 29 matching lines @@
       class B extends A {}
 
       typedef T Function2<S, T>(S z);
 
       typedef A BToA(B x);  // Top of the base lattice
       typedef B AToB(A x);  // Bot of the base lattice
 
       BToA top(Function2<A, B> f) => f;
       AToB left(Function2<A, B> f) => f;
       BToA right(Function2<B, A> f) => f;
-      AToB _bot(Function2<B, A> f) => /*warning:DOWN_CAST_COMPOSITE*/f;
+      AToB bot_(Function2<B, A> f) => /*warning:DOWN_CAST_COMPOSITE*/f;
       AToB bot(Function2<B, A> f) => f as AToB;
 
       void main() {
         {
           Function2<AToB, BToA> f; // Top
           f = top;
           f = left;
           f = right;
           f = bot;
         }
@@ skipping 84 matching lines @@
          FN n;
          FRR rr;
          FRO ro;
          FRN rn;
          FOO oo;
          FNN nn;
          FNNN nnn;
 
          r = r;
          r = o;
-         r = /*severe:STATIC_TYPE_ERROR*/n;
-         r = /*severe:STATIC_TYPE_ERROR*/rr;
+         r = /*warning:INVALID_ASSIGNMENT*/n;
+         r = /*warning:INVALID_ASSIGNMENT*/rr;
          r = ro;
          r = rn;
          r = oo;
-         r = /*severe:STATIC_TYPE_ERROR*/nn;
-         r = /*severe:STATIC_TYPE_ERROR*/nnn;
+         r = /*warning:INVALID_ASSIGNMENT*/nn;
+         r = /*warning:INVALID_ASSIGNMENT*/nnn;
 
          o = /*warning:DOWN_CAST_COMPOSITE*/r;
          o = o;
-         o = /*severe:STATIC_TYPE_ERROR*/n;
-         o = /*severe:STATIC_TYPE_ERROR*/rr;
-         o = /*severe:STATIC_TYPE_ERROR*/ro;
-         o = /*severe:STATIC_TYPE_ERROR*/rn;
+         o = /*warning:INVALID_ASSIGNMENT*/n;
+         o = /*warning:INVALID_ASSIGNMENT*/rr;
+         o = /*warning:INVALID_ASSIGNMENT*/ro;
+         o = /*warning:INVALID_ASSIGNMENT*/rn;
          o = oo;
-         o = /*severe:STATIC_TYPE_ERROR*/nn;
-         o = /*severe:STATIC_TYPE_ERROR*/nnn;
+         o = /*warning:INVALID_ASSIGNMENT*/nn;
+         o = /*warning:INVALID_ASSIGNMENT*/nnn;
 
-         n = /*severe:STATIC_TYPE_ERROR*/r;
-         n = /*severe:STATIC_TYPE_ERROR*/o;
+         n = /*warning:INVALID_ASSIGNMENT*/r;
+         n = /*warning:INVALID_ASSIGNMENT*/o;
          n = n;
-         n = /*severe:STATIC_TYPE_ERROR*/rr;
-         n = /*severe:STATIC_TYPE_ERROR*/ro;
-         n = /*severe:STATIC_TYPE_ERROR*/rn;
-         n = /*severe:STATIC_TYPE_ERROR*/oo;
+         n = /*warning:INVALID_ASSIGNMENT*/rr;
+         n = /*warning:INVALID_ASSIGNMENT*/ro;
+         n = /*warning:INVALID_ASSIGNMENT*/rn;
+         n = /*warning:INVALID_ASSIGNMENT*/oo;
          n = nn;
          n = nnn;
 
-         rr = /*severe:STATIC_TYPE_ERROR*/r;
-         rr = /*severe:STATIC_TYPE_ERROR*/o;
-         rr = /*severe:STATIC_TYPE_ERROR*/n;
+         rr = /*warning:INVALID_ASSIGNMENT*/r;
+         rr = /*warning:INVALID_ASSIGNMENT*/o;
+         rr = /*warning:INVALID_ASSIGNMENT*/n;
          rr = rr;
          rr = ro;
-         rr = /*severe:STATIC_TYPE_ERROR*/rn;
+         rr = /*warning:INVALID_ASSIGNMENT*/rn;
          rr = oo;
-         rr = /*severe:STATIC_TYPE_ERROR*/nn;
-         rr = /*severe:STATIC_TYPE_ERROR*/nnn;
+         rr = /*warning:INVALID_ASSIGNMENT*/nn;
+         rr = /*warning:INVALID_ASSIGNMENT*/nnn;
 
          ro = /*warning:DOWN_CAST_COMPOSITE*/r;
-         ro = /*severe:STATIC_TYPE_ERROR*/o;
-         ro = /*severe:STATIC_TYPE_ERROR*/n;
+         ro = /*warning:INVALID_ASSIGNMENT*/o;
+         ro = /*warning:INVALID_ASSIGNMENT*/n;
          ro = /*warning:DOWN_CAST_COMPOSITE*/rr;
          ro = ro;
-         ro = /*severe:STATIC_TYPE_ERROR*/rn;
+         ro = /*warning:INVALID_ASSIGNMENT*/rn;
          ro = oo;
-         ro = /*severe:STATIC_TYPE_ERROR*/nn;
-         ro = /*severe:STATIC_TYPE_ERROR*/nnn;
+         ro = /*warning:INVALID_ASSIGNMENT*/nn;
+         ro = /*warning:INVALID_ASSIGNMENT*/nnn;
 
          rn = /*warning:DOWN_CAST_COMPOSITE*/r;
-         rn = /*severe:STATIC_TYPE_ERROR*/o;
-         rn = /*severe:STATIC_TYPE_ERROR*/n;
-         rn = /*severe:STATIC_TYPE_ERROR*/rr;
-         rn = /*severe:STATIC_TYPE_ERROR*/ro;
+         rn = /*warning:INVALID_ASSIGNMENT*/o;
+         rn = /*warning:INVALID_ASSIGNMENT*/n;
+         rn = /*warning:INVALID_ASSIGNMENT*/rr;
+         rn = /*warning:INVALID_ASSIGNMENT*/ro;
          rn = rn;
-         rn = /*severe:STATIC_TYPE_ERROR*/oo;
-         rn = /*severe:STATIC_TYPE_ERROR*/nn;
-         rn = /*severe:STATIC_TYPE_ERROR*/nnn;
+         rn = /*warning:INVALID_ASSIGNMENT*/oo;
+         rn = /*warning:INVALID_ASSIGNMENT*/nn;
+         rn = /*warning:INVALID_ASSIGNMENT*/nnn;
 
          oo = /*warning:DOWN_CAST_COMPOSITE*/r;
          oo = /*warning:DOWN_CAST_COMPOSITE*/o;
-         oo = /*severe:STATIC_TYPE_ERROR*/n;
+         oo = /*warning:INVALID_ASSIGNMENT*/n;
          oo = /*warning:DOWN_CAST_COMPOSITE*/rr;
          oo = /*warning:DOWN_CAST_COMPOSITE*/ro;
-         oo = /*severe:STATIC_TYPE_ERROR*/rn;
+         oo = /*warning:INVALID_ASSIGNMENT*/rn;
          oo = oo;
-         oo = /*severe:STATIC_TYPE_ERROR*/nn;
-         oo = /*severe:STATIC_TYPE_ERROR*/nnn;
+         oo = /*warning:INVALID_ASSIGNMENT*/nn;
+         oo = /*warning:INVALID_ASSIGNMENT*/nnn;
 
-         nn = /*severe:STATIC_TYPE_ERROR*/r;
-         nn = /*severe:STATIC_TYPE_ERROR*/o;
+         nn = /*warning:INVALID_ASSIGNMENT*/r;
+         nn = /*warning:INVALID_ASSIGNMENT*/o;
          nn = /*warning:DOWN_CAST_COMPOSITE*/n;
-         nn = /*severe:STATIC_TYPE_ERROR*/rr;
-         nn = /*severe:STATIC_TYPE_ERROR*/ro;
-         nn = /*severe:STATIC_TYPE_ERROR*/rn;
-         nn = /*severe:STATIC_TYPE_ERROR*/oo;
+         nn = /*warning:INVALID_ASSIGNMENT*/rr;
+         nn = /*warning:INVALID_ASSIGNMENT*/ro;
+         nn = /*warning:INVALID_ASSIGNMENT*/rn;
+         nn = /*warning:INVALID_ASSIGNMENT*/oo;
          nn = nn;
          nn = nnn;
 
-         nnn = /*severe:STATIC_TYPE_ERROR*/r;
-         nnn = /*severe:STATIC_TYPE_ERROR*/o;
+         nnn = /*warning:INVALID_ASSIGNMENT*/r;
+         nnn = /*warning:INVALID_ASSIGNMENT*/o;
          nnn = /*warning:DOWN_CAST_COMPOSITE*/n;
-         nnn = /*severe:STATIC_TYPE_ERROR*/rr;
-         nnn = /*severe:STATIC_TYPE_ERROR*/ro;
-         nnn = /*severe:STATIC_TYPE_ERROR*/rn;
-         nnn = /*severe:STATIC_TYPE_ERROR*/oo;
+         nnn = /*warning:INVALID_ASSIGNMENT*/rr;
+         nnn = /*warning:INVALID_ASSIGNMENT*/ro;
+         nnn = /*warning:INVALID_ASSIGNMENT*/rn;
+         nnn = /*warning:INVALID_ASSIGNMENT*/oo;
          nnn = /*warning:DOWN_CAST_COMPOSITE*/nn;
          nnn = nnn;
       }
    ''');
     });
 
     test('Function subtyping: objects with call methods', () {
       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 = /*severe:STATIC_TYPE_ERROR*/new B();
+           f = /*warning: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 = /*severe:STATIC_TYPE_ERROR*/new A();
+           f = /*warning: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 = /*severe:STATIC_TYPE_ERROR*/new B();
-           f = /*severe:STATIC_TYPE_ERROR*/i2i;
-           f = /*severe:STATIC_TYPE_ERROR*/n2n;
+           f = /*warning:INVALID_ASSIGNMENT*/new B();
+           f = /*warning:INVALID_ASSIGNMENT*/i2i;
+           f = /*warning:INVALID_ASSIGNMENT*/n2n;
            f = /*info:DOWN_CAST_IMPLICIT*/i2i as Object;
            f = /*info:DOWN_CAST_IMPLICIT*/n2n as Function;
          }
          {
            B f;
-           f = /*severe:STATIC_TYPE_ERROR*/new A();
+           f = /*warning:INVALID_ASSIGNMENT*/new A();
            f = new B();
-           f = /*severe:STATIC_TYPE_ERROR*/i2i;
-           f = /*severe:STATIC_TYPE_ERROR*/n2n;
+           f = /*warning:INVALID_ASSIGNMENT*/i2i;
+           f = /*warning: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;
            f = (n2n as Function);
          }
       }
    ''');
     });
 
     test('void', () {
       checkFile('''
 
       class A {
         void bar() => null;
-        void foo() => bar; // allowed
+        void foo() => bar(); // allowed
       }
    ''');
     });
 
     test('uninferred closure', () {
       checkFile('''
         typedef num Num2Num(num x);
         void main() {
           Num2Num g = /*info:INFERRED_TYPE_CLOSURE,severe:STATIC_TYPE_ERROR*/(int x) { return x; };
           print(g(42));
         }
       ''');
     });
 
     test('subtype of universal type', () {
       checkFile('''
         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 = /*severe:STATIC_TYPE_ERROR*/(x) => null;
-            local = /*severe:STATIC_TYPE_ERROR*/nonGenericFn;
+            local = /*severe:STATIC_TYPE_ERROR, warning:INVALID_ASSIGNMENT*/(x) => null;
+            local = /*warning: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 = /*severe:STATIC_TYPE_ERROR*/(x) => null;
-            local = /*severe:STATIC_TYPE_ERROR*/nonGenericFn;
+            local = /*severe:STATIC_TYPE_ERROR, warning:INVALID_ASSIGNMENT*/(x) => null;
+            local = /*warning:INVALID_ASSIGNMENT*/nonGenericFn;
           }
         }
       ''');
     });
   });
 
   test('Relaxed casts', () {
     checkFile('''
 
       class A {}
@@ skipping 29 matching lines @@
         {
           lOfOs = mOfDs;
           lOfOs = mOfOs;
           lOfOs = mOfAs;
           lOfOs = lOfDs;
           lOfOs = lOfOs;
           lOfOs = lOfAs;
         }
         {
           lOfAs = /*warning:DOWN_CAST_COMPOSITE*/mOfDs;
-          lOfAs = /*severe:STATIC_TYPE_ERROR*/mOfOs;
+          lOfAs = /*warning:INVALID_ASSIGNMENT*/mOfOs;
           lOfAs = mOfAs;
           lOfAs = /*warning:DOWN_CAST_COMPOSITE*/lOfDs;
           lOfAs = /*info:DOWN_CAST_IMPLICIT*/lOfOs;
           lOfAs = lOfAs;
         }
         {
           mOfDs = mOfDs;
           mOfDs = mOfOs;
           mOfDs = mOfAs;
           mOfDs = /*info:DOWN_CAST_IMPLICIT*/lOfDs;
           mOfDs = /*info:DOWN_CAST_IMPLICIT*/lOfOs;
           mOfDs = /*warning:DOWN_CAST_COMPOSITE*/lOfAs;
         }
         {
           mOfOs = mOfDs;
           mOfOs = mOfOs;
           mOfOs = mOfAs;
-          mOfOs = /*info:DOWN_CAST_IMPLICIT*/lOfDs;
-          mOfOs = /*info:DOWN_CAST_IMPLICIT*/lOfOs;
-          mOfOs = /*severe:STATIC_TYPE_ERROR*/lOfAs;
+          mOfOs = /*info:DOWN_CAST_IMPLICIT, info:INVALID_ASSIGNMENT*/lOfDs;

[Leaf, 2016/03/10 22:58:25]

Why did these show up?  I think this is just an implicit downcast for us.

[Bob Nystrom, 2016/03/15 00:08:13]

I believe it's a hint coming from type propagation at:

lOfDs = lOfAs;

It knows lOfDs is actually lOfAs, so you get the same warning as on line 1346,
though downgraded to a hint. Want me to rearrange the code to nullify the type
propagation?

[Leaf, 2016/03/15 00:28:04]

I see.  Not a big deal, but it might be better to null the assigned variable at
the end of each block since this is essentially just noise for the purposes of
the test.

[Bob Nystrom, 2016/03/15 19:14:34]

Done.

+          mOfOs = /*info:DOWN_CAST_IMPLICIT, info:INVALID_ASSIGNMENT*/lOfOs;
+          mOfOs = /*warning:INVALID_ASSIGNMENT*/lOfAs;
         }
         {
           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;
         }
 
       }
    ''');
   });
 
   test('Type checking literals', () {
     checkFile('''
           test() {
             num n = 3;
             int i = 3;
             String s = "hello";
             {
                List<int> l = <int>[i];
-               l = <int>[/*severe:STATIC_TYPE_ERROR*/s];
+               l = <int>[/*warning:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/s];
                l = <int>[/*info:DOWN_CAST_IMPLICIT*/n];
-               l = <int>[i, /*info:DOWN_CAST_IMPLICIT*/n, /*severe:STATIC_TYPE_ERROR*/s];
+               l = <int>[i, /*info:DOWN_CAST_IMPLICIT*/n, /*warning:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/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:STATIC_TYPE_ERROR*/s};
+               m = <String, int>{s: /*warning: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: /*severe:STATIC_TYPE_ERROR*/s};
+                                 s: /*warning: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 = {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', () {
     checkFile('''
           class A {
             static const num n = 3.0;
-            static const int i = /*info:ASSIGNMENT_CAST*/n;
+            static const int /*severe:VARIABLE_TYPE_MISMATCH*/i = /*info:ASSIGNMENT_CAST*/n;

[Leaf, 2016/03/10 22:58:25]

What is this about?  I don't think this is supposed to be an error - just a
cast?   

[Bob Nystrom, 2016/03/15 00:08:13]

n and i are const, so analyzer knows the concrete value is the wrong type.
(That's also why this is severe, not warning.) Added a comment.

             final int fi;
             const A(num a) : this.fi = /*info:DOWN_CAST_IMPLICIT*/a;
           }
           class B extends A {
             const B(Object a) : super(/*info:DOWN_CAST_IMPLICIT*/a);
           }
           void foo(Object o) {
-            var a = const A(/*info:DOWN_CAST_IMPLICIT*/o);
+            var a = const A(/*info:DOWN_CAST_IMPLICIT, severe:CONST_WITH_NON_CONSTANT_ARGUMENT, severe:INVALID_CONSTANT*/o);
           }
      ''');
   });
 
   test('casts in conditionals', () {
     checkFile('''
           main() {
             bool b = true;
             num x = b ? 1 : 2.3;
             int y = /*info:ASSIGNMENT_CAST*/b ? 1 : 2.3;
             String z = !b ? "hello" : null;
             z = b ? null : "hello";
           }
       ''');
   });
 
   // This is a regression test for https://github.com/dart-lang/sdk/issues/25071
   test('unbound redirecting constructor', () {
     checkFile('''
       class Foo {
-        Foo() : this.init();
+        Foo() : /*severe:REDIRECT_GENERATIVE_TO_MISSING_CONSTRUCTOR*/this.init();
       }
        ''');
   });
 
   test('redirecting constructor', () {
     checkFile('''
           class A {
             A(A x) {}
-            A.two() : this(/*severe:STATIC_TYPE_ERROR*/3);
+            A.two() : this(/*warning:ARGUMENT_TYPE_NOT_ASSIGNABLE*/3);
           }
        ''');
   });
 
   test('super constructor', () {
     checkFile('''
           class A { A(A x) {} }
           class B extends A {
-            B() : super(/*severe:STATIC_TYPE_ERROR*/3);
+            B() : super(/*warning:ARGUMENT_TYPE_NOT_ASSIGNABLE*/3);
           }
        ''');
   });
 
   test('factory constructor downcast', () {
     checkFile(r'''
         class Animal {
           Animal();
           factory Animal.cat() => new Cat();
         }
@@ skipping 39 matching lines @@
     addFile(
         '''
           import 'main.dart' as main;
 
           class Base {
             var f1;
             var _f2;
             var _f3;
             get _f4 => null;
 
-            int _m1();
+            int _m1() => null;
           }
 
           class GrandChild extends main.Child {
             /*severe:INVALID_FIELD_OVERRIDE*/var _f2;
             /*severe:INVALID_FIELD_OVERRIDE*/var _f3;
             var _f4;
 
-            /*severe:INVALID_METHOD_OVERRIDE*/String _m1();
+            /*severe:INVALID_METHOD_OVERRIDE*/String
+                /*warning:INVALID_METHOD_OVERRIDE_RETURN_TYPE*/_m1() => null;
           }
     ''',
         name: '/helper.dart');
     checkFile('''
           import 'helper.dart' as helper;
 
           class Child extends helper.Base {
             /*severe:INVALID_FIELD_OVERRIDE*/var f1;
             var _f2;
             var _f4;
 
-            String _m1();
+            String _m1() => null;
           }
     ''');
   });
 
   test('getter/getter override', () {
     checkFile('''
           class A {}
           class B extends A {}
           class C extends B {}
 
@@ skipping 26 matching lines @@
             B f4;
           }
 
           class Child extends Base {
             /*severe:INVALID_FIELD_OVERRIDE,severe:INVALID_METHOD_OVERRIDE*/A get f1 => null;
             /*severe:INVALID_FIELD_OVERRIDE*/C get f2 => null;
             /*severe:INVALID_FIELD_OVERRIDE*/get f3 => null;
             /*severe:INVALID_FIELD_OVERRIDE,severe:INVALID_METHOD_OVERRIDE*/dynamic get f4 => null;
           }
 
-          class Child2 implements Base {
+          class /*warning:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR*/Child2 implements Base {
             /*severe:INVALID_METHOD_OVERRIDE*/A get f1 => null;
             C get f2 => null;
             get f3 => null;
             /*severe:INVALID_METHOD_OVERRIDE*/dynamic get f4 => null;
           }
        ''');
   });
 
   test('setter/setter override', () {
     checkFile('''
@@ skipping 63 matching lines @@
        ''');
   });
 
   test('method override', () {
     checkFile('''
           class A {}
           class B extends A {}
           class C extends B {}
 
           class Base {
-            B m1(B a);
-            B m2(B a);
-            B m3(B a);
-            B m4(B a);
-            B m5(B a);
-            B m6(B a);
+            B m1(B a) => null;
+            B m2(B a) => null;
+            B m3(B a) => null;
+            B m4(B a) => null;
+            B m5(B a) => null;
+            B m6(B a) => null;
           }
 
           class Child extends Base {
-            /*severe:INVALID_METHOD_OVERRIDE*/A m1(A value) {}
-            /*severe:INVALID_METHOD_OVERRIDE*/C m2(C value) {}
-            /*severe:INVALID_METHOD_OVERRIDE*/A m3(C value) {}
-            C m4(A value) {}
-            m5(value) {}
-            /*severe:INVALID_METHOD_OVERRIDE*/dynamic m6(dynamic value) {}
+            /*severe:INVALID_METHOD_OVERRIDE*/A m1(A value) => null;
+            /*severe:INVALID_METHOD_OVERRIDE*/C m2(C value) => null;
+            /*severe:INVALID_METHOD_OVERRIDE*/A m3(C value) => null;
+            C m4(A value) => null;
+            m5(value) => null;
+            /*severe:INVALID_METHOD_OVERRIDE*/dynamic m6(dynamic value) => null;
           }
        ''');
   });
 
   test('generic class method override', () {
     checkFile('''
           class A {}
           class B extends A {}
 
           class Base<T extends B> {
             T foo() => null;
           }
 
           class Derived<S extends A> extends Base<B> {
-            /*severe:INVALID_METHOD_OVERRIDE*/S foo() => null;
+            /*severe:INVALID_METHOD_OVERRIDE*/S
+                /*warning:INVALID_METHOD_OVERRIDE_RETURN_TYPE*/foo() => null;
           }
 
           class Derived2<S extends B> extends Base<B> {
             S foo() => null;
           }
        ''');
   });
 
   test('generic method override', () {
     checkFile('''
@@ skipping 44 matching lines @@
           }
       ''');
   });
 
   test('type promotion from dynamic', () {
     checkFile(r'''
           f() {
             dynamic x;
             if (x is int) {
               int y = x;
-              String z = /*severe:STATIC_TYPE_ERROR*/x;
+              String z = /*warning:INVALID_ASSIGNMENT*/x;
             }
           }
           g() {
             Object x;
             if (x is int) {
               int y = x;
-              String z = /*severe:STATIC_TYPE_ERROR*/x;
+              String z = /*warning:INVALID_ASSIGNMENT*/x;
             }
           }
     ''');
   });
 
   test('unary operators', () {
     checkFile('''
       class A {
-        A operator ~() {}
-        A operator +(int x) {}
-        A operator -(int x) {}
-        A operator -() {}
+        A operator ~() => null;
+        A operator +(int x) => null;
+        A operator -(int x) => null;
+        A operator -() => null;
       }
 
       foo() => new A();
 
       test() {
         A a = new A();
         var c = foo();
         dynamic d;
 
         ~a;
         (/*info:DYNAMIC_INVOKE*/~d);
 
-        !/*severe:STATIC_TYPE_ERROR*/a;
+        !/*warning:NON_BOOL_NEGATION_EXPRESSION*/a;
         !/*info:DYNAMIC_CAST*/d;
 
         -a;
         (/*info:DYNAMIC_INVOKE*/-d);
 
         ++a;
         --a;
         (/*info:DYNAMIC_INVOKE*/++d);
         (/*info:DYNAMIC_INVOKE*/--d);
 
         a++;
         a--;
         (/*info:DYNAMIC_INVOKE*/d++);
         (/*info:DYNAMIC_INVOKE*/d--);
       }''');
   });
 
   test('binary and index operators', () {
     checkFile('''
           class A {
-            A operator *(B b) {}
-            A operator /(B b) {}
-            A operator ~/(B b) {}
-            A operator %(B b) {}
-            A operator +(B b) {}
-            A operator -(B b) {}
-            A operator <<(B b) {}
-            A operator >>(B b) {}
-            A operator &(B b) {}
-            A operator ^(B b) {}
-            A operator |(B b) {}
-            A operator[](B b) {}
+            A operator *(B b) => null;
+            A operator /(B b) => null;
+            A operator ~/(B b) => null;
+            A operator %(B b) => null;
+            A operator +(B b) => null;
+            A operator -(B b) => null;
+            A operator <<(B b) => null;
+            A operator >>(B b) => null;
+            A operator &(B b) => null;
+            A operator ^(B b) => null;
+            A operator |(B b) => null;
+            A operator[](B b) => null;
           }
 
           class B {
-            A operator -(B b) {}
+            A operator -(B b) => null;
           }
 
           foo() => new A();
 
           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 + /*severe:STATIC_TYPE_ERROR*/a;
+            a = a + /*warning:ARGUMENT_TYPE_NOT_ASSIGNABLE*/a;
             a = a - b;
-            b = /*severe:STATIC_TYPE_ERROR*/b - b;
+            b = /*warning: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 + /*severe:STATIC_TYPE_ERROR*/y;
+            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 = (/*severe:STATIC_TYPE_ERROR*/y) && p;
+            p = /*warning:NON_BOOL_OPERAND*/y && p;
             p = c == y;
 
             a = a[b];
             a = a[/*info:DYNAMIC_CAST*/c];
             c = (/*info:DYNAMIC_INVOKE*/c[b]);
-            a[/*severe:STATIC_TYPE_ERROR*/y];
+            a[/*warning:ARGUMENT_TYPE_NOT_ASSIGNABLE*/y];
           }
        ''');
   });
 
   test('null coalescing operator', () {
     checkFile('''
           class A {}
           class C<T> {}
           main() {
             A a, b;
             a ??= new A();
             b = b ?? new A();
 
             // downwards inference
             C<int> c, d;
             c ??= /*info:INFERRED_TYPE_ALLOCATION*/new C();
             d = d ?? /*info:INFERRED_TYPE_ALLOCATION*/new C();
           }
        ''');
   });
 
   test('compound assignments', () {
     checkFile('''
           class A {
-            A operator *(B b) {}
-            A operator /(B b) {}
-            A operator ~/(B b) {}
-            A operator %(B b) {}
-            A operator +(B b) {}
-            A operator -(B b) {}
-            A operator <<(B b) {}
-            A operator >>(B b) {}
-            A operator &(B b) {}
-            A operator ^(B b) {}
-            A operator |(B b) {}
-            D operator [](B index) {}
-            void operator []=(B index, D value) {}
+            A operator *(B b) => null;
+            A operator /(B b) => null;
+            A operator ~/(B b) => null;
+            A operator %(B b) => null;
+            A operator +(B b) => null;
+            A operator -(B b) => null;
+            A operator <<(B b) => null;
+            A operator >>(B b) => null;
+            A operator &(B b) => null;
+            A operator ^(B b) => null;
+            A operator |(B b) => null;
+            D operator [](B index) => null;
+            void operator []=(B index, D value) => null;
           }
 
           class B {
-            A operator -(B b) {}
+            A operator -(B b) => null;
           }
 
           class D {
-            D operator +(D d) {}
+            D operator +(D d) => null;
           }
 
           foo() => new A();
 
           test() {
             int x = 0;
             x += 5;
-            (/*severe:STATIC_TYPE_ERROR*/x += 3.14);
+            /*severe:STATIC_TYPE_ERROR*/x += 3.14;
 
             double y = 0.0;
             y += 5;
             y += 3.14;
 
             num z = 0;
             z += 5;
             z += 3.14;
 
             x = /*info:DOWN_CAST_IMPLICIT*/x + z;
             x += /*info:DOWN_CAST_IMPLICIT*/z;
             y = /*info:DOWN_CAST_IMPLICIT*/y + z;
             y += /*info:DOWN_CAST_IMPLICIT*/z;
 
             dynamic w = 42;
             x += /*info:DYNAMIC_CAST*/w;
             y += /*info:DYNAMIC_CAST*/w;
             z += /*info:DYNAMIC_CAST*/w;
 
             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 += /*severe:STATIC_TYPE_ERROR*/a;
+            a += /*warning:ARGUMENT_TYPE_NOT_ASSIGNABLE*/a;
             a -= b;
-            (/*severe:STATIC_TYPE_ERROR*/b -= b);
+            /*severe:STATIC_TYPE_ERROR*/b -= /*warning:INVALID_ASSIGNMENT*/b;
             a <<= b;
             a >>= b;
             a &= b;
             a ^= b;
             a |= b;
-            (/*info:DYNAMIC_INVOKE*/c += b);
+            /*info:DYNAMIC_INVOKE*/c += b;
 
             var d = new D();
             a[b] += d;
             a[/*info:DYNAMIC_CAST*/c] += d;
-            a[/*severe:STATIC_TYPE_ERROR*/z] += d;
+            a[/*warning:ARGUMENT_TYPE_NOT_ASSIGNABLE*/z] += d;
             a[b] += /*info:DYNAMIC_CAST*/c;
-            a[b] += /*severe:STATIC_TYPE_ERROR*/z;
+            a[b] += /*warning:ARGUMENT_TYPE_NOT_ASSIGNABLE*/z;
             /*info:DYNAMIC_INVOKE,info:DYNAMIC_INVOKE*/c[b] += d;
           }
        ''');
   });
 
   test('super call placement', () {
     checkFile('''
           class Base {
             var x;
             Base() : x = print('Base.1') { print('Base.2'); }
@@ skipping 24 matching lines @@
           }
 
           main() => new Derived();
        ''');
   });
 
   test('for loop variable', () {
     checkFile('''
           foo() {
             for (int i = 0; i < 10; i++) {
-              i = /*severe:STATIC_TYPE_ERROR*/"hi";
+              i = /*warning:INVALID_ASSIGNMENT*/"hi";
             }
           }
           bar() {
             for (var i = 0; i < 10; i++) {
               int j = i + 1;
             }
           }
         ''');
   });
 
@@ skipping 11 matching lines @@
     test('child override', () {
       checkFile('''
             class A {}
             class B {}
 
             class Base {
                 A f;
             }
 
             class T1 extends Base {
-              /*severe:INVALID_METHOD_OVERRIDE,severe:INVALID_FIELD_OVERRIDE*/B get f => null;
+              /*warning:MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE, severe:INVALID_FIELD_OVERRIDE, severe:INVALID_METHOD_OVERRIDE*/B get
+                  /*warning:INVALID_GETTER_OVERRIDE_RETURN_TYPE*/f => null;
             }
 
             class T2 extends Base {
-              /*severe:INVALID_METHOD_OVERRIDE,severe:INVALID_FIELD_OVERRIDE*/set f(B b) => null;
+              /*warning:MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE, severe:INVALID_FIELD_OVERRIDE, severe:INVALID_METHOD_OVERRIDE*/set f(
+                  /*warning:INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE*/B b) => null;
             }
 
             class T3 extends Base {
-              /*severe:INVALID_FIELD_OVERRIDE,severe:INVALID_METHOD_OVERRIDE*/final B f;
+              /*severe:INVALID_FIELD_OVERRIDE, severe:INVALID_METHOD_OVERRIDE*/final B
+                  /*warning:FINAL_NOT_INITIALIZED, warning:INVALID_GETTER_OVERRIDE_RETURN_TYPE*/f;
             }
             class T4 extends Base {
               // two: one for the getter one for the setter.
-              /*severe:INVALID_FIELD_OVERRIDE,severe:INVALID_METHOD_OVERRIDE,severe:INVALID_METHOD_OVERRIDE*/B f;
+              /*severe:INVALID_FIELD_OVERRIDE, severe:INVALID_METHOD_OVERRIDE, severe:INVALID_METHOD_OVERRIDE*/B
+                  /*warning:INVALID_GETTER_OVERRIDE_RETURN_TYPE, warning:INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE*/f;
             }
 
-            class T5 implements Base {
-              /*severe:INVALID_METHOD_OVERRIDE*/B get f => null;
+            class /*warning:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE*/T5 implements Base {
+              /*warning:MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE, severe:INVALID_METHOD_OVERRIDE*/B get
+                  /*warning:INVALID_GETTER_OVERRIDE_RETURN_TYPE*/f => null;
             }
 
-            class T6 implements Base {
-              /*severe:INVALID_METHOD_OVERRIDE*/set f(B b) => null;
+            class /*warning:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE*/T6 implements Base {
+              /*warning:MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE, severe:INVALID_METHOD_OVERRIDE*/set f(
+                  /*warning:INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE*/B b) => null;
             }
 
-            class T7 implements Base {
-              /*severe:INVALID_METHOD_OVERRIDE*/final B f;
+            class /*warning:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE*/T7 implements Base {
+              /*severe:INVALID_METHOD_OVERRIDE*/final B
+                  /*warning:INVALID_GETTER_OVERRIDE_RETURN_TYPE*/f = null;
             }
             class T8 implements Base {
               // two: one for the getter one for the setter.
-              /*severe:INVALID_METHOD_OVERRIDE,severe:INVALID_METHOD_OVERRIDE*/B f;
+              /*severe:INVALID_METHOD_OVERRIDE, severe:INVALID_METHOD_OVERRIDE*/B
+                  /*warning:INVALID_GETTER_OVERRIDE_RETURN_TYPE, warning:INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE*/f;
             }
          ''');
     });
 
     test('child override 2', () {
       checkFile('''
             class A {}
             class B {}
 
             class Base {
                 m(A a) {}
             }
 
             class Test extends Base {
-                /*severe:INVALID_METHOD_OVERRIDE*/m(B a) {}
+              /*severe:INVALID_METHOD_OVERRIDE*/m(
+                    /*warning:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
             }
          ''');
     });
     test('grandchild override', () {
       checkFile('''
             class A {}
             class B {}
 
             class Grandparent {
                 m(A a) {}
                 int x;
             }
             class Parent extends Grandparent {
             }
 
             class Test extends Parent {
-                /*severe:INVALID_METHOD_OVERRIDE*/m(B a) {}
+                /*severe:INVALID_METHOD_OVERRIDE*/m(
+                      /*warning:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
                 /*severe:INVALID_FIELD_OVERRIDE*/int x;
             }
          ''');
     });
 
     test('double override', () {
       checkFile('''
             class A {}
             class B {}
 
             class Grandparent {
                 m(A a) {}
             }
             class Parent extends Grandparent {
                 m(A a) {}
             }
 
             class Test extends Parent {
                 // Reported only once
-                /*severe:INVALID_METHOD_OVERRIDE*/m(B a) {}
+                /*severe:INVALID_METHOD_OVERRIDE*/m(
+                    /*warning:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
             }
          ''');
     });
 
     test('double override 2', () {
       checkFile('''
             class A {}
             class B {}
 
             class Grandparent {
                 m(A a) {}
             }
             class Parent extends Grandparent {
-                /*severe:INVALID_METHOD_OVERRIDE*/m(B a) {}
+              /*severe:INVALID_METHOD_OVERRIDE*/m(
+                  /*warning:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
             }
 
             class Test extends Parent {
                 m(B a) {}
             }
          ''');
     });
 
     test('mixin override to base', () {
       checkFile('''
             class A {}
             class B {}
 
             class Base {
                 m(A a) {}
                 int x;
             }
 
             class M1 {
                 m(B a) {}
             }
 
             class M2 {
                 int x;
             }
 
-            class T1 extends Base with /*severe:INVALID_METHOD_OVERRIDE*/M1 {}
-            class T2 extends Base with /*severe:INVALID_METHOD_OVERRIDE*/M1, /*severe:INVALID_FIELD_OVERRIDE*/M2 {}
-            class T3 extends Base with /*severe:INVALID_FIELD_OVERRIDE*/M2, /*severe:INVALID_METHOD_OVERRIDE*/M1 {}
+            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 {}
          ''');
     });
 
     test('mixin override to mixin', () {
       checkFile('''
             class A {}
             class B {}
 
             class Base {
             }
 
             class M1 {
                 m(B a) {}
                 int x;
             }
 
             class M2 {
                 m(A a) {}
                 int x;
             }
 
-            class T1 extends Base with M1, /*severe:INVALID_METHOD_OVERRIDE,severe:INVALID_FIELD_OVERRIDE*/M2 {}
+            class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1 extends Base
+                with M1,
+                /*severe:INVALID_METHOD_OVERRIDE,severe:INVALID_FIELD_OVERRIDE*/M2 {}
          ''');
     });
 
     // 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.
     test('no duplicate mixin override', () {
       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 T1 extends Base
+            class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1 extends Base
                 with M1, /*severe:INVALID_METHOD_OVERRIDE*/M2, M3 {}
          ''');
     });
 
     test('class override of interface', () {
       checkFile('''
             class A {}
             class B {}
 
             abstract class I {
                 m(A a);
             }
 
             class T1 implements I {
-                /*severe:INVALID_METHOD_OVERRIDE*/m(B a) {}
+              /*severe:INVALID_METHOD_OVERRIDE*/m(
+                  /*warning:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
             }
          ''');
     });
 
     test('base class override to child interface', () {
       checkFile('''
             class A {}
             class B {}
 
             abstract class I {
                 m(A a);
             }
 
             class Base {
                 m(B a) {}
             }
 
-
-            class T1 /*severe:INVALID_METHOD_OVERRIDE*/extends Base implements I {
-            }
+            class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1
+                /*severe:INVALID_METHOD_OVERRIDE*/extends Base implements I {}
          ''');
     });
 
     test('mixin override of interface', () {
       checkFile('''
             class A {}
             class B {}
 
             abstract class I {
                 m(A a);
             }
 
             class M {
                 m(B a) {}
             }
 
-            class T1 extends Object with /*severe:INVALID_METHOD_OVERRIDE*/M
-               implements I {}
+            class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1
+                extends Object with /*severe:INVALID_METHOD_OVERRIDE*/M
+                implements I {}
          ''');
     });
 
     // This is a case were it is incorrect to say that the base class
     // incorrectly overrides the interface.
     test('no errors if subclass correctly overrides base and interface', () {
       checkFile('''
             class A {}
             class B {}
 
             class Base {
                 m(A a) {}
             }
 
             class I1 {
                 m(B a) {}
             }
 
-            class T1 /*severe:INVALID_METHOD_OVERRIDE*/extends Base
+            class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1
+                /*severe:INVALID_METHOD_OVERRIDE*/extends Base
                 implements I1 {}
 
             class T2 extends Base implements I1 {
                 /*severe:INVALID_METHOD_OVERRIDE,severe:INVALID_METHOD_OVERRIDE*/m(a) {}
             }
 
-            class T3 extends Object with /*severe:INVALID_METHOD_OVERRIDE*/Base
+            class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T3
+                extends Object with /*severe:INVALID_METHOD_OVERRIDE*/Base
                 implements I1 {}
 
             class T4 extends Object with Base implements I1 {
                 /*severe:INVALID_METHOD_OVERRIDE,severe:INVALID_METHOD_OVERRIDE*/m(a) {}
             }
          ''');
     });
   });
 
   group('class override of grand interface', () {
     test('interface of interface of child', () {
       checkFile('''
               class A {}
               class B {}
 
               abstract class I1 {
                   m(A a);
               }
               abstract class I2 implements I1 {}
 
               class T1 implements I2 {
-                  /*severe:INVALID_METHOD_OVERRIDE*/m(B a) {}
+                /*severe:INVALID_METHOD_OVERRIDE*/m(
+                    /*warning:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
               }
            ''');
     });
     test('superclass of interface of child', () {
       checkFile('''
               class A {}
               class B {}
 
               abstract class I1 {
                   m(A a);
               }
               abstract class I2 extends I1 {}
 
               class T1 implements I2 {
-                  /*severe:INVALID_METHOD_OVERRIDE*/m(B a) {}
+                /*severe:INVALID_METHOD_OVERRIDE*/m(
+                    /*warning:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
               }
            ''');
     });
     test('mixin of interface of child', () {
       checkFile('''
               class A {}
               class B {}
 
               abstract class M1 {
                   m(A a);
               }
               abstract class I2 extends Object with M1 {}
 
               class T1 implements I2 {
-                  /*severe:INVALID_METHOD_OVERRIDE*/m(B a) {}
+                /*severe:INVALID_METHOD_OVERRIDE*/m(
+                    /*warning:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
               }
            ''');
     });
     test('interface of abstract superclass', () {
       checkFile('''
               class A {}
               class B {}
 
               abstract class I1 {
                   m(A a);
               }
               abstract class Base implements I1 {}
 
               class T1 extends Base {
-                  /*severe:INVALID_METHOD_OVERRIDE*/m(B a) {}
+                /*severe:INVALID_METHOD_OVERRIDE*/m(
+                    /*warning:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
               }
            ''');
     });
     test('interface of concrete superclass', () {
       checkFile('''
               class A {}
               class B {}
 
               abstract class I1 {
                   m(A a);
               }
 
-              // See issue #25
-              /*pass should be warning:AnalyzerError*/class Base implements I1 {
-              }
+              class /*warning: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(B a) {}
+                  m(/*warning:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
               }
            ''');
     });
   });
 
   group('mixin override of grand interface', () {
     test('interface of interface of child', () {
       checkFile('''
               class A {}
               class B {}
 
               abstract class I1 {
                   m(A a);
               }
               abstract class I2 implements I1 {}
 
               class M {
                   m(B a) {}
               }
 
-              class T1 extends Object with /*severe:INVALID_METHOD_OVERRIDE*/M
-                  implements I2 {
-              }
+              class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1
+                  extends Object with /*severe:INVALID_METHOD_OVERRIDE*/M
+                  implements I2 {}
            ''');
     });
     test('superclass of interface of child', () {
       checkFile('''
               class A {}
               class B {}
 
               abstract class I1 {
                   m(A a);
               }
               abstract class I2 extends I1 {}
 
               class M {
                   m(B a) {}
               }
 
-              class T1 extends Object with /*severe:INVALID_METHOD_OVERRIDE*/M
-                  implements I2 {
-              }
+              class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1
+                  extends Object with /*severe:INVALID_METHOD_OVERRIDE*/M
+                  implements I2 {}
            ''');
     });
     test('mixin of interface of child', () {
       checkFile('''
               class A {}
               class B {}
 
               abstract class M1 {
                   m(A a);
               }
               abstract class I2 extends Object with M1 {}
 
               class M {
                   m(B a) {}
               }
 
-              class T1 extends Object with /*severe:INVALID_METHOD_OVERRIDE*/M
-                  implements I2 {
-              }
+              class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1
+                  extends Object with /*severe:INVALID_METHOD_OVERRIDE*/M
+                  implements I2 {}
            ''');
     });
     test('interface of abstract superclass', () {
       checkFile('''
               class A {}
               class B {}
 
               abstract class I1 {
                   m(A a);
               }
               abstract class Base implements I1 {}
 
               class M {
                   m(B a) {}
               }
 
-              class T1 extends Base with /*severe:INVALID_METHOD_OVERRIDE*/M {
-              }
+              class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1 extends Base
+                  with /*severe:INVALID_METHOD_OVERRIDE*/M {}
            ''');
     });
     test('interface of concrete superclass', () {
       checkFile('''
               class A {}
               class B {}
 
               abstract class I1 {
                   m(A a);
               }
 
-              // See issue #25
-              /*pass should be warning:AnalyzerError*/class Base implements I1 {
-              }
+              class /*warning:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE*/Base
+                  implements I1 {}
 
               class M {
                   m(B a) {}
               }
 
-              class T1 extends Base with M {
-              }
+              class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1 extends Base
+                  with M {}
            ''');
     });
   });
 
   group('superclass override of grand interface', () {
     test('interface of interface of child', () {
       checkFile('''
               class A {}
               class B {}
 
               abstract class I1 {
                   m(A a);
               }
               abstract class I2 implements I1 {}
 
               class Base {
                   m(B a) {}
               }
 
-              class T1 /*severe:INVALID_METHOD_OVERRIDE*/extends Base
-                  implements I2 {
-              }
+              class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1
+                  /*severe:INVALID_METHOD_OVERRIDE*/extends Base implements I2 {}
            ''');
     });
     test('superclass of interface of child', () {
       checkFile('''
               class A {}
               class B {}
 
               abstract class I1 {
                   m(A a);
               }
               abstract class I2 extends I1 {}
 
               class Base {
                   m(B a) {}
               }
 
-              class T1 /*severe:INVALID_METHOD_OVERRIDE*/extends Base
-                  implements I2 {
-              }
+              class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1
+                  /*severe:INVALID_METHOD_OVERRIDE*/extends Base
+                  implements I2 {}
            ''');
     });
     test('mixin of interface of child', () {
       checkFile('''
               class A {}
               class B {}
 
               abstract class M1 {
                   m(A a);
               }
               abstract class I2 extends Object with M1 {}
 
               class Base {
                   m(B a) {}
               }
 
-              class T1 /*severe:INVALID_METHOD_OVERRIDE*/extends Base
-                  implements I2 {
-              }
+              class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1
+                  /*severe:INVALID_METHOD_OVERRIDE*/extends Base
+                  implements I2 {}
            ''');
     });
     test('interface of abstract superclass', () {
       checkFile('''
               class A {}
               class B {}
 
               abstract class I1 {
                   m(A a);
               }
 
               abstract class Base implements I1 {
-                  /*severe:INVALID_METHOD_OVERRIDE*/m(B a) {}
+                /*severe:INVALID_METHOD_OVERRIDE*/m(
+                    /*warning: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.
                   /*severe:INVALID_METHOD_OVERRIDE*/m(B a) {}
               }
            ''');
     });
     test('interface of concrete superclass', () {
       checkFile('''
               class A {}
               class B {}
 
               abstract class I1 {
                   m(A a);
               }
 
               class Base implements I1 {
-                  /*severe:INVALID_METHOD_OVERRIDE*/m(B a) {}
+                /*severe:INVALID_METHOD_OVERRIDE*/m(
+                    /*warning:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
               }
 
               class T1 extends Base {
                   m(B a) {}
               }
            ''');
     });
   });
 
   group('no duplicate reports from overriding interfaces', () {
     test('type overrides same method in multiple interfaces', () {
       checkFile('''
               class A {}
               class B {}
 
               abstract class I1 {
                   m(A a);
               }
               abstract class I2 implements I1 {
                   m(A a);
               }
 
-              class Base {
-              }
+              class Base {}
 
               class T1 implements I2 {
-                /*severe:INVALID_METHOD_OVERRIDE*/m(B a) {}
+                /*severe:INVALID_METHOD_OVERRIDE*/m(
+                    /*warning:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
               }
            ''');
     });
 
     test('type and base type override same method in interface', () {
       checkFile('''
               class A {}
               class B {}
 
               abstract class I1 {
                   m(A a);
               }
 
               class Base {
-                  m(B a);
+                  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(B a) {}
+                /*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 T2 /*severe:INVALID_METHOD_OVERRIDE*/extends Base
-                  implements I1 {
-              }
+              class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T2
+                  /*severe:INVALID_METHOD_OVERRIDE*/extends Base
+                  implements I1 {}
            ''');
     });
 
     test('type and mixin override same method in interface', () {
       checkFile('''
               class A {}
               class B {}
 
               abstract class I1 {
                   m(A a);
               }
 
               class M {
-                  m(B a);
+                  m(B a) {}
               }
 
               class T1 extends Object with M implements I1 {
-                /*severe:INVALID_METHOD_OVERRIDE*/m(B a) {}
+                /*severe:INVALID_METHOD_OVERRIDE*/m(
+                    /*warning:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
               }
 
-              class T2 extends Object with /*severe:INVALID_METHOD_OVERRIDE*/M
-                  implements I1 {
-              }
+              class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T2
+                  extends Object with /*severe:INVALID_METHOD_OVERRIDE*/M
+                  implements I1 {}
            ''');
     });
 
     test('two grand types override same method in interface', () {
       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 {
-              }
+              class Parent2 extends Grandparent {}
 
               // Note: otherwise both errors would be reported on this line
-              class T1 /*severe:INVALID_METHOD_OVERRIDE*/extends Parent1
-                  implements I1 {
-              }
-              class T2 /*severe:INVALID_METHOD_OVERRIDE*/extends Parent2
-                  implements I1 {
-              }
+              class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1
+                  /*severe:INVALID_METHOD_OVERRIDE*/extends Parent1
+                  implements I1 {}
+              class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T2
+                  /*severe:INVALID_METHOD_OVERRIDE*/extends Parent2
+                  implements I1 {}
            ''');
     });
 
     test('two mixins override same method in interface', () {
       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 T1 extends Object
+              class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1 extends Object
                   with /*severe:INVALID_METHOD_OVERRIDE*/M1,
                   /*severe:INVALID_METHOD_OVERRIDE*/M2
-                  implements I1 {
-              }
+                  implements I1 {}
            ''');
     });
 
     test('base type and mixin override same method in interface', () {
       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 T1 /*severe:INVALID_METHOD_OVERRIDE*/extends Base
+              class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1
+                  /*severe:INVALID_METHOD_OVERRIDE*/extends Base
                   with /*severe:INVALID_METHOD_OVERRIDE*/M
-                  implements I1 {
-              }
+                  implements I1 {}
            ''');
     });
   });
 
   test('invalid runtime checks', () {
     checkFile('''
           typedef int I2I(int x);
           typedef int D2I(x);
           typedef int II2I(int x, int y);
           typedef int DI2I(x, int y);
@@ skipping 48 matching lines @@
   group('function modifiers', () {
     test('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 => (/*severe:STATIC_TYPE_ERROR*/new Future<String>.value(/*info:DYNAMIC_CAST*/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);
 
         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 (/*severe:STATIC_TYPE_ERROR*/new Future<String>.value(/*info:DYNAMIC_CAST*/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);
+        }
 
         int y;
         Future<int> z;
 
-        void baz() async {
+        baz() async {
           int a = /*info:DYNAMIC_CAST*/await x;
           int b = await y;
           int c = await z;
-          String d = /*severe:STATIC_TYPE_ERROR*/await z;
+          String d = /*warning: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);
           }
         }
     ''');
     });
 
     test('async*', () {
       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 (/*severe:STATIC_TYPE_ERROR*/new Stream<int>()); }
+        Stream<int> bar3() async* { yield /*info:DYNAMIC_CAST*/x; }
+        Stream<int> bar4() async* { yield /*warning: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); }
+        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()); }
+        Stream<int> baz5() async* { yield* /*info:INFERRED_TYPE_ALLOCATION*/new Stream(); }
     ''');
     });
 
     test('sync*', () {
       checkFile('''
-        import 'dart:async';
-
         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 (/*severe:STATIC_TYPE_ERROR*/new Iterable<int>()); }
+        Iterable<int> bar3() sync* { yield /*info:DYNAMIC_CAST*/x; }
+        Iterable<int> bar4() sync* {
+          yield /*warning:YIELD_OF_INVALID_TYPE*/new /*warning:NEW_WITH_ABSTRACT_CLASS*/Iterable<int>();

[Leaf, 2016/03/10 22:58:25]

I think the extra error here is just noise, the test should have a valid thing
of type Iterable<int> here.  Maybe just yield bar3()?

[Bob Nystrom, 2016/03/15 00:08:13]

Ah, great idea. I didn't want to change it to List because I thought it might be
useful for the test to validate it works with any iterable.

Done.

+        }
 
-        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* new Iterable<int>(); }
-        Iterable<int> baz5() sync* { yield* (/*info:INFERRED_TYPE_ALLOCATION*/new Iterable()); }
+        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* new /*warning:NEW_WITH_ABSTRACT_CLASS*/Iterable<int>();

[Leaf, 2016/03/10 22:58:25]

ditto.

[Bob Nystrom, 2016/03/15 00:08:13]

Done.

+        }
+        Iterable<int> baz5() sync* {
+          yield* /*info:INFERRED_TYPE_ALLOCATION*/new /*warning:NEW_WITH_ABSTRACT_CLASS*/Iterable();

[Leaf, 2016/03/10 22:58:25]

and again.

[Bob Nystrom, 2016/03/15 00:08:13]

Changed this to new List() since we want to test inferring the type argument.

+        }
     ''');
     });
   });
 }