remove covariant generics option

test/checker/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.
 
 /// General type checking tests
 library dev_compiler.test.checker_test;
 
 import 'package:test/test.dart';
 
 import 'package:dev_compiler/src/testing.dart';
@@ skipping 1053 matching lines @@
       '/main.dart': '''
 
       class A {
         void bar() => null;
         void foo() => bar; // allowed
       }
    '''
     });
   });
 
-  test('Generic subtyping: invariance', () {
-    testChecker({
-      '/main.dart': '''
-
-      class A {}
-      class B extends A {}
-      class C implements A {}
-
-      class L<T> {}
-      class M<T> extends L<T> {}
-      class N extends M<A> {}
-
-      void main() {
-        L<A> lOfAs;
-        L<B> lOfBs;
-        L<C> lOfCs;
-
-        M<A> mOfAs;
-        M<B> mOfBs;
-        M<C> mOfCs;
-
-        N ns;
-
-        // L<T> <: L<S> iff S = dynamic or S=T
-        lOfAs = lOfAs;
-        lOfAs = /*severe:StaticTypeError*/lOfBs;
-        lOfAs = /*severe:StaticTypeError*/lOfCs;
-
-        // M<S> <: L<S>
-        lOfAs = mOfAs;
-        lOfAs = /*severe:StaticTypeError*/mOfBs;
-        lOfAs = /*severe:StaticTypeError*/mOfCs;
-
-        // N <: L<A>
-        lOfAs = ns;
-
-        // L<T> <: L<S> iff S = dynamic or  S=T
-        lOfBs = /*severe:StaticTypeError*/lOfAs;
-        lOfBs = lOfBs;
-        lOfBs = /*severe:StaticTypeError*/lOfCs;
-
-        // M<S> <: L<S>
-        lOfBs = /*severe:StaticTypeError*/mOfAs;
-        lOfBs = mOfBs;
-        lOfBs = /*severe:StaticTypeError*/mOfCs;
-
-        // N </: L<B>
-        lOfBs = /*severe:StaticTypeError*/ns;
-
-        // L<T> <: L<S> iff S = dynamic or  S=T
-        lOfCs = /*severe:StaticTypeError*/lOfAs;
-        lOfCs = /*severe:StaticTypeError*/lOfBs;
-        lOfCs = lOfCs;
-
-        // M<S> <: L<S>
-        lOfCs = /*severe:StaticTypeError*/mOfAs;
-        lOfCs = /*severe:StaticTypeError*/mOfBs;
-        lOfCs = mOfCs;
-
-        // N </: L<C>
-        lOfCs = /*severe:StaticTypeError*/ns;
-
-        // M<T> <: L<S> iff S = dynamic or S=T
-        mOfAs = /*warning:DownCastComposite*/lOfAs;
-        mOfAs = /*severe:StaticTypeError*/lOfBs;
-        mOfAs = /*severe:StaticTypeError*/lOfCs;
-
-        // M<S> <: M<S> iff S = dynamic or S=T
-        mOfAs = mOfAs;
-        mOfAs = /*severe:StaticTypeError*/mOfBs;
-        mOfAs = /*severe:StaticTypeError*/mOfCs;
-
-        // N <: M<A>
-        mOfAs = ns;
-
-        // M<T> <: L<S> iff S = dynamic or S=T
-        mOfBs = /*severe:StaticTypeError*/lOfAs;
-        mOfBs = /*warning:DownCastComposite*/lOfBs;
-        mOfBs = /*severe:StaticTypeError*/lOfCs;
-
-        // M<S> <: M<S> iff S = dynamic or S=T
-        mOfBs = /*severe:StaticTypeError*/mOfAs;
-        mOfBs = mOfBs;
-        mOfBs = /*severe:StaticTypeError*/mOfCs;
-
-        // N </: M<B>
-        mOfBs = /*severe:StaticTypeError*/ns;
-
-        // M<T> <: L<S> iff S = dynamic or S=T
-        mOfCs = /*severe:StaticTypeError*/lOfAs;
-        mOfCs = /*severe:StaticTypeError*/lOfBs;
-        mOfCs = /*warning:DownCastComposite*/lOfCs;
-
-        // M<S> <: M<S> iff S = dynamic or S=T
-        mOfCs = /*severe:StaticTypeError*/mOfAs;
-        mOfCs = /*severe:StaticTypeError*/mOfBs;
-        mOfCs = mOfCs;
-
-        // N </: L<C>
-        mOfCs = /*severe:StaticTypeError*/ns;
-
-        // Concrete subclass subtyping
-        ns = /*warning:DownCastImplicit*/lOfAs;
-        ns = /*severe:StaticTypeError*/lOfBs;
-        ns = /*severe:StaticTypeError*/lOfCs;
-        ns = /*warning:DownCastImplicit*/mOfAs;
-        ns = /*severe:StaticTypeError*/mOfBs;
-        ns = /*severe:StaticTypeError*/mOfCs;
-        ns = ns;
-      }
-   '''
-    }, covariantGenerics: false, relaxedCasts: false);
-  });
-
-  test('Generic subtyping: covariant raw types', () {
-    testChecker({
-      '/main.dart': '''
-
-      class A {}
-      class B extends A {}
-      class C implements A {}
-
-      class L<T> {}
-      class M<T> extends L<T> {}
-      class N extends M<A> {}
-
-      void main() {
-        L lRaw;
-        L<dynamic> lOfDynamics;
-        L<A> lOfAs;
-        L<B> lOfBs;
-        L<C> lOfCs;
-
-        M mRaw;
-        M<dynamic> mOfDynamics;
-        M<A> mOfAs;
-        M<B> mOfBs;
-        M<C> mOfCs;
-
-        N ns;
-
-        // Raw type subtyping
-        lRaw = lRaw;
-        lRaw = lOfDynamics;
-        lRaw = lOfAs;
-        lRaw = lOfBs;
-        lRaw = lOfCs;
-        lRaw = mRaw;
-        lRaw = mOfDynamics;
-        lRaw = mOfAs;
-        lRaw = mOfBs;
-        lRaw = mOfCs;
-        lRaw = ns;
-
-        // L<dynamic> == L
-        lOfDynamics = lRaw;
-        lOfDynamics = lOfDynamics;
-        lOfDynamics = lOfAs;
-        lOfDynamics = lOfBs;
-        lOfDynamics = lOfCs;
-        lOfDynamics = mRaw;
-        lOfDynamics = mOfDynamics;
-        lOfDynamics = mOfAs;
-        lOfDynamics = mOfBs;
-        lOfDynamics = mOfCs;
-        lOfDynamics = ns;
-
-        // L<T> <: L<S> iff S = dynamic or S=T
-        lOfAs = /*warning:DownCastComposite*/lRaw;
-        lOfAs = /*warning:DownCastComposite*/lOfDynamics;
-
-        // M<dynamic> </:/> L<A>
-        lOfAs = /*severe:StaticTypeError*/mRaw;
-        lOfAs = /*severe:StaticTypeError*/mOfDynamics;
-
-        // L<T> <: L<S> iff S = dynamic or S=T
-        lOfBs = /*warning:DownCastComposite*/lRaw;
-        lOfBs = /*warning:DownCastComposite*/lOfDynamics;
-
-        // M<dynamic> </:/> L<B>
-        lOfBs = /*severe:StaticTypeError*/mRaw;
-        lOfBs = /*severe:StaticTypeError*/mOfDynamics;
-
-        // L<T> <: L<S> iff S = dynamic or S=T
-        lOfCs = /*warning:DownCastComposite*/lRaw;
-        lOfCs = /*warning:DownCastComposite*/lOfDynamics;
-
-        // M<dynamic> </:/> L<C>
-        lOfCs = /*severe:StaticTypeError*/mRaw;
-        lOfCs = /*severe:StaticTypeError*/mOfDynamics;
-
-        // Raw type subtyping
-        mRaw = /*warning:DownCastImplicit*/lRaw;
-        mRaw = /*warning:DownCastImplicit*/lOfDynamics;
-        mRaw = /*severe:StaticTypeError*/lOfAs;
-        mRaw = /*severe:StaticTypeError*/lOfBs;
-        mRaw = /*severe:StaticTypeError*/lOfCs;
-        mRaw = mRaw;
-        mRaw = mOfDynamics;
-        mRaw = mOfAs;
-        mRaw = mOfBs;
-        mRaw = mOfCs;
-        mRaw = ns;
-
-        // M<dynamic> == M
-        mOfDynamics = /*warning:DownCastImplicit*/lRaw;
-        mOfDynamics = /*warning:DownCastImplicit*/lOfDynamics;
-        mOfDynamics = /*severe:StaticTypeError*/lOfAs;
-        mOfDynamics = /*severe:StaticTypeError*/lOfBs;
-        mOfDynamics = /*severe:StaticTypeError*/lOfCs;
-        mOfDynamics = mRaw;
-        mOfDynamics = mOfDynamics;
-        mOfDynamics = mOfAs;
-        mOfDynamics = mOfBs;
-        mOfDynamics = mOfCs;
-        mOfDynamics = ns;
-
-        // M<T> <: L<S> iff S = dynamic or S=T
-        mOfAs = /*warning:DownCastComposite*/lRaw;
-        mOfAs = /*warning:DownCastComposite*/lOfDynamics;
-
-        // M<dynamic> </:/> M<A>
-        mOfAs = /*warning:DownCastComposite*/mRaw;
-        mOfAs = /*warning:DownCastComposite*/mOfDynamics;
-
-        // M<T> <: L<S> iff S = dynamic or S=T
-        mOfBs = /*warning:DownCastComposite*/lRaw;
-        mOfBs = /*warning:DownCastComposite*/lOfDynamics;
-
-        // M<dynamic> </:/> M<B>
-        mOfBs = /*warning:DownCastComposite*/mRaw;
-        mOfBs = /*warning:DownCastComposite*/mOfDynamics;
-
-        // M<T> <: L<S> iff S = dynamic or S=T
-        mOfCs = /*warning:DownCastComposite*/lRaw;
-        mOfCs = /*warning:DownCastComposite*/lOfDynamics;
-
-        // M<dynamic> </:/> M<C>
-        mOfCs = /*warning:DownCastComposite*/mRaw;
-        mOfCs = /*warning:DownCastComposite*/mOfDynamics;
-
-        // Concrete subclass subtyping
-        ns = /*warning:DownCastImplicit*/lRaw;
-        ns = /*warning:DownCastImplicit*/lOfDynamics;
-        ns = /*warning:DownCastImplicit*/mRaw;
-        ns = /*warning:DownCastImplicit*/mOfDynamics;
-      }
-   '''
-    }, covariantGenerics: false, relaxedCasts: false);
-  });
-
-  test('Generic subtyping: covariant raw types with multiple parameters', () {
-    testChecker({
-      '/main.dart': '''
-
-      class A {}
-
-      class L<S, T> {}
-      class M<S, T> extends L<S, T> {}
-
-      void main() {
-        L lRaw;
-        /*pass should be severe:StaticTypeError*/L<dynamic> lOfD_;
-        /*pass should be severe:StaticTypeError*/L<A> lOfA_;
-        L<dynamic, A> lOfDA;
-        L<A, dynamic> lOfAD;
-        L<dynamic, dynamic> lOfDD;
-        L<A, A> lOfAA;
-
-        // This is the currently implemented lattice.
-        // We may wish to change this to a flat lattice with
-        // L<dynamic, dynamic> as the top element
-        //
-        //    L<dynamic, dynamic>
-        //      /           \
-        //  L<dynamic, A>  L<A, dynamic>
-        //      \           /
-        //         L<A, A>
-
-        // L == L<dynamic, dynamic>
-        lRaw = lRaw;
-        lRaw = lOfD_;
-        lRaw = lOfA_;
-        lRaw = lOfDA;
-        lRaw = lOfAD;
-        lRaw = lOfDD;
-        lRaw = lOfAA;
-
-        // L<dynamic> == L<dynamic, dynamic>
-        lOfD_ = lRaw;
-        lOfD_ = lOfD_;
-        lOfD_ = lOfA_;
-        lOfD_ = lOfDA;
-        lOfD_ = lOfAD;
-        lOfD_ = lOfDD;
-        lOfD_ = lOfAA;
-
-        // L<dynamic, dynamic>
-        lOfDD = lRaw;
-        lOfDD = lOfD_;
-        lOfDD = lOfA_;
-        lOfDD = lOfDA;
-        lOfDD = lOfAD;
-        lOfDD = lOfDD;
-        lOfDD = lOfAA;
-
-        // L<dynamic, A>
-        lOfDA = /*warning:DownCastComposite*/lRaw;
-        lOfDA = /*warning:DownCastComposite*/lOfD_;
-        lOfDA = /*warning:DownCastComposite*/lOfA_;
-        lOfDA = lOfDA;
-        lOfDA = /*severe:StaticTypeError*/lOfAD;
-        lOfDA = /*warning:DownCastComposite*/lOfDD;
-        lOfDA = lOfAA;
-
-        // L<A, dynamic>
-        lOfAD = /*warning:DownCastComposite*/lRaw;
-        lOfAD = /*warning:DownCastComposite*/lOfD_;
-        lOfAD = /*warning:DownCastComposite*/lOfA_;
-        lOfAD = /*severe:StaticTypeError*/lOfDA;
-        lOfAD = lOfAD;
-        lOfAD = /*warning:DownCastComposite*/lOfDD;
-        lOfAD = lOfAA;
-
-        // L<A> == L<dynamic, dynamic>
-        lOfA_ = lRaw;
-        lOfA_ = lOfD_;
-        lOfA_ = lOfA_;
-        lOfA_ = lOfDA;
-        lOfA_ = lOfAD;
-        lOfA_ = lOfDD;
-        lOfA_ = lOfAA;
-
-        // L<A, A>
-        lOfAA = /*warning:DownCastComposite*/lRaw;
-        lOfAA = /*warning:DownCastComposite*/lOfD_;
-        lOfAA = /*warning:DownCastComposite*/lOfA_;
-        lOfAA = /*warning:DownCastComposite*/lOfDA;
-        lOfAA = /*warning:DownCastComposite*/lOfAD;
-        lOfAA = /*warning:DownCastComposite*/lOfDD;
-        lOfAA = lOfAA;
-      }
-   '''
-    }, covariantGenerics: false, relaxedCasts: false);
-  });
-
   test('Covariant generic subtyping: invariance', () {
     testChecker({
       '/main.dart': '''
 
       class A {}
       class B extends A {}
       class C implements A {}
 
       class L<T> {}
       class M<T> extends L<T> {}
@@ skipping 91 matching lines @@
         // Concrete subclass subtyping
         ns = /*warning:DownCastImplicit*/lOfAs;
         ns = /*severe:StaticTypeError*/lOfBs;
         ns = /*severe:StaticTypeError*/lOfCs;
         ns = /*warning:DownCastImplicit*/mOfAs;
         ns = /*severe:StaticTypeError*/mOfBs;
         ns = /*severe:StaticTypeError*/mOfCs;
         ns = ns;
       }
    '''
-    }, covariantGenerics: true, relaxedCasts: false);
+    }, relaxedCasts: false);
   });
 
   test('Relaxed casts', () {
     testChecker({
       '/main.dart': '''
 
       class A {}
 
       class L<T> {}
       class M<T> extends L<T> {}
@@ skipping 59 matching lines @@
           mOfAs = /*warning:DownCastComposite*/mOfDs;
           mOfAs = /*warning:DownCastComposite*/mOfOs;
           mOfAs = mOfAs;
           mOfAs = /*warning:DownCastComposite*/lOfDs;
           mOfAs = /*warning:DownCastComposite*/lOfOs;
           mOfAs = /*warning:DownCastComposite*/lOfAs;
         }
 
       }
    '''
-    }, covariantGenerics: true, relaxedCasts: true);
+    }, relaxedCasts: true);
   });
 
   test('Subtyping literals', () {
     testChecker({
       '/main.dart': '''
           test() {
             Iterable i1 = [1, 2, 3];
             i1 = <int>[1, 2, 3];
 
             List l1 = [1, 2, 3];
@@ skipping 1387 matching lines @@
     '/main.dart': '''
       import 'dart:foobar' show Baz;
       main() {
         print(Baz.quux);
       }'''
   },
       customUrlMappings: {
     'dart:foobar': '$testDirectory/checker/dart_foobar.dart'
   }));
 }