Compute mixin application constructors in the ClassElement.constructors getter.

pkg/analyzer/test/src/task/dart_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 test.src.task.dart_test;
 
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element.dart';
@@ skipping 10 matching lines @@
 import 'package:analyzer/task/general.dart';
 import 'package:analyzer/task/model.dart';
 import 'package:unittest/unittest.dart';
 
 import '../../generated/test_support.dart';
 import '../../reflective_tests.dart';
 import '../context/abstract_context.dart';
 
 main() {
   groupSep = ' | ';
-  runReflectiveTests(BuildClassConstructorsTaskTest);
   runReflectiveTests(BuildCompilationUnitElementTaskTest);
   runReflectiveTests(BuildDirectiveElementsTaskTest);
   runReflectiveTests(BuildEnumMemberElementsTaskTest);
   runReflectiveTests(BuildSourceExportClosureTaskTest);
   runReflectiveTests(BuildSourceImportExportClosureTaskTest);
   runReflectiveTests(BuildExportNamespaceTaskTest);
-  runReflectiveTests(BuildLibraryConstructorsTaskTest);
   runReflectiveTests(BuildLibraryElementTaskTest);
   runReflectiveTests(BuildPublicNamespaceTaskTest);
   runReflectiveTests(BuildTypeProviderTaskTest);
   runReflectiveTests(ComputeConstantDependenciesTaskTest);
   runReflectiveTests(ComputeConstantValueTaskTest);
   runReflectiveTests(ContainingLibrariesTaskTest);
   runReflectiveTests(DartErrorsTaskTest);
   runReflectiveTests(EvaluateUnitConstantsTaskTest);
   runReflectiveTests(GatherUsedImportedElementsTaskTest);
   runReflectiveTests(GatherUsedLocalElementsTaskTest);
   runReflectiveTests(GenerateHintsTaskTest);
   runReflectiveTests(LibraryErrorsReadyTaskTest);
   runReflectiveTests(LibraryUnitErrorsTaskTest);
   runReflectiveTests(ParseDartTaskTest);
   runReflectiveTests(ResolveUnitTypeNamesTaskTest);
   runReflectiveTests(ResolveLibraryTypeNamesTaskTest);
   runReflectiveTests(ResolveReferencesTaskTest);
   runReflectiveTests(ResolveVariableReferencesTaskTest);
   runReflectiveTests(ScanDartTaskTest);
   runReflectiveTests(VerifyUnitTaskTest);
 }
 
 @reflectiveTest
