Avoid issuing incorrect errors when super mixins are enabled

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 2621 matching lines @@
 }
 
 abstract class M2 = Object with M;
 
 class C2 extends Object with M2 {
   /*error:INVALID_METHOD_OVERRIDE*/String x;
 }
     ''');
   }
 
+  test_interfacesFromMixinsOnlyConsiderMostDerivedMember() {
+    // Regression test for dart2js interface pattern in strong mode.
+    return checkFile(r'''
+abstract class I1 { num get x; }
+abstract class I2 extends I1 { int get x; }
+
+class M1 { num get x => 0; }
+class M2 { int get x => 0; }
+
+class Base extends Object with M1 implements I1 {}
+class Child extends Base with M2 implements I2 {}
+
+class C extends Object with M1, M2 implements I1, I2 {}
+    ''');
+  }
+
   test_interfacesFromMixinsUsedTwiceAreChecked() {
     // Regression test for https://github.com/dart-lang/sdk/issues/29782
     return checkFile(r'''
 abstract class I<E> {
   set x(E v);
 }
 abstract class M<E> implements I<E> {}
 
 class C extends Object with M<int> {
   /*error:INVALID_METHOD_OVERRIDE*/String x;
 }
 
 abstract class D extends Object with M<num> {}
 class E extends D with M<int> {
   /*error:INVALID_METHOD_OVERRIDE*/int x;
 }
 class F extends D with M<int> {
   num x;
 }
     ''');
   }
 
-  test_interfacesFromMixinsOnlyConsiderMostDerivedMember() {
-    // Regression test for dart2js interface pattern in strong mode.
-    return checkFile(r'''
-abstract class I1 { num get x; } 
-abstract class I2 extends I1 { int get x; }
-
-class M1 { num get x => 0; }
-class M2 { int get x => 0; }
-
-class Base extends Object with M1 implements I1 {}
-class Child extends Base with M2 implements I2 {}
-
-class C extends Object with M1, M2 implements I1, I2 {}
-    ''');
-  }
-
   test_invalidOverrides_baseClassOverrideToChildInterface() async {
     await checkFile('''
 class A {}
 class B {}
 
 abstract class I {
     m(A a);
 }
 
 class Base {
@@ skipping 473 matching lines @@
     await checkFile(r'''
 class A {
   void foo(dynamic x) {}
   void test(void f(int x)) {
     test(foo);
   }
 }
     ''');
   }
 
+  test_mixinApplicationIsConcrete() async {

[Jennifer Messerly, 2017/07/27 21:07:58]

style thing: existing tests in this file often use async/await needlessly.

I've been fixing tests where possible to be:

    test_mixinApplicationIsConcrete() {
      return checkFile(...);
    }

because checkFile return a Future, there's not really a need for async/await in
most tests. (also "checkFile" does "addFile" and "check" in one step)

[Leaf, 2017/07/27 21:38:09]

Done.

+    addFile(r'''
+class A {
+  int get foo => 3;
+}
+
+class B {
+  num get foo => 3.0;
+}
+
+class C = Object with B;
+
+class D extends Object with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/C implements A {}
+    ''');
+    await check();
+  }
+
   test_mixinOverrideOfGrandInterface_interfaceOfAbstractSuperclass() async {
     await checkFile('''
 class A {}
 class B {}
 
 abstract class I1 {
     m(A a);
 }
 abstract class Base implements I1 {}
 
@@ skipping 723 matching lines @@
 
   test_superConstructor() async {
     await checkFile('''
 class A { A(A x) {} }
 class B extends A {
   B() : super(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/3);
 }
 ''');
   }
 
+  @failingTest
+  test_superMixin_invalidApplication() async {

[Jennifer Messerly, 2017/07/27 21:07:58]

(same comment from above would apply to these tests too)

[Leaf, 2017/07/27 21:38:09]

Done.

+    //Failing: https://github.com/dart-lang/sdk/issues/30283

[Jennifer Messerly, 2017/07/27 21:07:58]

trivia nit: space after "//"

[Leaf, 2017/07/27 21:38:09]

Done.

+    addFile(r'''
+    class A {
+  int get foo => 3;
+}
+
+// This expects a super class which satisfies the contract of A
+class B extends A {}
+
+class C {
+  num get foo => null;
+}
+
+// This mixin application doesn't provide a valid superclass for B
+class D extends C with /*error:INCONSISTENT_METHOD_INHERITANCE*/B {}
+}
+    ''');
+    await check(superMixins: true);
+  }
+
+  test_superMixinsMakeSuperclassMethodsAbstract() async {
+    addFile(r'''
+  abstract class A {}
+
+abstract class B extends A {}
+
+abstract class ProvidesConcreteAGetter {
+  A get constraints => null;
+}
+
+abstract class ProvidesConcreteBGetter extends ProvidesConcreteAGetter {
+  @override
+  B get constraints => null;
+}
+
+abstract class ProvidesAbstractBGetter implements ProvidesConcreteBGetter {}
+
+abstract class ProvidesAbstractAGetterMixin extends ProvidesConcreteAGetter {}
+
+abstract class HasConcreteBGetterButMixesinAbstractAGetter
+    extends ProvidesConcreteBGetter
+    with ProvidesAbstractAGetterMixin, ProvidesAbstractBGetter {}
+    ''');
+    await check(superMixins: true);
+  }
+
   test_tearOffTreatedConsistentlyAsStrictArrow() async {
     await checkFile(r'''
 void foo(void f(String x)) {}
 
 class A {
   Null bar1(dynamic x) => null;
   void bar2(dynamic x) => null;
   Null bar3(String x) => null;
   void test() {
     foo(bar1);
@@ skipping 470 matching lines @@
 class CheckerTest_Driver extends CheckerTest {
   @override
   bool get enableNewAnalysisDriver => true;
 
   @failingTest
   @override
   test_covariantOverride_fields() async {
     await super.test_covariantOverride_fields();
   }
 }