fix #29426, class type alias was missing checks

pkg/analyzer/test/src/task/strong/checker_test.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library analyzer.test.src.task.strong.checker_test;
 
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import 'strong_test_helper.dart';
 
@@ skipping 2421 matching lines @@
 
   test_implicitDynamic_type() async {
     addFile(r'''
 class C<T> {}
 class M1<T extends /*error:IMPLICIT_DYNAMIC_TYPE*/List> {}
 class M2<T> {}
 class I<T> {}
 class D<T, S> extends /*error:IMPLICIT_DYNAMIC_TYPE*/C
     with M1, /*error:IMPLICIT_DYNAMIC_TYPE*/M2
     implements /*error:IMPLICIT_DYNAMIC_TYPE*/I {}
+class D2<T, S> = /*error:IMPLICIT_DYNAMIC_TYPE*/C
+    with M1, /*error:IMPLICIT_DYNAMIC_TYPE*/M2
+    implements /*error:IMPLICIT_DYNAMIC_TYPE*/I;
 
 C f(D d) {
   D x = /*info:INFERRED_TYPE_ALLOCATION*/new /*error:IMPLICIT_DYNAMIC_TYPE*/D();
   D<int, dynamic> y = /*info:INFERRED_TYPE_ALLOCATION*/new /*error:IMPLICIT_DYNAMIC_TYPE*/D();
   D<dynamic, int> z = /*info:INFERRED_TYPE_ALLOCATION*/new /*error:IMPLICIT_DYNAMIC_TYPE*/D();
   return /*info:INFERRED_TYPE_ALLOCATION*/new /*error:IMPLICIT_DYNAMIC_TYPE*/C();
 }
 
 class A<T extends num> {}
 class N1<T extends List<int>> {}
@@ skipping 179 matching lines @@
     m(A a);
 }
 
 class M {
     m(B a) {}
 }
 
 class /*error:INCONSISTENT_METHOD_INHERITANCE*/T1
     extends Object with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M
     implements I {}
+
+class /*error:INCONSISTENT_METHOD_INHERITANCE*/U1 = Object
+    with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M implements I;
 ''');
   }
 
   test_invalidOverrides_mixinOverrideToBase() async {
     await checkFile('''
 class A {}
 class B {}
 
 class Base {
     m(A a) {}
     int x;
 }
 
 class M1 {
     m(B a) {}
 }
 
 class M2 {
     int x;
 }
 
 class /*error:INCONSISTENT_METHOD_INHERITANCE*/T1 extends Base
     with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M1 {}
 class /*error:INCONSISTENT_METHOD_INHERITANCE*/T2 extends Base
     with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M1, M2 {}
 class /*error:INCONSISTENT_METHOD_INHERITANCE*/T3 extends Base
     with M2, /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M1 {}
+
+
+class /*error:INCONSISTENT_METHOD_INHERITANCE*/U1 = Base
+    with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M1;
+class /*error:INCONSISTENT_METHOD_INHERITANCE*/U2 = Base
+    with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M1, M2;
+class /*error:INCONSISTENT_METHOD_INHERITANCE*/U3 = Base
+    with M2, /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M1;
 ''');
   }
 
   test_invalidOverrides_mixinOverrideToMixin() async {
     await checkFile('''
 class A {}
 class B {}
 
 class Base {
 }
 
 class M1 {
     m(B a) {}
     int x;
 }
 
 class M2 {
     m(A a) {}
     int x;
 }
 
 class /*error:INCONSISTENT_METHOD_INHERITANCE*/T1 extends Base
     with M1,
     /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M2 {}
+
+class /*error:INCONSISTENT_METHOD_INHERITANCE*/U1 = Base
+    with M1,
+    /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M2;
 ''');
   }
 
   test_invalidOverrides_noDuplicateMixinOverride() async {
     // 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.
     await 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 /*error:INCONSISTENT_METHOD_INHERITANCE*/T1 extends Base
     with M1, /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M2, M3 {}
+
+class /*error:INCONSISTENT_METHOD_INHERITANCE*/U1 = Base
+    with M1, /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M2, M3;
 ''');
   }
 
   test_invalidOverrides_noErrorsIfSubclassCorrectlyOverrideBaseAndInterface() async {
     // This is a case were it is incorrect to say that the base class
     // incorrectly overrides the interface.
     await checkFile('''
 class A {}
 class B {}
 
@@ skipping 10 matching lines @@
     implements I1 {}
 
 class T2 extends Base implements I1 {
     m(a) {}
 }
 
 class /*error:INCONSISTENT_METHOD_INHERITANCE*/T3
     extends Object with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/Base
     implements I1 {}
 
+class /*error:INCONSISTENT_METHOD_INHERITANCE*/U3
+    = Object with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/Base
+    implements I1;
+
 class T4 extends Object with Base implements I1 {
     m(a) {}
 }
 ''');
   }
 
   test_invalidRuntimeChecks() async {
     await checkFile('''
 typedef int I2I(int x);
 typedef int D2I(x);
@@ skipping 192 matching lines @@
     m(A a);
 }
 abstract class Base implements I1 {}
 
 class M {
     m(B a) {}
 }
 
 class /*error:INCONSISTENT_METHOD_INHERITANCE*/T1 extends Base
     with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M {}
