Improve error reporting when a mixin application is invalid.

pkg/analyzer/test/generated/compile_time_error_code_test.dart

 // Copyright (c) 2014, 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 engine.compile_time_error_code_test;
 
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/parser.dart' show ParserErrorCode;
 import 'package:analyzer/src/generated/engine.dart';
@@ skipping 2894 matching lines @@
   }
 
   void test_mixinHasNoConstructors_mixinClass() {
     Source source = addSource(r'''
 class B {
   B({x});
 }
 class M {}
 class C extends B with M {}
 ''');
+    // Note: the implicit call from C's default constructor to B() should not
+    // generate a further error (despite the fact that it's not forwarded),
+    // since CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS does a better job
+    // of explaining the probem to the user.
     resolve(source);
-    assertErrors(source, [CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
+    assertErrors(source, [CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS]);
     verify([source]);
   }
 
+  void test_mixinHasNoConstructors_mixinClass_explicitSuperCall() {
+    Source source = addSource(r'''
+class B {
+  B({x});
+}
+class M {}
+class C extends B with M {
+  C() : super();
+}
+''');
+    // Note: the explicit call from C() to B() should not generate a further
+    // error (despite the fact that it's not forwarded), since
+    // CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS does a better job of
+    // explaining the error to the user.
+    resolve(source);
+    assertErrors(source, [CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS]);
+    verify([source]);
+  }
+
+  void test_mixinHasNoConstructors_mixinClass_implicitSuperCall() {
+    Source source = addSource(r'''
+class B {
+  B({x});
+}
+class M {}
+class C extends B with M {
+  C();
+}
+''');
+    // Note: the implicit call from C() to B() should not generate a further
+    // error (despite the fact that it's not forwarded), since
+    // CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS does a better job of
+    // explaining the error to the user.
+    resolve(source);
+    assertErrors(source, [CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS]);
+    verify([source]);
+  }
+
+  void test_mixinHasNoConstructors_mixinClass_namedSuperCall() {
+    Source source = addSource(r'''
+class B {
+  B.named({x});
+}
+class M {}
+class C extends B with M {
+  C() : super.named();
+}
+''');
+    // Note: the explicit call from C() to B.named() should not generate a
+    // further error (despite the fact that it's not forwarded), since
+    // CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS does a better job of
+    // explaining the error to the user.
+    resolve(source);
+    assertErrors(source, [CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS]);
+    verify([source]);
+  }
+
   void test_mixinInheritsFromNotObject_classDeclaration_extends() {
     Source source = addSource(r'''
 class A {}
 class B extends A {}
 class C extends Object with B {}''');
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT]);
     verify([source]);
   }
 
@@ skipping 345 matching lines @@
     assertErrors(source, [
         CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT]);
     verify([source]);
   }
 
   void test_noDefaultSuperConstructorExplicit_MixinWithDirectSuperCall() {
     Source source = addSource(r'''
 class M {}
 class B {
   B({x});
+  B.other();
 }
 class C extends B with M {
   C(x) : super();
 }
 ''');
     resolve(source);
     assertErrors(source, [
         CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT]);
     verify([source]);
   }
 
   void test_noDefaultSuperConstructorExplicit_MixinWithNamedSuperCall() {
     Source source = addSource(r'''
 class M {}
 class B {
   B.named({x});
+  B.other();
 }
 class C extends B with M {
   C(x) : super.named();
 }
 ''');
     resolve(source);
     assertErrors(source, [
         CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER]);
     // Don't verify since call to super.named() can't be resolved.
   }
 
   void test_noDefaultSuperConstructorExplicit_mixinWithNamedParam() {
     Source source = addSource(r'''
 class M {}
 class B {
   B({x});
+  B.named();
 }
 class C extends B with M {
   C();
 }
 ''');
     resolve(source);
     assertErrors(source, [
         CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT]);
     verify([source]);
   }
 
   void test_noDefaultSuperConstructorExplicit_mixinWithOptionalParam() {
     Source source = addSource(r'''
 class M {}
 class B {
   B([x]);
+  B.other();
 }
 class C extends B with M {
   C();
 }
 ''');
     resolve(source);
     assertErrors(source, [
         CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT]);
     verify([source]);
   }
@@ skipping 28 matching lines @@
     assertErrors(source, [
         CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
     verify([source]);
   }
 
   void test_noDefaultSuperConstructorImplicit_mixinWithNamedParam() {
     Source source = addSource(r'''
 class M {}
 class B {
   B({x});
+  B.other();
 }
 class C extends B with M {}
 ''');
     resolve(source);
     assertErrors(source, [
         CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
     verify([source]);
   }
 
   void test_noDefaultSuperConstructorImplicit_mixinWithOptionalParam() {
     Source source = addSource(r'''
 class M {}
 class B {
   B([x]);
+  B.other();
 }
 class C extends B with M {}
 ''');
     resolve(source);
     assertErrors(source, [
         CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
     verify([source]);
   }
 
   void test_noDefaultSuperConstructorImplicit_superHasParameters() {
@@ skipping 1577 matching lines @@
   void _check_wrongNumberOfParametersForOperator1(String name) {
     _check_wrongNumberOfParametersForOperator(name, "");
     _check_wrongNumberOfParametersForOperator(name, "a, b");
   }
 }
 
 main() {
   _ut.groupSep = ' | ';
   runReflectiveTests(CompileTimeErrorCodeTest);
 }