Replicate existing analyzer supermixin tests using new "mixin" syntax.

A few test cases fail.  I'll investigate them and follow up with fixes.

Change-Id: I934e82a2ecec68f72ed46fb698b065186ef38aad
Reviewed-on: https://dart-review.googlesource.com/75980
Reviewed-by: Konstantin Shcheglov <scheglov@google.com>
Commit-Queue: Paul Berry <paulberry@google.com>

pkg/analyzer/test/generated/compile_time_error_code_driver_test.dart

@@ -20,4 +20,8 @@ class CompileTimeErrorCodeTest_Driver extends CompileTimeErrorCodeTest {
   @override // Passes with driver
   test_mixinInference_recursiveSubtypeCheck() =>
       super.test_mixinInference_recursiveSubtypeCheck();
+
+  @override // Passes with driver
+  test_mixinInference_recursiveSubtypeCheck_new_syntax() =>
+      super.test_mixinInference_recursiveSubtypeCheck_new_syntax();
 }

pkg/analyzer/test/generated/compile_time_error_code_test.dart

@@ -3823,6 +3823,29 @@ class C extends Object with M1, M2 {}
     assertNoErrors(source);
   }
 
+  test_mixinInference_matchingClass_inPreviousMixin_new_syntax() async {
+    Source source = addSource('''
+abstract class A<T> {}
+class B {}
+mixin M1 implements A<B> {}
+mixin M2<T> on A<T> {}
+class C extends Object with M1, M2 {}
+''');
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
+  }
+
+  test_mixinInference_matchingClass_new_syntax() async {
+    Source source = addSource('''
+abstract class A<T> {}
+class B {}
+mixin M<T> on A<T> {}
+class C extends A<int> with M {}
+''');
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
+  }
+
   test_mixinInference_noMatchingClass() async {
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.enableSuperMixins = true;
@@ -3853,6 +3876,31 @@ class C = Object with M;
         source, [CompileTimeErrorCode.MIXIN_INFERENCE_NO_MATCHING_CLASS]);
   }
 
+  @failingTest
+  test_mixinInference_noMatchingClass_namedMixinApplication_new_syntax() async {
+    Source source = addSource('''
+abstract class A<T> {}
+class B {}
+mixin M<T> on A<T> {}
+class C = Object with M;
+''');
+    await computeAnalysisResult(source);
+    assertErrors(
+        source, [CompileTimeErrorCode.MIXIN_INFERENCE_NO_MATCHING_CLASS]);
+  }
+
+  test_mixinInference_noMatchingClass_new_syntax() async {
+    Source source = addSource('''
+abstract class A<T> {}
+class B {}
+mixin M<T> on A<T> {}
+class C extends Object with M {}
+''');
+    await computeAnalysisResult(source);
+    assertErrors(source,
+        [CompileTimeErrorCode.MIXIN_APPLICATION_NOT_IMPLEMENTED_INTERFACE]);
+  }
+
   test_mixinInference_noMatchingClass_noSuperclassConstraint() async {
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.enableSuperMixins = true;
@@ -3867,6 +3915,18 @@ class C extends Object with M {}
     assertNoErrors(source);
   }
 