-class BuildClassConstructorsTaskTest extends _AbstractDartTaskTest {
-  test_perform_ClassDeclaration_errors_mixinHasNoConstructors() {
-    Source source = newSource('/test.dart', '''
-class B {
-  B({x});
-}
-class M {}
-class C extends B with M {}
-''');
-    LibraryElement libraryElement;
-    {
-      computeResult(source, LIBRARY_ELEMENT5);
-      libraryElement = outputs[LIBRARY_ELEMENT5];
-    }
-    // prepare C
-    ClassElement c = libraryElement.getType('C');
-    expect(c, isNotNull);
-    // build constructors
-    computeResult(c, CONSTRUCTORS);
-    expect(task, new isInstanceOf<BuildClassConstructorsTask>());
-    _fillErrorListener(CONSTRUCTORS_ERRORS);
-    errorListener.assertErrorsWithCodes(
-        <ErrorCode>[CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS]);
-  }
-
-  test_perform_ClassDeclaration_explicitConstructors() {
-    Source source = newSource('/test.dart', '''
-class B {
-  B(p);
-}
-class C extends B {
-  C(int a, String b) {}
-}
-''');
-    LibraryElement libraryElement;
-    {
-      computeResult(source, LIBRARY_ELEMENT5);
-      libraryElement = outputs[LIBRARY_ELEMENT5];
-    }
-    // prepare C
-    ClassElement c = libraryElement.getType('C');
-    expect(c, isNotNull);
-    // build constructors
-    computeResult(c, CONSTRUCTORS);
-    expect(task, new isInstanceOf<BuildClassConstructorsTask>());
-    // no errors
-    expect(outputs[CONSTRUCTORS_ERRORS], isEmpty);
-    // explicit constructor
-    List<ConstructorElement> constructors = outputs[CONSTRUCTORS];
-    expect(constructors, hasLength(1));
-    expect(constructors[0].parameters, hasLength(2));
-  }
-
-  test_perform_ClassTypeAlias() {
-    Source source = newSource('/test.dart', '''
-class B {
-  B(int i);
-}
-class M1 {}
-class M2 {}
-
-class C2 = C1 with M2;
-class C1 = B with M1;
-''');
-    LibraryElement libraryElement;
-    {
-      computeResult(source, LIBRARY_ELEMENT5);
-      libraryElement = outputs[LIBRARY_ELEMENT5];
-    }
-    // prepare C2
-    ClassElement class2 = libraryElement.getType('C2');
-    expect(class2, isNotNull);
-    // build constructors
-    computeResult(class2, CONSTRUCTORS);
-    expect(task, new isInstanceOf<BuildClassConstructorsTask>());
-    List<ConstructorElement> constructors = outputs[CONSTRUCTORS];
-    expect(constructors, hasLength(1));
-    expect(constructors[0].parameters, hasLength(1));
-  }
-
-  test_perform_ClassTypeAlias_errors_mixinHasNoConstructors() {
-    Source source = newSource('/test.dart', '''
-class B {
-  B({x});
-}
-class M {}
-class C = B with M;
-''');
-    LibraryElement libraryElement;
-    {
-      computeResult(source, LIBRARY_ELEMENT5);
-      libraryElement = outputs[LIBRARY_ELEMENT5];
-    }
-    // prepare C
-    ClassElement c = libraryElement.getType('C');
-    expect(c, isNotNull);
-    // build constructors
-    computeResult(c, CONSTRUCTORS);
-    expect(task, new isInstanceOf<BuildClassConstructorsTask>());
-    _fillErrorListener(CONSTRUCTORS_ERRORS);
-    errorListener.assertErrorsWithCodes(
-        <ErrorCode>[CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS]);
-  }
-}
-
-@reflectiveTest
 class BuildCompilationUnitElementTaskTest extends _AbstractDartTaskTest {
   Source source;
   LibrarySpecificUnit target;
 
   test_buildInputs() {
     LibrarySpecificUnit target =
         new LibrarySpecificUnit(emptySource, emptySource);
     Map<String, TaskInput> inputs =
         BuildCompilationUnitElementTask.buildInputs(target);
     expect(inputs, isNotNull);
@@ skipping 530 matching lines @@
     {
       LibraryElement library = outputs[LIBRARY_ELEMENT4];
       Namespace namespace = library.exportNamespace;
       Iterable<String> definedKeys = namespace.definedNames.keys;
       expect(definedKeys, unorderedEquals(['A', 'topLevelB', 'topLevelB=']));
     }
   }
 }
 
 @reflectiveTest
