Roll Observatory deps (charted -> ^0.3.0)

packages/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 test.src.task.strong.checker_test;
+
+import 'package:unittest/unittest.dart';
+
+import 'strong_test_helper.dart';
+
+void main() {
+  testChecker('ternary operator', {
+    '/main.dart': '''
+        abstract class Comparable<T> {
+          int compareTo(T other);
+          static int compare(Comparable a, Comparable b) => a.compareTo(b);
+        }
+        typedef int Comparator<T>(T a, T b);
+
+        typedef bool _Predicate<T>(T value);
+
+        class SplayTreeMap<K, V> {
+          Comparator<K> _comparator;
+          _Predicate _validKey;
+
+          // Initializing _comparator needs a cast, since K may not always be
+          // Comparable.
+          // Initializing _validKey shouldn't need a cast.  Currently
+          // it requires inference to work because of dartbug.com/23381
+          SplayTreeMap([int compare(K key1, K key2),
+                        bool isValidKey(potentialKey)]) {
+            : _comparator = /*warning:DownCastComposite*/(compare == null) ? Comparable.compare : compare,
+              _validKey = /*info:InferredType should be pass*/(isValidKey != null) ? isValidKey : ((v) => true);
+              _Predicate<Object> _v = /*warning:DownCastComposite*/(isValidKey != null) ? isValidKey : ((v) => true);
+              _v = /*info:InferredType should be pass*/(isValidKey != null) ? _v : ((v) => true);
+          }
+        }
+        void main() {
+          Object obj = 42;
+          dynamic dyn = 42;
+          int i = 42;
+
+          // Check the boolean conversion of the condition.
+          print((/*severe:StaticTypeError*/i) ? false : true);
+          print((/*info:DownCastImplicit*/obj) ? false : true);
+          print((/*info:DynamicCast*/dyn) ? false : true);
+        }
+      '''
+  });
+
+  testChecker('if/for/do/while statements use boolean conversion', {
+    '/main.dart': '''
+      main() {
+        dynamic d = 42;
+        Object obj = 42;
+        int i = 42;
+        bool b = false;
+
+        if (b) {}
+        if (/*info:DynamicCast*/dyn) {}
+        if (/*info:DownCastImplicit*/obj) {}
+        if (/*severe:StaticTypeError*/i) {}
+
+        while (b) {}
+        while (/*info:DynamicCast*/dyn) {}
+        while (/*info:DownCastImplicit*/obj) {}
+        while (/*severe:StaticTypeError*/i) {}
+
+        do {} while (b);
+        do {} while (/*info:DynamicCast*/dyn);
+        do {} while (/*info:DownCastImplicit*/obj);
+        do {} while (/*severe:StaticTypeError*/i);
+
+        for (;b;) {}
+        for (;/*info:DynamicCast*/dyn;) {}
+        for (;/*info:DownCastImplicit*/obj;) {}
+        for (;/*severe:StaticTypeError*/i;) {}
+      }
+    '''
+  });
+
+  testChecker('dynamic invocation', {
+    '/main.dart': '''
+
+      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;
+          // The analyzer has what I believe is a bug (dartbug.com/23252) which
+          // causes the return type of calls to f to be treated as dynamic.
+          x = /*info:DynamicCast should be pass*/f(3);
+          x = /*severe:StaticTypeError*/f.col(3.0);
+          y = /*info:DynamicCast should be severe:StaticTypeError*/f(3);
+          y = f.col(3.0);
+          f(/*severe:StaticTypeError*/3.0);
+          f.col(/*severe:StaticTypeError*/3);
+        }
+        {
+          Function f = new B();
+          int x;
+          double y;
+          x = /*info:DynamicCast, info:DynamicInvoke*/f(3);
+          x = /*info:DynamicCast, info:DynamicInvoke*/f.col(3.0);
+          y = /*info:DynamicCast, info:DynamicInvoke*/f(3);
+          y = /*info:DynamicCast, info:DynamicInvoke*/f.col(3.0);
+          (/*info:DynamicInvoke*/f(3.0));
+          (/*info:DynamicInvoke*/f.col(3));
+        }
+        {
+          A f = new B();
+          int x;
+          double y;
+          x = /*info:DynamicCast, info:DynamicInvoke*/f(3);
+          y = /*info:DynamicCast, info:DynamicInvoke*/f(3);
+          (/*info:DynamicInvoke*/f(3.0));
+        }
+      }
+    '''
+  });
+
+  testChecker('conversion and dynamic invoke', {
+    '/helper.dart': '''
+      dynamic toString = (int x) => x + 42;
+      dynamic hashCode = "hello";
+      ''',
+    '/main.dart': '''
+      import 'helper.dart' as helper;
+
+      class A {
+        String x = "hello world";
+
+        void baz1(y) => x + /*info:DynamicCast*/y;
+        static baz2(y) => /*info:DynamicInvoke*/y + y;
+      }
+
+      void foo(String str) {
+        print(str);
+      }
+
+      class B {
+        String toString([int arg]) => arg.toString();
+      }
+
+      void bar(a) {
+        foo(/*info:DynamicCast,info:DynamicInvoke*/a.x);
+      }
+
+      baz() => new B();
+
+      typedef DynFun(x);
+      typedef StrFun(String x);
+
+      var bar1 = bar;
+
+      void main() {
+        var a = new A();
+        bar(a);
+        (/*info:DynamicInvoke*/bar1(a));
+        var b = bar;
+        (/*info:DynamicInvoke*/b(a));
+        var f1 = foo;
+        f1("hello");
+        dynamic f2 = foo;
+        (/*info:DynamicInvoke*/f2("hello"));
+        DynFun f3 = foo;
+        (/*info:DynamicInvoke*/f3("hello"));
+        (/*info:DynamicInvoke*/f3(42));
+        StrFun f4 = foo;
+        f4("hello");
+        a.baz1("hello");
+        var b1 = a.baz1;
+        (/*info:DynamicInvoke*/b1("hello"));
+        A.baz2("hello");
+        var b2 = A.baz2;
+        (/*info:DynamicInvoke*/b2("hello"));
+
+        dynamic a1 = new B();
+        (/*info:DynamicInvoke*/a1.x);
+        a1.toString();
+        (/*info:DynamicInvoke*/a1.toString(42));
+        var toStringClosure = a1.toString;
+        (/*info:DynamicInvoke*/a1.toStringClosure());
+        (/*info:DynamicInvoke*/a1.toStringClosure(42));
+        (/*info:DynamicInvoke*/a1.toStringClosure("hello"));
+        a1.hashCode;
+
+        dynamic toString = () => null;
+        (/*info:DynamicInvoke*/toString());
+
+        (/*info:DynamicInvoke*/helper.toString());
+        var toStringClosure2 = helper.toString;
+        (/*info:DynamicInvoke*/toStringClosure2());
+        int hashCode = /*info:DynamicCast*/helper.hashCode;
+
+        baz().toString();
+        baz().hashCode;
+      }
+    '''
+  });
+
+  testChecker('Constructors', {
+    '/main.dart': '''
+      const num z = 25;
+      Object obj = "world";
+
+      class A {
+        int x;
+        String y;
+
+        A(this.x) : this.y = /*severe:StaticTypeError*/42;
+
+        A.c1(p): this.x = /*info:DownCastImplicit*/z, this.y = /*info:DynamicCast*/p;
+
+        A.c2(this.x, this.y);
+
+        A.c3(/*severe:InvalidParameterDeclaration*/num this.x, String this.y);
+      }
+
+      class B extends A {
+        B() : super(/*severe:StaticTypeError*/"hello");
+
+        B.c2(int x, String y) : super.c2(/*severe:StaticTypeError*/y, 
+                                         /*severe:StaticTypeError*/x);
+
+        B.c3(num x, Object y) : super.c3(x, /*info:DownCastImplicit*/y);
+      }
+
+      void main() {
+         A a = new A.c2(/*info:DownCastImplicit*/z, /*severe:StaticTypeError*/z);
+         var b = new B.c2(/*severe:StaticTypeError*/"hello", /*info:DownCastImplicit*/obj);
+      }
+   '''
+  });
+
+  testChecker('Unbound variable', {
+    '/main.dart': '''
+      void main() {
+         dynamic y = /*pass should be severe:StaticTypeError*/unboundVariable;
+      }
+   '''
+  });
+
+  testChecker('Unbound type name', {
+    '/main.dart': '''
+      void main() {
+         /*pass should be severe:StaticTypeError*/AToB y;
+      }
+   '''
+  });
+
+  testChecker('Ground type subtyping: dynamic is top', {
+    '/main.dart': '''
+
+      class A {}
+      class B extends A {}
+
+      void main() {
+         dynamic y;
+         Object o;
+         int i = 0;
+         double d = 0.0;
+         num n;
+         A a;
+         B b;
+         y = o;
+         y = i;
+         y = d;
+         y = n;
+         y = a;
+         y = b;
+      }
+   '''
+  });
+
+  testChecker('Ground type subtyping: dynamic downcasts', {
+    '/main.dart': '''
+
+      class A {}
+      class B extends A {}
+
+      void main() {
+         dynamic y;
+         Object o;
+         int i = 0;
+         double d = 0.0;
+         num n;
+         A a;
+         B b;
+         o = y;
+         i = /*info:DynamicCast*/y;
+         d = /*info:DynamicCast*/y;
+         n = /*info:DynamicCast*/y;
+         a = /*info:DynamicCast*/y;
+         b = /*info:DynamicCast*/y;
+      }
+   '''
+  });
+
+  testChecker('Ground type subtyping: assigning a class', {
+    '/main.dart': '''
+
+      class A {}
+      class B extends A {}
+
+      void main() {
+         dynamic y;
+         Object o;
+         int i = 0;
+         double d = 0.0;
+         num n;
+         A a;
+         B b;
+         y = a;
+         o = a;
+         i = /*severe:StaticTypeError*/a;
+         d = /*severe:StaticTypeError*/a;
+         n = /*severe:StaticTypeError*/a;
+         a = a;
+         b = /*info:DownCastImplicit*/a;
+      }
+   '''
+  });
+
+  testChecker('Ground type subtyping: assigning a subclass', {
+    '/main.dart': '''
+
+      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:StaticTypeError*/b;
+         d = /*severe:StaticTypeError*/b;
+         n = /*severe:StaticTypeError*/b;
+         a = b;
+         b = b;
+         c = /*severe:StaticTypeError*/b;
+      }
+   '''
+  });
+
+  testChecker('Ground type subtyping: interfaces', {
+    '/main.dart': '''
+
+      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:DownCastImplicit*/top;
+           left = left;
+           left = /*severe:StaticTypeError*/right;
+           left = bot;
+         }
+         {
+           right = /*info:DownCastImplicit*/top;
+           right = /*severe:StaticTypeError*/left;
+           right = right;
+           right = bot;
+         }
+         {
+           bot = /*info:DownCastImplicit*/top;
+           bot = /*info:DownCastImplicit*/left;
+           bot = /*info:DownCastImplicit*/right;
+           bot = bot;
+         }
+      }
+   '''
+  });
+
+  testChecker('Function typing and subtyping: int and object', {
+    '/main.dart': '''
+
+      typedef Object Top(int x);      // Top of the lattice
+      typedef int Left(int x);        // Left branch
+      typedef int Left2(int x);       // Left branch
+      typedef Object Right(Object x); // Right branch
+      typedef int Bot(Object x);      // Bottom of the lattice
+
+      Object top(int x) => x;
+      int left(int x) => x;
+      Object right(Object x) => x;
+      int _bot(Object x) => /*info:DownCastImplicit*/x;
+      int bot(Object x) => x as int;
+
+      void main() {
+        { // Check typedef equality
+          Left f = left;
+          Left2 g = f;
+        }
+        {
+          Top f;
+          f = top;
+          f = left;
+          f = right;
+          f = bot;
+        }
+        {
+          Left f;
+          f = /*warning:DownCastComposite*/top;
+          f = left;
+          f = /*warning:DownCastComposite*/right; // Should we reject this?
+          f = bot;
+        }
+        {
+          Right f;
+          f = /*warning:DownCastComposite*/top;
+          f = /*warning:DownCastComposite*/left; // Should we reject this?
+          f = right;
+          f = bot;
+        }
+        {
+          Bot f;
+          f = /*warning:DownCastComposite*/top;
+          f = /*warning:DownCastComposite*/left;
+          f = /*warning:DownCastComposite*/right;
+          f = bot;
+        }
+      }
+   '''
+  });
+
+  testChecker('Function typing and subtyping: classes', {
+    '/main.dart': '''
+
+      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:DownCastImplicit*/x;
+      B bot(A x) => x as B;
+      A top(B x) => x;
+      A right(A x) => x;
+
+      void main() {
+        { // Check typedef equality
+          Left f = left;
+          Left2 g = f;
+        }
+        {
+          Top f;
+          f = top;
+          f = left;
+          f = right;
+          f = bot;
+        }
+        {
+          Left f;
+          f = /*warning:DownCastComposite*/top;
+          f = left;
+          f = /*warning:DownCastComposite*/right; // Should we reject this?
+          f = bot;
+        }
+        {
+          Right f;
+          f = /*warning:DownCastComposite*/top;
+          f = /*warning:DownCastComposite*/left; // Should we reject this?
+          f = right;
+          f = bot;
+        }
+        {
+          Bot f;
+          f = /*warning:DownCastComposite*/top;
+          f = /*warning:DownCastComposite*/left;
+          f = /*warning:DownCastComposite*/right;
+          f = bot;
+        }
+      }
+   '''
+  });
+
+  testChecker('Function typing and subtyping: dynamic', {
+    '/main.dart': '''
+
+      class A {}
+
+      typedef dynamic Top(dynamic x);     // Top of the lattice
+      typedef dynamic Left(A x);          // Left branch
+      typedef A Right(dynamic x);         // Right branch
+      typedef A Bottom(A x);              // Bottom of the lattice
+
+      dynamic left(A x) => x;
+      A bot(A x) => x;
+      dynamic top(dynamic x) => x;
+      A right(dynamic x) => /*info:DynamicCast*/x;
+
+      void main() {
+        {
+          Top f;
+          f = top;
+          f = left;
+          f = right;
+          f = bot;
+        }
+        {
+          Left f;
+          f = /*warning:DownCastComposite*/top;
+          f = left;
+          f = /*warning:DownCastComposite*/right;
+          f = bot;
+        }
+        {
+          Right f;
+          f = /*warning:DownCastComposite*/top;
+          f = /*warning:DownCastComposite*/left;
+          f = right;
+          f = bot;
+        }
+        {
+          Bottom f;
+          f = /*warning:DownCastComposite*/top;
+          f = /*warning:DownCastComposite*/left;
+          f = /*warning:DownCastComposite*/right;
+          f = bot;
+        }
+      }
+   '''
+  });
+
+  testChecker('Function typing and subtyping: function literal variance', {
+    '/main.dart': '''
+
+      class A {}
+      class B extends A {}
+
+      typedef T Function2<S, T>(S z);
+
+      A top(B x) => x;
+      B left(B x) => x;
+      A right(A x) => x;
+      B bot(A x) => x as B;
+
+      void main() {
+        {
+          Function2<B, A> f;
+          f = top;
+          f = left;
+          f = right;
+          f = bot;
+        }
+        {
+          Function2<B, B> f;
+          f = /*warning:DownCastComposite*/top;
+          f = left;
+          f = /*warning:DownCastComposite*/right; // Should we reject this?
+          f = bot;
+        }
+        {
+          Function2<A, A> f;
+          f = /*warning:DownCastComposite*/top;
+          f = /*warning:DownCastComposite*/left; // Should we reject this?
+          f = right;
+          f = bot;
+        }
+        {
+          Function2<A, B> f;
+          f = /*warning:DownCastComposite*/top;
+          f = /*warning:DownCastComposite*/left;
+          f = /*warning:DownCastComposite*/right;
+          f = bot;
+        }
+      }
+   '''
+  });
+
+  testChecker('Function typing and subtyping: function variable variance', {
+    '/main.dart': '''
+
+      class A {}
+      class B extends A {}
+
+      typedef T Function2<S, T>(S z);
+
+      void main() {
+        {
+          Function2<B, A> top;
+          Function2<B, B> left;
+          Function2<A, A> right;
+          Function2<A, B> bot;
+
+          top = right;
+          top = bot;
+          top = top;
+          top = left;
+
+          left = /*warning:DownCastComposite*/top;
+          left = left;
+          left = /*warning:DownCastComposite*/right; // Should we reject this?
+          left = bot;
+
+          right = /*warning:DownCastComposite*/top;
+          right = /*warning:DownCastComposite*/left; // Should we reject this?
+          right = right;
+          right = bot;
+
+          bot = /*warning:DownCastComposite*/top;
+          bot = /*warning:DownCastComposite*/left;
+          bot = /*warning:DownCastComposite*/right;
+          bot = bot;
+        }
+      }
+   '''
+  });
+
+  testChecker('Function typing and subtyping: higher order function literals', {
+    '/main.dart': '''
+
+      class A {}
+      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:DownCastComposite*/f;
+      AToB bot(BToA f) => f as AToB;
+
+      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:DownCastComposite*/f;
+      Function2<A, B> bot(BToA f) => f as Function2<A, B>;
+
+
+      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:DownCastComposite*/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;
+        }
+        {
+          Function2<AToB, AToB> f; // Left
+          f = /*warning:DownCastComposite*/top;
+          f = left;
+          f = /*warning:DownCastComposite*/right; // Should we reject this?
+          f = bot;
+        }
+        {
+          Function2<BToA, BToA> f; // Right
+          f = /*warning:DownCastComposite*/top;
+          f = /*warning:DownCastComposite*/left; // Should we reject this?
+          f = right;
+          f = bot;
+        }
+        {
+          Function2<BToA, AToB> f; // Bot
+          f = bot;
+          f = /*warning:DownCastComposite*/left;
+          f = /*warning:DownCastComposite*/top;
+          f = /*warning:DownCastComposite*/left;
+        }
+      }
+   '''
+  });
+
+  testChecker(
+      'Function typing and subtyping: higher order function variables', {
+    '/main.dart': '''
+
+    class A {}
+    class B extends A {}
+
+    typedef T Function2<S, T>(S z);
+
+    void main() {
+      {
+        Function2<Function2<A, B>, Function2<B, A>> top;
+        Function2<Function2<B, A>, Function2<B, A>> right;
+        Function2<Function2<A, B>, Function2<A, B>> left;
+        Function2<Function2<B, A>, Function2<A, B>> bot;
+
+        top = right;
+        top = bot;
+        top = top;
+        top = left;
+
+        left = /*warning:DownCastComposite*/top;
+        left = left;
+        left =
+            /*warning:DownCastComposite should be severe:StaticTypeError*/right;
+        left = bot;
+
+        right = /*warning:DownCastComposite*/top;
+        right =
+            /*warning:DownCastComposite should be severe:StaticTypeError*/left;
+        right = right;
+        right = bot;
+
+        bot = /*warning:DownCastComposite*/top;
+        bot = /*warning:DownCastComposite*/left;
+        bot = /*warning:DownCastComposite*/right;
+        bot = bot;
+      }
+    }
+   '''
+  });
+
+  testChecker('Function typing and subtyping: named and optional parameters', {
+    '/main.dart': '''
+
+      class A {}
+
+      typedef A FR(A x);
+      typedef A FO([A x]);
+      typedef A FN({A x});
+      typedef A FRR(A x, A y);
+      typedef A FRO(A x, [A y]);
+      typedef A FRN(A x, {A n});
+      typedef A FOO([A x, A y]);
+      typedef A FNN({A x, A y});
+      typedef A FNNN({A z, A y, A x});
+
+      void main() {
+         FR r;
+         FO o;
+         FN n;
+         FRR rr;
+         FRO ro;
+         FRN rn;
+         FOO oo;
+         FNN nn;
+         FNNN nnn;
+
+         r = r;
+         r = o;
+         r = /*severe:StaticTypeError*/n;
+         r = /*severe:StaticTypeError*/rr;
+         r = ro;
+         r = rn;
+         r = oo;
+         r = /*severe:StaticTypeError*/nn;
+         r = /*severe:StaticTypeError*/nnn;
+
+         o = /*warning:DownCastComposite*/r;
+         o = o;
+         o = /*severe:StaticTypeError*/n;
+         o = /*severe:StaticTypeError*/rr;
+         o = /*severe:StaticTypeError*/ro;
+         o = /*severe:StaticTypeError*/rn;
+         o = oo;
+         o = /*severe:StaticTypeError*/nn
+         o = /*severe:StaticTypeError*/nnn;
+
+         n = /*severe:StaticTypeError*/r;
+         n = /*severe:StaticTypeError*/o;
+         n = n;
+         n = /*severe:StaticTypeError*/rr;
+         n = /*severe:StaticTypeError*/ro;
+         n = /*severe:StaticTypeError*/rn;
+         n = /*severe:StaticTypeError*/oo;
+         n = nn;
+         n = nnn;
+
+         rr = /*severe:StaticTypeError*/r;
+         rr = /*severe:StaticTypeError*/o;
+         rr = /*severe:StaticTypeError*/n;
+         rr = rr;
+         rr = ro;
+         rr = /*severe:StaticTypeError*/rn;
+         rr = oo;
+         rr = /*severe:StaticTypeError*/nn;
+         rr = /*severe:StaticTypeError*/nnn;
+
+         ro = /*warning:DownCastComposite*/r;
+         ro = /*severe:StaticTypeError*/o;
+         ro = /*severe:StaticTypeError*/n;
+         ro = /*warning:DownCastComposite*/rr;
+         ro = ro;
+         ro = /*severe:StaticTypeError*/rn;
+         ro = oo;
+         ro = /*severe:StaticTypeError*/nn;
+         ro = /*severe:StaticTypeError*/nnn;
+
+         rn = /*warning:DownCastComposite*/r;
+         rn = /*severe:StaticTypeError*/o;
+         rn = /*severe:StaticTypeError*/n;
+         rn = /*severe:StaticTypeError*/rr;
+         rn = /*severe:StaticTypeError*/ro;
+         rn = rn;
+         rn = /*severe:StaticTypeError*/oo;
+         rn = /*severe:StaticTypeError*/nn;
+         rn = /*severe:StaticTypeError*/nnn;
+
+         oo = /*warning:DownCastComposite*/r;
+         oo = /*warning:DownCastComposite*/o;
+         oo = /*severe:StaticTypeError*/n;
+         oo = /*warning:DownCastComposite*/rr;
+         oo = /*warning:DownCastComposite*/ro;
+         oo = /*severe:StaticTypeError*/rn;
+         oo = oo;
+         oo = /*severe:StaticTypeError*/nn;
+         oo = /*severe:StaticTypeError*/nnn;
+
+         nn = /*severe:StaticTypeError*/r;
+         nn = /*severe:StaticTypeError*/o;
+         nn = /*warning:DownCastComposite*/n;
+         nn = /*severe:StaticTypeError*/rr;
+         nn = /*severe:StaticTypeError*/ro;
+         nn = /*severe:StaticTypeError*/rn;
+         nn = /*severe:StaticTypeError*/oo;
+         nn = nn;
+         nn = nnn;
+
+         nnn = /*severe:StaticTypeError*/r;
+         nnn = /*severe:StaticTypeError*/o;
+         nnn = /*warning:DownCastComposite*/n;
+         nnn = /*severe:StaticTypeError*/rr;
+         nnn = /*severe:StaticTypeError*/ro;
+         nnn = /*severe:StaticTypeError*/rn;
+         nnn = /*severe:StaticTypeError*/oo;
+         nnn = /*warning:DownCastComposite*/nn;
+         nnn = nnn;
+      }
+   '''
+  });
+
+  testChecker('Function subtyping: objects with call methods', {
+    '/main.dart': '''
+
+      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:StaticTypeError*/new B();
+           f = i2i;
+           f = /*warning:DownCastComposite*/n2n;
+           f = /*warning:DownCastComposite*/i2i as Object;
+           f = /*warning:DownCastComposite*/n2n as Function;
+         }
+         {
+           N2N f;
+           f = /*severe:StaticTypeError*/new A();
+           f = new B();
+           f = /*warning:DownCastComposite*/i2i;
+           f = n2n;
+           f = /*warning:DownCastComposite*/i2i as Object;
+           f = /*warning:DownCastComposite*/n2n as Function;
+         }
+         {
+           A f;
+           f = new A();
+           f = /*severe:StaticTypeError*/new B();
+           f = /*severe:StaticTypeError*/i2i;
+           f = /*severe:StaticTypeError*/n2n;
+           f = /*info:DownCastImplicit*/i2i as Object;
+           f = /*info:DownCastImplicit*/n2n as Function;
+         }
+         {
+           B f;
+           f = /*severe:StaticTypeError*/new A();
+           f = new B();
+           f = /*severe:StaticTypeError*/i2i;
+           f = /*severe:StaticTypeError*/n2n;
+           f = /*info:DownCastImplicit*/i2i as Object;
+           f = /*info:DownCastImplicit*/n2n as Function;
+         }
+         {
+           Function f;
+           f = new A();
+           f = new B();
+           f = i2i;
+           f = n2n;
+           f = /*info:DownCastImplicit*/i2i as Object;
+           f = (n2n as Function);
+         }
+      }
+   '''
+  });
+
+  testChecker('Function typing and subtyping: void', {
+    '/main.dart': '''
+
+      class A {
+        void bar() => null;
+        void foo() => bar; // allowed
+      }
+   '''
+  });
+
+  testChecker('Relaxed casts', {
+    '/main.dart': '''
+
+      class A {}
+
+      class L<T> {}
+      class M<T> extends L<T> {}
+      //     L<dynamic|Object>
+      //    /              \
+      // M<dynamic|Object>  L<A>
+      //    \              /
+      //          M<A>
+      // In normal Dart, there are additional edges
+      //  from M<A> to M<dynamic>
+      //  from L<A> to M<dynamic>
+      //  from L<A> to L<dynamic>
+      void main() {
+        L lOfDs;
+        L<Object> lOfOs;
+        L<A> lOfAs;
+
+        M mOfDs;
+        M<Object> mOfOs;
+        M<A> mOfAs;
+
+        {
+          lOfDs = mOfDs;
+          lOfDs = mOfOs;
+          lOfDs = mOfAs;
+          lOfDs = lOfDs;
+          lOfDs = lOfOs;
+          lOfDs = lOfAs;
+        }
+        {
+          lOfOs = mOfDs;
+          lOfOs = mOfOs;
+          lOfOs = mOfAs;
+          lOfOs = lOfDs;
+          lOfOs = lOfOs;
+          lOfOs = lOfAs;
+        }
+        {
+          lOfAs = /*warning:DownCastComposite*/mOfDs;
+          lOfAs = /*severe:StaticTypeError*/mOfOs;
+          lOfAs = mOfAs;
+          lOfAs = /*warning:DownCastComposite*/lOfDs;
+          lOfAs = /*warning:DownCastComposite*/lOfOs;
+          lOfAs = lOfAs;
+        }
+        {
+          mOfDs = mOfDs;
+          mOfDs = mOfOs;
+          mOfDs = mOfAs;
+          mOfDs = /*info:DownCastImplicit*/lOfDs;
+          mOfDs = /*info:DownCastImplicit*/lOfOs;
+          mOfDs = /*info:DownCastImplicit*/lOfAs;
+        }
+        {
+          mOfOs = mOfDs;
+          mOfOs = mOfOs;
+          mOfOs = mOfAs;
+          mOfOs = /*info:DownCastImplicit*/lOfDs;
+          mOfOs = /*info:DownCastImplicit*/lOfOs;
+          mOfOs = /*severe:StaticTypeError*/lOfAs;
+        }
+        {
+          mOfAs = /*warning:DownCastComposite*/mOfDs;
+          mOfAs = /*warning:DownCastComposite*/mOfOs;
+          mOfAs = mOfAs;
+          mOfAs = /*warning:DownCastComposite*/lOfDs;
+          mOfAs = /*warning:DownCastComposite*/lOfOs;
+          mOfAs = /*warning:DownCastComposite*/lOfAs;
+        }
+
+      }
+   '''
+  });
+
+  testChecker('Type checking literals', {
+    '/main.dart': '''
+          test() {
+            num n = 3;
+            int i = 3;
+            String s = "hello";
+            {
+               List<int> l = <int>[i];
+               l = <int>[/*severe:StaticTypeError*/s];
+               l = <int>[/*info:DownCastImplicit*/n];
+               l = <int>[i, /*info:DownCastImplicit*/n, /*severe:StaticTypeError*/s];
+            }
+            {
+               List l = [i];
+               l = [s];
+               l = [n];
+               l = [i, n, s];
+            }
+            {
+               Map<String, int> m = <String, int>{s: i};
+               m = <String, int>{s: /*severe:StaticTypeError*/s};
+               m = <String, int>{s: /*info:DownCastImplicit*/n};
+               m = <String, int>{s: i,
+                                 s: /*info:DownCastImplicit*/n,
+                                 s: /*severe:StaticTypeError*/s};
+            }
+           // TODO(leafp): We can't currently test for key errors since the
+           // error marker binds to the entire entry.
+            {
+               Map m = {s: i};
+               m = {s: s};
+               m = {s: n};
+               m = {s: i,
+                    s: n,
+                    s: s};
+               m = {i: s,
+                    n: s,
+                    s: s};
+            }
+          }
+   '''
+  });
+
+  testChecker('casts in constant contexts', {
+    '/main.dart': '''
+          class A {
+            static const num n = 3.0;
+            static const int i = /*info:AssignmentCast*/n;
+            final int fi;
+            const A(num a) : this.fi = /*info:DownCastImplicit*/a;
+          }
+          class B extends A {
+            const B(Object a) : super(/*info:DownCastImplicit*/a);
+          }
+          void foo(Object o) {
+            var a = const A(/*info:DownCastImplicit*/o);
+          }
+     '''
+  });
+
+  testChecker('casts in conditionals', {
+    '/main.dart': '''
+          main() {
+            bool b = true;
+            num x = b ? 1 : 2.3;
+            int y = /*info:AssignmentCast*/b ? 1 : 2.3;
+            String z = !b ? "hello" : null;
+            z = b ? null : "hello";
+          }
+      '''
+  });
+
+  testChecker('redirecting constructor', {
+    '/main.dart': '''
+          class A {
+            A(A x) {}
+            A.two() : this(/*severe:StaticTypeError*/3);
+          }
+       '''
+  });
+
+  testChecker('super constructor', {
+    '/main.dart': '''
+          class A { A(A x) {} }
+          class B extends A {
+            B() : super(/*severe:StaticTypeError*/3);
+          }
+       '''
+  });
+
+  testChecker('field/field override', {
+    '/main.dart': '''
+          class A {}
+          class B extends A {}
+          class C extends B {}
+
+          class Base {
+            B f1;
+            B f2;
+            B f3;
+            B f4;
+          }
+
+          class Child extends Base {
+            /*severe:InvalidMethodOverride*/A f1; // invalid for getter
+            /*severe:InvalidMethodOverride*/C f2; // invalid for setter
+            var f3;
+            /*severe:InvalidMethodOverride,severe:InvalidMethodOverride*/dynamic f4;
+          }
+       '''
+  });
+
+  testChecker('getter/getter override', {
+    '/main.dart': '''
+          class A {}
+          class B extends A {}
+          class C extends B {}
+
+          abstract class Base {
+            B get f1;
+            B get f2;
+            B get f3;
+            B get f4;
+          }
+
+          class Child extends Base {
+            /*severe:InvalidMethodOverride*/A get f1 => null;
+            C get f2 => null;
+            get f3 => null;
+            /*severe:InvalidMethodOverride*/dynamic get f4 => null;
+          }
+       '''
+  });
+
+  testChecker('field/getter override', {
+    '/main.dart': '''
+          class A {}
+          class B extends A {}
+          class C extends B {}
+
+          abstract class Base {
+            B f1;
+            B f2;
+            B f3;
+            B f4;
+          }
+
+          class Child extends Base {
+            /*severe:InvalidMethodOverride*/A get f1 => null;
+            C get f2 => null;
+            get f3 => null;
+            /*severe:InvalidMethodOverride*/dynamic get f4 => null;
+          }
+       '''
+  });
+
+  testChecker('setter/setter override', {
+    '/main.dart': '''
+          class A {}
+          class B extends A {}
+          class C extends B {}
+
+          abstract class Base {
+            void set f1(B value);
+            void set f2(B value);
+            void set f3(B value);
+            void set f4(B value);
+            void set f5(B value);
+          }
+
+          class Child extends Base {
+            void set f1(A value) {}
+            /*severe:InvalidMethodOverride*/void set f2(C value) {}
+            void set f3(value) {}
+            /*severe:InvalidMethodOverride*/void set f4(dynamic value) {}
+            set f5(B value) {}
+          }
+       '''
+  });
+
+  testChecker('field/setter override', {
+    '/main.dart': '''
+          class A {}
+          class B extends A {}
+          class C extends B {}
+
+          class Base {
+            B f1;
+            B f2;
+            B f3;
+            B f4;
+            B f5;
+          }
+
+          class Child extends Base {
+            B get f1 => null;
+            B get f2 => null;
+            B get f3 => null;
+            B get f4 => null;
+            B get f5 => null;
+
+            void set f1(A value) {}
+            /*severe:InvalidMethodOverride*/void set f2(C value) {}
+            void set f3(value) {}
+            /*severe:InvalidMethodOverride*/void set f4(dynamic value) {}
+            set f5(B value) {}
+          }
+       '''
+  });
+
+  testChecker('method override', {
+    '/main.dart': '''
+          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);
+          }
+
+          class Child extends Base {
+            /*severe:InvalidMethodOverride*/A m1(A value) {}
+            /*severe:InvalidMethodOverride*/C m2(C value) {}
+            /*severe:InvalidMethodOverride*/A m3(C value) {}
+            C m4(A value) {}
+            m5(value) {}
+            /*severe:InvalidMethodOverride*/dynamic m6(dynamic value) {}
+          }
+       '''
+  });
+
+  testChecker('unary operators', {
+    '/main.dart': '''
+      class A {
+        A operator ~() {}
+        A operator +(int x) {}
+        A operator -(int x) {}
+        A operator -() {}
+      }
+
+      foo() => new A();
+
+      test() {
+        A a = new A();
+        var c = foo();
+
+        ~a;
+        (/*info:DynamicInvoke*/~d);
+
+        !/*severe:StaticTypeError*/a;
+        !/*info:DynamicCast*/d;
+
+        -a;
+        (/*info:DynamicInvoke*/-d);
+
+        ++a;
+        --a;
+        (/*info:DynamicInvoke*/++d);
+        (/*info:DynamicInvoke*/--d);
+
+        a++;
+        a--;
+        (/*info:DynamicInvoke*/d++);
+        (/*info:DynamicInvoke*/d--);
+      }'''
+  });
+
+  testChecker('binary and index operators', {
+    '/main.dart': '''
+          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) {}
+          }
+
+          class B {
+            A operator -(B b) {}
+          }
+
+          foo() => new A();
+
+          test() {
+            A a = new A();
+            B b = new B();
+            var c = foo();
+            a = a * b;
+            a = a * /*info:DynamicCast*/c;
+            a = a / b;
+            a = a ~/ b;
+            a = a % b;
+            a = a + b;
+            a = a + /*severe:StaticTypeError*/a;
+            a = a - b;
+            b = /*severe:StaticTypeError*/b - b;
+            a = a << b;
+            a = a >> b;
+            a = a & b;
+            a = a ^ b;
+            a = a | b;
+            c = (/*info:DynamicInvoke*/c + b);
+
+            String x = 'hello';
+            int y = 42;
+            x = x + x;
+            x = x + /*info:DynamicCast*/c;
+            x = x + /*severe:StaticTypeError*/y;
+
+            bool p = true;
+            p = p && p;
+            p = p && /*info:DynamicCast*/c;
+            p = (/*info:DynamicCast*/c) && p;
+            p = (/*info:DynamicCast*/c) && /*info:DynamicCast*/c;
+            p = (/*severe:StaticTypeError*/y) && p;
+            p = c == y;
+
+            a = a[b];
+            a = a[/*info:DynamicCast*/c];
+            c = (/*info:DynamicInvoke*/c[b]);
+            a[/*severe:StaticTypeError*/y];
+          }
+       '''
+  });
+
+  testChecker('compound assignments', {
+    '/main.dart': '''
+          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) {}
+          }
+
+          class B {
+            A operator -(B b) {}
+          }
+
+          class D {
+            D operator +(D d) {}
+          }
+
+          foo() => new A();
+
+          test() {
+            int x = 0;
+            x += 5;
+            (/*severe:StaticTypeError*/x += 3.14);
+
+            double y = 0.0;
+            y += 5;
+            y += 3.14;
+
+            num z = 0;
+            z += 5;
+            z += 3.14;
+
+            x = /*info:DownCastImplicit*/x + z;
+            x += /*info:DownCastImplicit*/z;
+            y = /*info:DownCastImplicit*/y + z;
+            y += /*info:DownCastImplicit*/z;
+
+            dynamic w = 42;
+            x += /*info:DynamicCast*/w;
+            y += /*info:DynamicCast*/w;
+            z += /*info:DynamicCast*/w;
+
+            A a = new A();
+            B b = new B();
+            var c = foo();
+            a = a * b;
+            a *= b;
+            a *= /*info:DynamicCast*/c;
+            a /= b;
+            a ~/= b;
+            a %= b;
+            a += b;
+            a += /*severe:StaticTypeError*/a;
+            a -= b;
+            (/*severe:StaticTypeError*/b -= b);
+            a <<= b;
+            a >>= b;
+            a &= b;
+            a ^= b;
+            a |= b;
+            (/*info:DynamicInvoke*/c += b);
+
+            var d = new D();
+            a[b] += d;
+            a[/*info:DynamicCast*/c] += d;
+            a[/*severe:StaticTypeError*/z] += d;
+            a[b] += /*info:DynamicCast*/c;
+            a[b] += /*severe:StaticTypeError*/z;
+            (/*info:DynamicInvoke*/(/*info:DynamicInvoke*/c[b]) += d);
+          }
+       '''
+  });
+
+  testChecker('super call placement', {
+    '/main.dart': '''
+          class Base {
+            var x;
+            Base() : x = print('Base.1') { print('Base.2'); }
+          }
+
+          class Derived extends Base {
+            var y, z;
+            Derived()
+                : y = print('Derived.1'),
+                  /*severe:InvalidSuperInvocation*/super(),
+                  z = print('Derived.2') {
+              print('Derived.3');
+            }
+          }
+
+          class Valid extends Base {
+            var y, z;
+            Valid()
+                : y = print('Valid.1'),
+                  z = print('Valid.2'),
+                  super() {
+              print('Valid.3');
+            }
+          }
+
+          class AlsoValid extends Base {
+            AlsoValid() : super();
+          }
+
+          main() => new Derived();
+       '''
+  });
+
+  testChecker('for loop variable', {
+    '/main.dart': '''
+          foo() {
+            for (int i = 0; i < 10; i++) {
+              i = /*severe:StaticTypeError*/"hi";
+            }
+          }
+          bar() {
+            for (var i = 0; i < 10; i++) {
+              int j = i + 1;
+            }
+          }
+        '''
+  });
+
+  group('invalid overrides', () {
+    testChecker('child override', {
+      '/main.dart': '''
+            class A {}
+            class B {}
+
+            class Base {
+                A f;
+            }
+
+            class T1 extends Base {
+              /*severe:InvalidMethodOverride*/B get f => null;
+            }
+
+            class T2 extends Base {
+              /*severe:InvalidMethodOverride*/set f(B b) => null;
+            }
+
+            class T3 extends Base {
+              /*severe:InvalidMethodOverride*/final B f;
+            }
+            class T4 extends Base {
+              // two: one for the getter one for the setter.
+              /*severe:InvalidMethodOverride,severe:InvalidMethodOverride*/B f;
+            }
+         '''
+    });
+
+    testChecker('child override 2', {
+      '/main.dart': '''
+            class A {}
+            class B {}
+
+            class Base {
+                m(A a) {}
+            }
+
+            class Test extends Base {
+                /*severe:InvalidMethodOverride*/m(B a) {}
+            }
+         '''
+    });
+    testChecker('grandchild override', {
+      '/main.dart': '''
+            class A {}
+            class B {}
+
+            class Grandparent {
+                m(A a) {}
+            }
+            class Parent extends Grandparent {
+            }
+
+            class Test extends Parent {
+                /*severe:InvalidMethodOverride*/m(B a) {}
+            }
+         '''
+    });
+
+    testChecker('double override', {
+      '/main.dart': '''
+            class A {}
+            class B {}
+
+            class Grandparent {
+                m(A a) {}
+            }
+            class Parent extends Grandparent {
+                m(A a) {}
+            }
+
+            class Test extends Parent {
+                // Reported only once
+                /*severe:InvalidMethodOverride*/m(B a) {}
+            }
+         '''
+    });
+
+    testChecker('double override 2', {
+      '/main.dart': '''
+            class A {}
+            class B {}
+
+            class Grandparent {
+                m(A a) {}
+            }
+            class Parent extends Grandparent {
+                /*severe:InvalidMethodOverride*/m(B a) {}
+            }
+
+            class Test extends Parent {
+                m(B a) {}
+            }
+         '''
+    });
+
+    testChecker('mixin override to base', {
+      '/main.dart': '''
+            class A {}
+            class B {}
+
+            class Base {
+                m(A a) {}
+            }
+
+            class M1 {
+                m(B a) {}
+            }
+
+            class M2 {}
+
+            class T1 extends Base with /*severe:InvalidMethodOverride*/M1 {}
+            class T2 extends Base with /*severe:InvalidMethodOverride*/M1, M2 {}
+            class T3 extends Base with M2, /*severe:InvalidMethodOverride*/M1 {}
+         '''
+    });
+
+    testChecker('mixin override to mixin', {
+      '/main.dart': '''
+            class A {}
+            class B {}
+
+            class Base {
+            }
+
+            class M1 {
+                m(B a) {}
+            }
+
+            class M2 {
+                m(A a) {}
+            }
+
+            class T1 extends Base with M1, /*severe:InvalidMethodOverride*/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.
+    testChecker('no duplicate mixin override', {
+      '/main.dart': '''
+            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
+                with M1, /*severe:InvalidMethodOverride*/M2, M3 {}
+         '''
+    });
+
+    testChecker('class override of interface', {
+      '/main.dart': '''
+            class A {}
+            class B {}
+
+            abstract class I {
+                m(A a);
+            }
+
+            class T1 implements I {
+                /*severe:InvalidMethodOverride*/m(B a) {}
+            }
+         '''
+    });
+
+    testChecker('base class override to child interface', {
+      '/main.dart': '''
+            class A {}
+            class B {}
+
+            abstract class I {
+                m(A a);
+            }
+
+            class Base {
+                m(B a) {}
+            }
+
+
+            class T1 /*severe:InvalidMethodOverride*/extends Base implements I {
+            }
+         '''
+    });
+
+    testChecker('mixin override of interface', {
+      '/main.dart': '''
+            class A {}
+            class B {}
+
+            abstract class I {
+                m(A a);
+            }
+
+            class M {
+                m(B a) {}
+            }
+
+            class T1 extends Object with /*severe:InvalidMethodOverride*/M
+               implements I {}
+         '''
+    });
+
+    // This is a case were it is incorrect to say that the base class
+    // incorrectly overrides the interface.
+    testChecker(
+        'no errors if subclass correctly overrides base and interface', {
+      '/main.dart': '''
+            class A {}
+            class B {}
+
+            class Base {
+                m(A a) {}
+            }
+
+            class I1 {
+                m(B a) {}
+            }
+
+            class T1 /*severe:InvalidMethodOverride*/extends Base
+                implements I1 {}
+
+            class T2 extends Base implements I1 {
+                /*severe:InvalidMethodOverride,severe:InvalidMethodOverride*/m(a) {}
+            }
+
+            class T3 extends Object with /*severe:InvalidMethodOverride*/Base
+                implements I1 {}
+
+            class T4 extends Object with Base implements I1 {
+                /*severe:InvalidMethodOverride,severe:InvalidMethodOverride*/m(a) {}
+            }
+         '''
+    });
+  });
+
+  group('class override of grand interface', () {
+    testChecker('interface of interface of child', {
+      '/main.dart': '''
+              class A {}
+              class B {}
+
+              abstract class I1 {
+                  m(A a);
+              }
+              abstract class I2 implements I1 {}
+
+              class T1 implements I2 {
+                  /*severe:InvalidMethodOverride*/m(B a) {}
+              }
+           '''
+    });
+    testChecker('superclass of interface of child', {
+      '/main.dart': '''
+              class A {}
+              class B {}
+
+              abstract class I1 {
+                  m(A a);
+              }
+              abstract class I2 extends I1 {}
+
+              class T1 implements I2 {
+                  /*severe:InvalidMethodOverride*/m(B a) {}
+              }
+           '''
+    });
+    testChecker('mixin of interface of child', {
+      '/main.dart': '''
+              class A {}
+              class B {}
+
+              abstract class M1 {
+                  m(A a);
+              }
+              abstract class I2 extends Object with M1 {}
+
+              class T1 implements I2 {
+                  /*severe:InvalidMethodOverride*/m(B a) {}
+              }
+           '''
+    });
+    testChecker('interface of abstract superclass', {
+      '/main.dart': '''
+              class A {}
+              class B {}
+
+              abstract class I1 {
+                  m(A a);
+              }
+              abstract class Base implements I1 {}
+
+              class T1 extends Base {
+                  /*severe:InvalidMethodOverride*/m(B a) {}
+              }
+           '''
+    });
+    testChecker('interface of concrete superclass', {
+      '/main.dart': '''
+              class A {}
+              class B {}
+
+              abstract class I1 {
+                  m(A a);
+              }
+
+              // See issue #25
+              /*pass should be warning:AnalyzerError*/class 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) {}
+              }
+           '''
+    });
+  });
+
+  group('mixin override of grand interface', () {
+    testChecker('interface of interface of child', {
+      '/main.dart': '''
+              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:InvalidMethodOverride*/M
+                  implements I2 {
+              }
+           '''
+    });
+    testChecker('superclass of interface of child', {
+      '/main.dart': '''
+              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:InvalidMethodOverride*/M
+                  implements I2 {
+              }
+           '''
+    });
+    testChecker('mixin of interface of child', {
+      '/main.dart': '''
+              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:InvalidMethodOverride*/M
+                  implements I2 {
+              }
+           '''
+    });
+    testChecker('interface of abstract superclass', {
+      '/main.dart': '''
+              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:InvalidMethodOverride*/M {
+              }
+           '''
+    });
+    testChecker('interface of concrete superclass', {
+      '/main.dart': '''
+              class A {}
+              class B {}
+
+              abstract class I1 {
+                  m(A a);
+              }
+
+              // See issue #25
+              /*pass should be warning:AnalyzerError*/class Base implements I1 {
+              }
+
+              class M {
+                  m(B a) {}
+              }
+
+              class T1 extends Base with M {
+              }
+           '''
+    });
+  });
+
+  group('superclass override of grand interface', () {
+    testChecker('interface of interface of child', {
+      '/main.dart': '''
+              class A {}
+              class B {}
+
+              abstract class I1 {
+                  m(A a);
+              }
+              abstract class I2 implements I1 {}
+
+              class Base {
+                  m(B a) {}
+              }
+
+              class T1 /*severe:InvalidMethodOverride*/extends Base
+                  implements I2 {
+              }
+           '''
+    });
+    testChecker('superclass of interface of child', {
+      '/main.dart': '''
+              class A {}
+              class B {}
+
+              abstract class I1 {
+                  m(A a);
+              }
+              abstract class I2 extends I1 {}
+
+              class Base {
+                  m(B a) {}
+              }
+
+              class T1 /*severe:InvalidMethodOverride*/extends Base
+                  implements I2 {
+              }
+           '''
+    });
+    testChecker('mixin of interface of child', {
+      '/main.dart': '''
+              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:InvalidMethodOverride*/extends Base
+                  implements I2 {
+              }
+           '''
+    });
+    testChecker('interface of abstract superclass', {
+      '/main.dart': '''
+              class A {}
+              class B {}
+
+              abstract class I1 {
+                  m(A a);
+              }
+
+              abstract class Base implements I1 {
+                  /*severe:InvalidMethodOverride*/m(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:InvalidMethodOverride*/m(B a) {}
+              }
+           '''
+    });
+    testChecker('interface of concrete superclass', {
+      '/main.dart': '''
+              class A {}
+              class B {}
+
+              abstract class I1 {
+                  m(A a);
+              }
+
+              class Base implements I1 {
+                  /*severe:InvalidMethodOverride*/m(B a) {}
+              }
+
+              class T1 extends Base {
+                  m(B a) {}
+              }
+           '''
+    });
+  });
+
+  group('no duplicate reports from overriding interfaces', () {
+    testChecker('type overrides same method in multiple interfaces', {
+      '/main.dart': '''
+              class A {}
+              class B {}
+
+              abstract class I1 {
+                  m(A a);
+              }
+              abstract class I2 implements I1 {
+                  m(A a);
+              }
+
+              class Base {
+              }
+
+              class T1 implements I2 {
+                /*severe:InvalidMethodOverride*/m(B a) {}
+              }
+           '''
+    });
+
+    testChecker('type and base type override same method in interface', {
+      '/main.dart': '''
+              class A {}
+              class B {}
+
+              abstract class I1 {
+                  m(A a);
+              }
+
+              class Base {
+                  m(B a);
+              }
+
+              // Note: no error reported in `extends Base` to avoid duplicating
+              // the error in T1.
+              class T1 extends Base implements I1 {
+                /*severe:InvalidMethodOverride*/m(B a) {}
+              }
+
+              // If there is no error in the class, we do report the error at
+              // the base class:
+              class T2 /*severe:InvalidMethodOverride*/extends Base
+                  implements I1 {
+              }
+           '''
+    });
+
+    testChecker('type and mixin override same method in interface', {
+      '/main.dart': '''
+              class A {}
+              class B {}
+
+              abstract class I1 {
+                  m(A a);
+              }
+
+              class M {
+                  m(B a);
+              }
+
+              class T1 extends Object with M implements I1 {
+                /*severe:InvalidMethodOverride*/m(B a) {}
+              }
+
+              class T2 extends Object with /*severe:InvalidMethodOverride*/M
+                  implements I1 {
+              }
+           '''
+    });
+
+    testChecker('two grand types override same method in interface', {
+      '/main.dart': '''
+              class A {}
+              class B {}
+
+              abstract class I1 {
+                  m(A a);
+              }
+
+              class Grandparent {
+                  m(B a) {}
+              }
+
+              class Parent1 extends Grandparent {
+                  m(B a) {}
+              }
+              class Parent2 extends Grandparent {
+              }
+
+              // Note: otherwise both errors would be reported on this line
+              class T1 /*severe:InvalidMethodOverride*/extends Parent1
+                  implements I1 {
+              }
+              class T2 /*severe:InvalidMethodOverride*/extends Parent2
+                  implements I1 {
+              }
+           '''
+    });
+
+    testChecker('two mixins override same method in interface', {
+      '/main.dart': '''
+              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
+                  with /*severe:InvalidMethodOverride*/M1
+                  with /*severe:InvalidMethodOverride*/M2
+                  implements I1 {
+              }
+           '''
+    });
+
+    testChecker('base type and mixin override same method in interface', {
+      '/main.dart': '''
+              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:InvalidMethodOverride*/extends Base
+                  with /*severe:InvalidMethodOverride*/M
+                  implements I1 {
+              }
+           '''
+    });
+  });
+
+  testChecker('invalid runtime checks', {
+    '/main.dart': '''
+          typedef int I2I(int x);
+          typedef int D2I(x);
+          typedef int II2I(int x, int y);
+          typedef int DI2I(x, int y);
+          typedef int ID2I(int x, y);
+          typedef int DD2I(x, y);
+
+          typedef I2D(int x);
+          typedef D2D(x);
+          typedef II2D(int x, int y);
+          typedef DI2D(x, int y);
+          typedef ID2D(int x, y);
+          typedef DD2D(x, y);
+
+          int foo(int x) => x;
+          int bar(int x, int y) => x + y;
+
+          void main() {
+            bool b;
+            b = /*info:NonGroundTypeCheckInfo*/foo is I2I;
+            b = /*info:NonGroundTypeCheckInfo*/foo is D2I;
+            b = /*info:NonGroundTypeCheckInfo*/foo is I2D;
+            b = foo is D2D;
+
+            b = /*info:NonGroundTypeCheckInfo*/bar is II2I;
+            b = /*info:NonGroundTypeCheckInfo*/bar is DI2I;
+            b = /*info:NonGroundTypeCheckInfo*/bar is ID2I;
+            b = /*info:NonGroundTypeCheckInfo*/bar is II2D;
+            b = /*info:NonGroundTypeCheckInfo*/bar is DD2I;
+            b = /*info:NonGroundTypeCheckInfo*/bar is DI2D;
+            b = /*info:NonGroundTypeCheckInfo*/bar is ID2D;
+            b = bar is DD2D;
+
+            // For as, the validity of checks is deferred to runtime.
+            Function f;
+            f = foo as I2I;
+            f = foo as D2I;
+            f = foo as I2D;
+            f = foo as D2D;
+
+            f = bar as II2I;
+            f = bar as DI2I;
+            f = bar as ID2I;
+            f = bar as II2D;
+            f = bar as DD2I;
+            f = bar as DI2D;
+            f = bar as ID2D;
+            f = bar as DD2D;
+          }
+      '''
+  });
+
+  group('function modifiers', () {
+    testChecker('async', {
+      '/main.dart': '''
+        import 'dart:async';
+        import 'dart:math' show Random;
+
+        dynamic x;
+
+        foo1() async => x;
+        Future foo2() async => x;
+        Future<int> foo3() async => (/*info:DynamicCast*/x);
+        Future<int> foo4() async => (/*severe:StaticTypeError*/new Future<int>.value(/*info:DynamicCast*/x));
+
+        bar1() async { return x; }
+        Future bar2() async { return x; }
+        Future<int> bar3() async { return (/*info:DynamicCast*/x); }
+        Future<int> bar4() async { return (/*severe:StaticTypeError*/new Future<int>.value(/*info:DynamicCast*/x)); }
+
+        int y;
+        Future<int> z;
+
+        void baz() async {
+          int a = /*info:DynamicCast*/await x;
+          int b = await y;
+          int c = await z;
+          String d = /*severe:StaticTypeError*/await z;
+        }
+
+        Future<bool> get issue_264 async {
+          await 42;
+          if (new Random().nextBool()) {
+            return true;
+          } else {
+            return /*severe:StaticTypeError*/new Future<bool>.value(false);
+          }
+        }
+    '''
+    });
+
+    testChecker('async*', {
+      '/main.dart': '''
+        import 'dart:async';
+
+        dynamic x;
+
+        bar1() async* { yield x; }
+        Stream bar2() async* { yield x; }
+        Stream<int> bar3() async* { yield (/*info:DynamicCast*/x); }
+        Stream<int> bar4() async* { yield (/*severe:StaticTypeError*/new Stream<int>()); }
+
+        baz1() async* { yield* (/*info:DynamicCast*/x); }
+        Stream baz2() async* { yield* (/*info:DynamicCast*/x); }
+        Stream<int> baz3() async* { yield* (/*warning:DownCastComposite*/x); }
+        Stream<int> baz4() async* { yield* new Stream<int>(); }
+        Stream<int> baz5() async* { yield* (/*info:InferredTypeAllocation*/new Stream()); }
+    '''
+    });
+
+    testChecker('sync*', {
+      '/main.dart': '''
+        import 'dart:async';
+
+        dynamic x;
+
+        bar1() sync* { yield x; }
+        Iterable bar2() sync* { yield x; }
+        Iterable<int> bar3() sync* { yield (/*info:DynamicCast*/x); }
+        Iterable<int> bar4() sync* { yield (/*severe:StaticTypeError*/new Iterable<int>()); }
+
+        baz1() sync* { yield* (/*info:DynamicCast*/x); }
+        Iterable baz2() sync* { yield* (/*info:DynamicCast*/x); }
+        Iterable<int> baz3() sync* { yield* (/*warning:DownCastComposite*/x); }
+        Iterable<int> baz4() sync* { yield* new Iterable<int>(); }
+        Iterable<int> baz5() sync* { yield* (/*info:InferredTypeAllocation*/new Iterable()); }
+    '''
+    });
+  });
+}