+  test_mixinInference_noMatchingClass_noSuperclassConstraint_new_syntax() async {
+    Source source = addSource('''
+abstract class A<T> {}
+class B {}
+mixin M<T> {}
+class C extends Object with M {}
+''');
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
+  }
+
+  @failingTest
   test_mixinInference_noMatchingClass_typeParametersSupplied() async {
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.enableSuperMixins = true;
@@ -3878,7 +3938,20 @@ class M<T> extends A<T> {}
 class C extends Object with M<int> {}
 ''');
     await computeAnalysisResult(source);
-    assertNoErrors(source);
+    assertErrors(source,
+        [CompileTimeErrorCode.MIXIN_APPLICATION_NOT_IMPLEMENTED_INTERFACE]);
+  }
+
+  test_mixinInference_noMatchingClass_typeParametersSupplied_new_syntax() async {
+    Source source = addSource('''
+abstract class A<T> {}
+class B {}
+mixin M<T> on A<T> {}
+class C extends Object with M<int> {}
+''');
+    await computeAnalysisResult(source);
+    assertErrors(source,
+        [CompileTimeErrorCode.MIXIN_APPLICATION_NOT_IMPLEMENTED_INTERFACE]);
   }
 
   @failingTest // Does not work with old task model
@@ -3920,6 +3993,42 @@ abstract class DirectoryAddOnsMixin implements Directory {}
     expect(mixins[0].toString(), 'ForwardingDirectory<_LocalDirectory>');
   }
 
+  @failingTest // Does not work with old task model
+  test_mixinInference_recursiveSubtypeCheck_new_syntax() async {
+    // See dartbug.com/32353 for a detailed explanation.
+    Source source = addSource('''
+class ioDirectory implements ioFileSystemEntity {}
+
+class ioFileSystemEntity {}
+
+abstract class _LocalDirectory
+    extends _LocalFileSystemEntity<_LocalDirectory, ioDirectory>
+    with ForwardingDirectory, DirectoryAddOnsMixin {}
+
+abstract class _LocalFileSystemEntity<T extends FileSystemEntity,
+  D extends ioFileSystemEntity> extends ForwardingFileSystemEntity<T, D> {}
+
+abstract class FileSystemEntity implements ioFileSystemEntity {}
+
+abstract class ForwardingFileSystemEntity<T extends FileSystemEntity,
+  D extends ioFileSystemEntity> implements FileSystemEntity {}
+
+
+mixin ForwardingDirectory<T extends Directory>
+    on ForwardingFileSystemEntity<T, ioDirectory>
+    implements Directory {}
+
+abstract class Directory implements FileSystemEntity, ioDirectory {}
+
+mixin DirectoryAddOnsMixin implements Directory {}
+''');
+    var analysisResult = await computeAnalysisResult(source);
+    assertNoErrors(source);
+    var mixins =
+        analysisResult.unit.declaredElement.getType('_LocalDirectory').mixins;
+    expect(mixins[0].toString(), 'ForwardingDirectory<_LocalDirectory>');
+  }
+
   test_mixinInheritsFromNotObject_classDeclaration_extends() async {
     Source source = addSource(r'''
 class A {}

pkg/analyzer/test/generated/non_error_resolver_driver_test.dart

@@ -23,6 +23,12 @@ class NonErrorResolverTest_Driver extends NonErrorResolverTestBase {
     return super.test_constConstructorWithMixinWithField_withoutSuperMixins();
   }
 
+  @override
+  @failingTest
+  test_infer_mixin_with_substitution_functionType_new_syntax() {
+    return super.test_infer_mixin_with_substitution_functionType_new_syntax();
+  }
+
   @override
   @failingTest
   test_intLiteralInDoubleContext_const_exact() {

pkg/analyzer/test/generated/non_error_resolver_test.dart

@@ -44,6 +44,12 @@ class NonErrorResolverTest extends NonErrorResolverTestBase {
     return super.test_infer_mixin_multiplyConstrained();
   }
 
+  @override
+  @failingTest // Does not work with old task model
+  test_infer_mixin_new_syntax() {
+    return super.test_infer_mixin_new_syntax();
+  }
+
   @override
   @failingTest // Does not work with old task model
   test_infer_mixin_with_substitution() {
@@ -56,6 +62,18 @@ class NonErrorResolverTest extends NonErrorResolverTestBase {
     return super.test_infer_mixin_with_substitution_functionType();
   }
 
+  @override
+  @failingTest
+  test_infer_mixin_with_substitution_functionType_new_syntax() {
+    return super.test_infer_mixin_with_substitution_functionType_new_syntax();
+  }
+
+  @override
+  @failingTest // Does not work with old task model
+  test_infer_mixin_with_substitution_new_syntax() {
+    return super.test_infer_mixin_with_substitution_new_syntax();
+  }
+
   @override
   @failingTest
   test_intLiteralInDoubleContext_const_exact() {
@@ -1316,6 +1334,18 @@ class A extends Object with M {
     verify([source]);
   }
 
+  test_constConstructorWithMixinWithField_withSuperMixins_new_syntax() async {
+    Source source = addSource(r'''
+mixin M {
+}
+class A extends Object with M {
+  const A();
+}''');
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
   test_constConstructorWithNonConstSuper_explicit() async {
     Source source = addSource(r'''
 class A {
@@ -2700,6 +2730,26 @@ class F extends E with M {}
     expect(classF.mixins[0].toString(), 'M<C, D>');
   }
 
+  test_infer_mixin_new_syntax() async {
+    Source source = addSource('''
+abstract class A<T> {}
+
+class B {}
+
+mixin M<T> on A<T> {}
+
+class C extends A<B> with M {}
+''');
+    TestAnalysisResult analysisResult = await computeAnalysisResult(source);
+    assertNoErrors(source);
+    verify([source]);
+    CompilationUnit unit = analysisResult.unit;
+    ClassElement classC =
+        resolutionMap.elementDeclaredByCompilationUnit(unit).getType('C');
+    expect(classC.mixins, hasLength(1));
+    expect(classC.mixins[0].toString(), 'M<B>');
+  }
+
   test_infer_mixin_with_substitution() async {
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.enableSuperMixins = true;
@@ -2745,6 +2795,45 @@ class C extends A<int Function(String)> with M {}
     expect(classC.mixins[0].toString(), 'M<int, String>');
   }
 
+  test_infer_mixin_with_substitution_functionType_new_syntax() async {
+    Source source = addSource('''
+abstract class A<T> {}
+
+class B {}
+
+mixin M<T, U> on A<T Function(U)> {}
+
+class C extends A<int Function(String)> with M {}
+''');
+    TestAnalysisResult analysisResult = await computeAnalysisResult(source);
+    assertNoErrors(source);
+    CompilationUnit unit = analysisResult.unit;
+    ClassElement classC =
+        resolutionMap.elementDeclaredByCompilationUnit(unit).getType('C');
+    expect(classC.mixins, hasLength(1));
+    expect(classC.mixins[0].toString(), 'M<int, String>');
+  }
+
+  test_infer_mixin_with_substitution_new_syntax() async {
+    Source source = addSource('''
+abstract class A<T> {}
+
+class B {}
+
+mixin M<T> on A<List<T>> {}
+
+class C extends A<List<B>> with M {}
+''');
+    TestAnalysisResult analysisResult = await computeAnalysisResult(source);
+    assertNoErrors(source);
+    verify([source]);
+    CompilationUnit unit = analysisResult.unit;
+    ClassElement classC =
+        resolutionMap.elementDeclaredByCompilationUnit(unit).getType('C');
+    expect(classC.mixins, hasLength(1));
+    expect(classC.mixins[0].toString(), 'M<B>');
+  }
+
   test_initializingFormalForNonExistentField() async {
     Source source = addSource(r'''
 class A {
@@ -3986,7 +4075,17 @@ void main () {
     Source source = addSource(r'''
 class A {}
 class B extends A {}
-class C extends Object with B {}''');
+class C extends A with B {}''');
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
+  test_mixinInheritsFromNotObject_classDeclaration_extends_new_syntax() async {
+    Source source = addSource(r'''
+class A {}
+mixin B on A {}
+class C extends A with B {}''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
@@ -4022,7 +4121,17 @@ class C extends Object with B {}''');
     Source source = addSource(r'''
 class A {}
 class B extends A {}
-class C = Object with B;''');
+class C = A with B;''');
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
+  test_mixinInheritsFromNotObject_typeAlias_extends_new_syntax() async {
+    Source source = addSource(r'''
+class A {}
+mixin B on A {}
+class C = A with B;''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
@@ -4065,6 +4174,17 @@ class B extends Object with A {}''');
     verify([source]);
   }
 
+  test_mixinReferencesSuper_new_syntax() async {
+    Source source = addSource(r'''
+mixin A {
+  toString() => super.toString();
+}
+class B extends Object with A {}''');
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
   test_multipleSuperInitializers_no() async {
     Source source = addSource(r'''
 class A {}