Fix analyzer's treatment of mixin constructors.

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 1381 matching lines @@
         CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS,
         CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
     verify([source]);
   }
 
   void test_extendsDisallowedClass_classTypeAlias_bool() {
     Source source = addSource(r'''
 class M {}
 class C = bool with M;''');
     resolve(source);
-    assertErrors(source, [CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS]);
+    assertErrors(source, [CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS,
+                          CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS]);

[Brian Wilkerson, 2014/11/07 16:59:32]

It would be good to disable the second error if the first has already been
produced because it seems like a duplicate to me.

[Paul Berry, 2014/11/07 17:31:01]

Good point.  I'll do this in a follow-up CL, as well as the other improvements
we discussed in person.

     verify([source]);
   }
 
   void test_extendsDisallowedClass_classTypeAlias_double() {
     Source source = addSource(r'''
 class M {}
 class C = double with M;''');
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS]);
     verify([source]);
   }
 
   void test_extendsDisallowedClass_classTypeAlias_int() {
     Source source = addSource(r'''
 class M {}
 class C = int with M;''');
     resolve(source);
-    assertErrors(source, [CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS]);
+    assertErrors(source, [CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS,
+                          CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS]);
     verify([source]);
   }
 
   void test_extendsDisallowedClass_classTypeAlias_Null() {
     Source source = addSource(r'''
 class M {}
 class C = Null with M;''');
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS]);
     verify([source]);
   }
 
   void test_extendsDisallowedClass_classTypeAlias_num() {
     Source source = addSource(r'''
 class M {}
 class C = num with M;''');
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS]);
     verify([source]);
   }
 
   void test_extendsDisallowedClass_classTypeAlias_String() {
     Source source = addSource(r'''
 class M {}
 class C = String with M;''');
     resolve(source);
-    assertErrors(source, [CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS]);
+    assertErrors(source, [CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS,
+                          CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS]);
     verify([source]);
   }
 
   void test_extendsEnum() {
     AnalysisOptionsImpl analysisOptions = new AnalysisOptionsImpl();
     analysisOptions.enableEnum = true;
     resetWithOptions(analysisOptions);
     Source source = addSource(r'''
 enum E { ONE }
 class A extends E {}''');
@@ skipping 1443 matching lines @@
         r'''
 library lib1;
 class A {}''',
         r'''
 library root;
 import 'lib1.dart' deferred as a;
 class B {}
 class C = B with a.A;'''], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.MIXIN_DEFERRED_CLASS]);
   }
 
+  void test_mixinHasNoConstructors_mixinApp() {
+    Source source = addSource(r'''
+class B {
+  B({x});
+}
+class M {}
+class C = B with M;
+''');
+    resolve(source);
+    assertErrors(source, [CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS]);
+    verify([source]);
+  }
+
+  void test_mixinHasNoConstructors_mixinClass() {
+    Source source = addSource(r'''
+class B {
+  B({x});
+}
+class M {}
+class C extends B with M {}
+''');
+    resolve(source);
+    assertErrors(source, [CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
+    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 268 matching lines @@
   A(p);
 }
 class B extends A {
   B() {}
 }''');
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT]);
     verify([source]);
   }
 
+  void test_noDefaultSuperConstructorExplicit_MixinAppWithDirectSuperCall() {
+    Source source = addSource(r'''
+class M {}
+class B {
+  B({x});
+  B.named(); // To avoid MIXIN_HAS_NO_CONSTRUCTORS
+}
+class Mixed = B with M;
+class C extends Mixed {
+  C(x) : super();
+}
+''');
+    resolve(source);
+    assertErrors(source, [
+        CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT]);
+    verify([source]);
+  }
+
+  void test_noDefaultSuperConstructorExplicit_MixinAppWithNamedSuperCall() {
+    Source source = addSource(r'''
+class M {}
+class B {
+  B.named({x});
+  B.named2(); // To avoid MIXIN_HAS_NO_CONSTRUCTORS
+}
+class Mixed = B with M;
+class C extends Mixed {
+  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_mixinAppWithNamedParam() {
+    Source source = addSource(r'''
+class M {}
+class B {
+  B({x});
+  B.named(); // To avoid MIXIN_HAS_NO_CONSTRUCTORS
+}
+class Mixed = B with M;
+class C extends Mixed {
+  C();
+}
+''');
+    resolve(source);
+    assertErrors(source, [
+        CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT]);
+    verify([source]);
+  }
+
+  void test_noDefaultSuperConstructorExplicit_mixinAppWithOptionalParam() {
+    Source source = addSource(r'''
+class M {}
+class B {
+  B([x]);
+  B.named(); // To avoid MIXIN_HAS_NO_CONSTRUCTORS
+}
+class Mixed = B with M;
+class C extends Mixed {
+  C();
+}
+''');
+    resolve(source);
+    assertErrors(source, [
+        CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT]);
+    verify([source]);
+  }
+
+  void test_noDefaultSuperConstructorExplicit_MixinWithDirectSuperCall() {
+    Source source = addSource(r'''
+class M {}
+class B {
+  B({x});
+}
+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});
+}
+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});
+}
+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]);
+}
+class C extends B with M {
+  C();
+}
+''');
+    resolve(source);
+    assertErrors(source, [
+        CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT]);
+    verify([source]);
+  }
+
+  void test_noDefaultSuperConstructorImplicit_mixinAppWithNamedParam() {
+    Source source = addSource(r'''
+class M {}
+class B {
+  B({x});
+  B.named(); // To avoid MIXIN_HAS_NO_CONSTRUCTORS
+}
+class Mixed = B with M;
+class C extends Mixed {}
+''');
+    resolve(source);
+    assertErrors(source, [
+        CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
+    verify([source]);
+  }
+
+  void test_noDefaultSuperConstructorImplicit_mixinAppWithOptionalParam() {
+    Source source = addSource(r'''
+class M {}
+class B {
+  B([x]);
+  B.named(); // To avoid MIXIN_HAS_NO_CONSTRUCTORS
+}
+class Mixed = B with M;
+class C extends Mixed {}
+''');
+    resolve(source);
+    assertErrors(source, [
+        CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
+    verify([source]);
+  }
+
+  void test_noDefaultSuperConstructorImplicit_mixinWithNamedParam() {
+    Source source = addSource(r'''
+class M {}
+class B {
+  B({x});
+}
+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]);
+}
+class C extends B with M {}
+''');
+    resolve(source);
+    assertErrors(source, [
+        CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
+    verify([source]);
+  }
+
   void test_noDefaultSuperConstructorImplicit_superHasParameters() {
     Source source = addSource(r'''
 class A {
   A(p);
 }
 class B extends A {
 }''');
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
     verify([source]);
@@ skipping 1568 matching lines @@
   void _check_wrongNumberOfParametersForOperator1(String name) {
     _check_wrongNumberOfParametersForOperator(name, "");
     _check_wrongNumberOfParametersForOperator(name, "a, b");
   }
 }
 
 main() {
   _ut.groupSep = ' | ';
   runReflectiveTests(CompileTimeErrorCodeTest);
 }