+
+class /*error:INCONSISTENT_METHOD_INHERITANCE*/U1 = Base
+    with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M;
 ''');
   }
 
   test_mixinOverrideOfGrandInterface_interfaceOfConcreteSuperclass() async {
     await checkFile('''
 class A {}
 class B {}
 
 abstract class I1 {
     m(A a);
 }
 
 class /*error:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE*/Base
     implements I1 {}
 
 class M {
     m(B a) {}
 }
 
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/T1 extends Base
-    with M {}
+class /*error:INCONSISTENT_METHOD_INHERITANCE*/T1 extends Base with M {}
+
+class /*error:INCONSISTENT_METHOD_INHERITANCE*/U1 = Base with M;
 ''');
   }
 
   test_mixinOverrideOfGrandInterface_interfaceOfInterfaceOfChild() async {
     await checkFile('''
 class A {}
 class B {}
 
 abstract class I1 {
     m(A a);
 }
 abstract class I2 implements I1 {}
 
 class M {
     m(B a) {}
 }
 
 class /*error:INCONSISTENT_METHOD_INHERITANCE*/T1
     extends Object with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M
     implements I2 {}
+
+class /*error:INCONSISTENT_METHOD_INHERITANCE*/U1
+    = Object with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M
+    implements I2;
 ''');
   }
 
   test_mixinOverrideOfGrandInterface_mixinOfInterfaceOfChild() async {
     await checkFile('''
 class A {}
 class B {}
 
 abstract class M1 {
     m(A a);
 }
 abstract class I2 extends Object with M1 {}
 
 class M {
     m(B a) {}
 }
 
 class /*error:INCONSISTENT_METHOD_INHERITANCE*/T1
     extends Object with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M
     implements I2 {}
+
+class /*error:INCONSISTENT_METHOD_INHERITANCE*/U1
+    = Object with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M
+    implements I2;
 ''');
   }
 
   test_mixinOverrideOfGrandInterface_superclassOfInterfaceOfChild() async {
     await checkFile('''
 class A {}
 class B {}
 
 abstract class I1 {
     m(A a);
 }
 abstract class I2 extends I1 {}
 
 class M {
     m(B a) {}
 }
 
 class /*error:INCONSISTENT_METHOD_INHERITANCE*/T1
     extends Object with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M
     implements I2 {}
+
+class /*error:INCONSISTENT_METHOD_INHERITANCE*/U1
+    = Object with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M
+    implements I2;
 ''');
   }
 
-  test_noDuplicateReportsFromOverridingInterfaces_baseTypeAndMixinOverrideSameMethodInInterface() async {
+  test_noDuplicateReports_baseTypeAndMixinOverrideSameMethodInInterface() async {
     await 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 /*error:INCONSISTENT_METHOD_INHERITANCE*/T1
     /*error:INVALID_METHOD_OVERRIDE_FROM_BASE*/extends Base
     with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M
     implements I1 {}
+
+
+// Here we want to report both, because the error location is
+// different.
+// TODO(sigmund): should we merge these as well?
+class /*error:INCONSISTENT_METHOD_INHERITANCE*/U1 =
+    /*error:INVALID_METHOD_OVERRIDE_FROM_BASE*/Base
+    with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M
+    implements I1;
 ''');
   }
 