-class BuildLibraryConstructorsTaskTest extends _AbstractDartTaskTest {
-  test_perform() {
-    Source source = newSource('/test.dart', '''
-class B {
-  B(int i);
-}
-class M1 {}
-class M2 {}
-
-class C2 = C1 with M2;
-class C1 = B with M1;
-class C3 = B with M2;
-''');
-    computeResult(source, LIBRARY_ELEMENT6);
-    expect(task, new isInstanceOf<BuildLibraryConstructorsTask>());
-    LibraryElement libraryElement = outputs[LIBRARY_ELEMENT6];
-    // C1
-    {
-      ClassElement classElement = libraryElement.getType('C2');
-      List<ConstructorElement> constructors = classElement.constructors;
-      expect(constructors, hasLength(1));
-      expect(constructors[0].parameters, hasLength(1));
-    }
-    // C3
-    {
-      ClassElement classElement = libraryElement.getType('C3');
-      List<ConstructorElement> constructors = classElement.constructors;
-      expect(constructors, hasLength(1));
-      expect(constructors[0].parameters, hasLength(1));
-    }
-  }
-}
-
-@reflectiveTest
 class BuildLibraryElementTaskTest extends _AbstractDartTaskTest {
   Source librarySource;
   CompilationUnit libraryUnit;
   CompilationUnitElement libraryUnitElement;
   List<CompilationUnit> partUnits;
 
   LibraryElement libraryElement;
 
   test_constructor() {
     BuildLibraryElementTask task =
@@ skipping 29 matching lines @@
 part 'part1.dart';
 part 'part2.dart';
 ''',
       '/part1.dart': '''
 part of lib;
 ''',
       '/part2.dart': '''
 part of lib;
 '''
     });
-    expect(outputs, hasLength(4));
+    expect(outputs, hasLength(3));
     // simple outputs
     expect(outputs[BUILD_LIBRARY_ERRORS], isEmpty);
     expect(outputs[IS_LAUNCHABLE], isFalse);
     // LibraryElement output
     expect(libraryElement, isNotNull);
     expect(libraryElement.entryPoint, isNull);
     expect(libraryElement.source, same(librarySource));
     expect(libraryElement.definingCompilationUnit, libraryUnitElement);
     expect(libraryElement.parts,
         unorderedEquals([partUnits[0].element, partUnits[1].element]));
@@ skipping 20 matching lines @@
     expect(
         (libraryUnit.directives[1] as PartDirective).element, same(firstPart));
 
     expect(secondPart.uri, 'part2.dart');
     expect(secondPart.uriOffset, 37);
     expect(secondPart.uriEnd, 49);
     expect(
         (libraryUnit.directives[2] as PartDirective).element, same(secondPart));
   }
 
-  test_perform_classElements() {
-    _performBuildTask({
-      '/lib.dart': '''
-library lib;
-part 'part1.dart';
-part 'part2.dart';
-class A {}
-''',
-      '/part1.dart': '''
-part of lib;
-class B {}
-''',
-      '/part2.dart': '''
-part of lib;
-class C {}
-'''
-    });
-    List<ClassElement> classElements = outputs[CLASS_ELEMENTS];
-    List<String> classNames = classElements.map((c) => c.displayName).toList();
-    expect(classNames, unorderedEquals(['A', 'B', 'C']));
-  }
-
   test_perform_error_missingLibraryDirectiveWithPart_hasCommon() {
     _performBuildTask({
       '/lib.dart': '''
 part 'partA.dart';
 part 'partB.dart';
 ''',
       '/partA.dart': '''
 part of my_lib;
         ''',
       '/partB.dart': '''
@@ skipping 1173 matching lines @@
   }
 }
 
 @reflectiveTest
 class LibraryUnitErrorsTaskTest extends _AbstractDartTaskTest {
   test_buildInputs() {
     Map<String, TaskInput> inputs = LibraryUnitErrorsTask
         .buildInputs(new LibrarySpecificUnit(emptySource, emptySource));
     expect(inputs, isNotNull);
     expect(inputs.keys, unorderedEquals([
-      LibraryUnitErrorsTask.CONSTRUCTORS_ERRORS_INPUT,
       LibraryUnitErrorsTask.HINTS_INPUT,
       LibraryUnitErrorsTask.RESOLVE_REFERENCES_ERRORS_INPUT,
       LibraryUnitErrorsTask.RESOLVE_TYPE_NAMES_ERRORS_INPUT,
       LibraryUnitErrorsTask.VARIABLE_REFERENCE_ERRORS_INPUT,
       LibraryUnitErrorsTask.VERIFY_ERRORS_INPUT
     ]));
   }
 
   test_constructor() {
     LibraryUnitErrorsTask task =
@@ skipping 670 matching lines @@
   /**
    * Fill [errorListener] with [result] errors in the current [task].
    */
   void _fillErrorListener(ResultDescriptor<List<AnalysisError>> result) {
     List<AnalysisError> errors = task.outputs[result];
     expect(errors, isNotNull, reason: result.name);
     errorListener = new GatheringErrorListener();
     errorListener.addAll(errors);
   }
 }