Task: BuildClassConstructorsTask.

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/file_system/file_system.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 13 matching lines @@
 import 'package:analyzer/task/model.dart';
 import 'package:typed_mock/typed_mock.dart';
 import 'package:unittest/unittest.dart';
 
 import '../../generated/test_support.dart';
 import '../../reflective_tests.dart';
 import '../mock_sdk.dart';
 
 main() {
   groupSep = ' | ';
+  runReflectiveTests(BuildClassConstructorsTaskTest);
   runReflectiveTests(BuildCompilationUnitElementTaskTest);
   runReflectiveTests(BuildDirectiveElementsTaskTest);
   runReflectiveTests(BuildEnumMemberElementsTaskTest);
   runReflectiveTests(BuildExportSourceClosureTaskTest);
   runReflectiveTests(BuildExportNamespaceTaskTest);
   runReflectiveTests(BuildFunctionTypeAliasesTaskTest);
   runReflectiveTests(BuildLibraryElementTaskTest);
   runReflectiveTests(BuildPublicNamespaceTaskTest);
   runReflectiveTests(BuildTypeProviderTaskTest);
   runReflectiveTests(ParseDartTaskTest);
   runReflectiveTests(ResolveUnitTypeNamesTaskTest);
   runReflectiveTests(ResolveLibraryTypeNamesTaskTest);
   runReflectiveTests(ScanDartTaskTest);
 }
 
 @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 {
   test_buildInputs() {
     LibraryUnitTarget target = new LibraryUnitTarget(emptySource, emptySource);
     Map<String, TaskInput> inputs =
         BuildCompilationUnitElementTask.buildInputs(target);
     expect(inputs, isNotNull);
     expect(inputs.keys, unorderedEquals(
         [BuildCompilationUnitElementTask.PARSED_UNIT_INPUT_NAME]));
   }
 
@@ skipping 96 matching lines @@
     // perform task
     _computeResult(sourceA, LIBRARY_ELEMENT2);
     expect(task, new isInstanceOf<BuildDirectiveElementsTask>());
     // prepare outputs
     LibraryElement libraryElementA = outputs[LIBRARY_ELEMENT2];
     LibraryElement libraryElementB = _getImportLibraryInput(sourceB);
     LibraryElement libraryElementC = _getExportLibraryInput(sourceC);
     // no errors
     _assertErrorsWithCodes([]);
     // validate directives
-    CompilationUnit libraryUnitA = context.getCacheEntry(new LibraryUnitTarget(sourceA, sourceA)).getValue(RESOLVED_UNIT1);
+    CompilationUnit libraryUnitA = context
+        .getCacheEntry(new LibraryUnitTarget(sourceA, sourceA))
+        .getValue(RESOLVED_UNIT1);
     {
       ImportDirective importNode = libraryUnitA.directives[1];
       ImportElement importElement = importNode.element;
       expect(importElement, isNotNull);
       expect(importElement.importedLibrary, libraryElementB);
       expect(importElement.prefix, isNull);
       expect(importElement.nameOffset, 14);
       expect(importElement.uriOffset, 21);
       expect(importElement.uriEnd, 32);
     }
@@ skipping 24 matching lines @@
 ''',
       '/libB.dart': '''
 library libB;
 '''
     });
     Source sourceA = sources[0];
     // perform task
     _computeResult(sourceA, LIBRARY_ELEMENT2);
     expect(task, new isInstanceOf<BuildDirectiveElementsTask>());
     // prepare outputs
-    CompilationUnit libraryUnitA = context.getCacheEntry(new LibraryUnitTarget(sourceA, sourceA)).getValue(RESOLVED_UNIT1);
+    CompilationUnit libraryUnitA = context
+        .getCacheEntry(new LibraryUnitTarget(sourceA, sourceA))
+        .getValue(RESOLVED_UNIT1);
     // no errors
     _assertErrorsWithCodes([]);
     // validate directives
     ImportDirective importNode = libraryUnitA.directives[1];
     ImportElement importElement = importNode.element;
     List<NamespaceCombinator> combinators = importElement.combinators;
     expect(combinators, hasLength(2));
     {
       ShowElementCombinator combinator = combinators[0];
       expect(combinator.offset, 33);
@@ skipping 70 matching lines @@
       '/libC.dart': '''
 library libC;
 '''
     });
     Source sourceA = sources[0];
     Source sourceB = sources[1];
     // perform task
     _computeResult(sourceA, LIBRARY_ELEMENT2);
     expect(task, new isInstanceOf<BuildDirectiveElementsTask>());
     // prepare outputs
-    CompilationUnit libraryUnitA = context.getCacheEntry(new LibraryUnitTarget(sourceA, sourceA)).getValue(RESOLVED_UNIT1);
+    CompilationUnit libraryUnitA = context
+        .getCacheEntry(new LibraryUnitTarget(sourceA, sourceA))
+        .getValue(RESOLVED_UNIT1);
     // validate directives
     {
       ImportDirective importNodeB = libraryUnitA.directives[1];
       SimpleIdentifier prefixNodeB = importNodeB.prefix;
       ImportElement importElementB = importNodeB.element;
       PrefixElement prefixElement = importElementB.prefix;
       expect(importElementB, isNotNull);
       expect(importElementB.importedLibrary, _getImportLibraryInput(sourceB));
       expect(prefixElement, isNotNull);
       expect(importElementB.prefixOffset, prefixElement.nameOffset);
@@ skipping 496 matching lines @@
   void _assertErrorsWithCodes(List<ErrorCode> expectedErrorCodes) {
     _fillErrorListener(BUILD_LIBRARY_ERRORS);
     errorListener.assertErrorsWithCodes(expectedErrorCodes);
   }
 
   void _performBuildTask(Map<String, String> sourceMap) {
     List<Source> sources = _newSources(sourceMap);
     Source libSource = sources.first;
     _computeResult(libSource, LIBRARY_ELEMENT1);
     expect(task, new isInstanceOf<BuildLibraryElementTask>());
-    libraryUnit = context.getCacheEntry(new LibraryUnitTarget(libSource, libSource)).getValue(RESOLVED_UNIT1);
+    libraryUnit = context
+        .getCacheEntry(new LibraryUnitTarget(libSource, libSource))
+        .getValue(RESOLVED_UNIT1);
     libraryUnitElement = libraryUnit.element;
     librarySource = libraryUnitElement.source;
     libraryElement = outputs[LIBRARY_ELEMENT1];
-    partUnits =
-        task.inputs[BuildLibraryElementTask.PARTS_UNIT_INPUT];
+    partUnits = task.inputs[BuildLibraryElementTask.PARTS_UNIT_INPUT];
   }
 }
 
 @reflectiveTest
 class BuildPublicNamespaceTaskTest extends _AbstractDartTaskTest {
   test_buildInputs() {
     Map<String, TaskInput> inputs =
         BuildPublicNamespaceTask.buildInputs(emptySource);
     expect(inputs, isNotNull);
     expect(
@@ skipping 311 matching lines @@
     emptySource = _newSource('/test.dart');
     // prepare AnalysisContext
     context.sourceFactory = new SourceFactory(<UriResolver>[
       new DartUriResolver(sdk),
       new ResourceUriResolver(resourceProvider)
     ]);
     // prepare TaskManager
     taskManager.addTaskDescriptor(GetContentTask.DESCRIPTOR);
     taskManager.addTaskDescriptor(ScanDartTask.DESCRIPTOR);
     taskManager.addTaskDescriptor(ParseDartTask.DESCRIPTOR);
+    taskManager.addTaskDescriptor(BuildClassConstructorsTask.DESCRIPTOR);
     taskManager.addTaskDescriptor(BuildCompilationUnitElementTask.DESCRIPTOR);
     taskManager.addTaskDescriptor(BuildLibraryElementTask.DESCRIPTOR);
     taskManager.addTaskDescriptor(BuildPublicNamespaceTask.DESCRIPTOR);
     taskManager.addTaskDescriptor(BuildDirectiveElementsTask.DESCRIPTOR);
     taskManager.addTaskDescriptor(BuildExportSourceClosureTask.DESCRIPTOR);
     taskManager.addTaskDescriptor(BuildExportNamespaceTask.DESCRIPTOR);
     taskManager.addTaskDescriptor(BuildTypeProviderTask.DESCRIPTOR);
     taskManager.addTaskDescriptor(BuildEnumMemberElementsTask.DESCRIPTOR);
     taskManager.addTaskDescriptor(BuildFunctionTypeAliasesTask.DESCRIPTOR);
     taskManager.addTaskDescriptor(ResolveUnitTypeNamesTask.DESCRIPTOR);
@@ skipping 50 matching lines @@
     return entryMap.putIfAbsent(target, () => new CacheEntry());
   }
 
   TimestampedData<String> getContents(Source source) => source.contents;
 
   noSuchMethod(Invocation invocation) {
     print('noSuchMethod: ${invocation.memberName}');
     return super.noSuchMethod(invocation);
   }
 }