-  test_noDuplicateReportsFromOverridingInterfaces_twoGrandTypesOverrideSameMethodInInterface() async {
+  test_noDuplicateReports_twoGrandTypesOverrideSameMethodInInterface() async {
     await checkFile('''
 class A {}
 class B {}
 
 abstract class I1 {
     m(A a);
 }
 
 class Grandparent {
     m(B a) {}
 }
 
 class Parent1 extends Grandparent {
     m(B a) {}
 }
 class Parent2 extends Grandparent {}
 
 // Note: otherwise both errors would be reported on this line
 class /*error:INCONSISTENT_METHOD_INHERITANCE*/T1
     /*error:INVALID_METHOD_OVERRIDE_FROM_BASE*/extends Parent1
     implements I1 {}
 class /*error:INCONSISTENT_METHOD_INHERITANCE*/T2
     /*error:INVALID_METHOD_OVERRIDE_FROM_BASE*/extends Parent2
     implements I1 {}
 ''');
   }
 
-  test_noDuplicateReportsFromOverridingInterfaces_twoMixinsOverrideSameMethodInInterface() async {
+  test_noDuplicateReports_twoMixinsOverrideSameMethodInInterface() async {
     await 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 /*error:INCONSISTENT_METHOD_INHERITANCE*/T1 extends Object
     with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M1,
     /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M2
     implements I1 {}
 ''');
   }
 
-  test_noDuplicateReportsFromOverridingInterfaces_typeAndBaseTypeOverrideSameMethodInInterface() async {
+  test_noDuplicateReports_typeAndBaseTypeOverrideSameMethodInInterface() async {
     await checkFile('''
 class A {}
 class B {}
 
 abstract class I1 {
     m(A a);
 }
 
 class Base {
     m(B a) {}
 }
 
 // Note: no error reported in `extends Base` to avoid duplicating
 // the error in T1.
 class T1 extends Base implements I1 {
   /*error:INVALID_METHOD_OVERRIDE*/m(B a) {}
 }
 
 // If there is no error in the class, we do report the error at
 // the base class:
 class /*error:INCONSISTENT_METHOD_INHERITANCE*/T2
     /*error:INVALID_METHOD_OVERRIDE_FROM_BASE*/extends Base
     implements I1 {}
 ''');
   }
 
-  test_noDuplicateReportsFromOverridingInterfaces_typeAndMixinOverrideSameMethodInInterface() async {
+  test_noDuplicateReports_typeAndMixinOverrideSameMethodInInterface() async {
     await checkFile('''
 class A {}
 class B {}
 
 abstract class I1 {
     m(A a);
 }
 
 class M {
     m(B a) {}
 }
 
 class T1 extends Object with M implements I1 {
   /*error:INVALID_METHOD_OVERRIDE*/m(B a) {}
 }
 
 class /*error:INCONSISTENT_METHOD_INHERITANCE*/T2
     extends Object with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M
     implements I1 {}
+
+class /*error:INCONSISTENT_METHOD_INHERITANCE*/U2
+    = Object with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M
+    implements I1;
 ''');
   }
 
-  test_noDuplicateReportsFromOverridingInterfaces_typeOverridesSomeMethodInMultipleInterfaces() async {
+  test_noDuplicateReports_typeOverridesSomeMethodInMultipleInterfaces() async {
     await checkFile('''
 class A {}
 class B {}
 
 abstract class I1 {
     m(A a);
 }
 abstract class I2 implements I1 {
     m(A a);
 }
@@ skipping 959 matching lines @@
 class CheckerTest_Driver extends CheckerTest {
   @override
   bool get enableNewAnalysisDriver => true;
 
   @failingTest
   @override
   test_covariantOverride_fields() async {
     await super.test_covariantOverride_fields();
   }
 }