ResolveLibraryTypeNamesTask to force type name resolution in parts.

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';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart'
     hide AnalysisTask, GetContentTask, ParseDartTask, ScanDartTask;
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/source.dart';
-import 'package:analyzer/src/generated/testing/ast_factory.dart';
-import 'package:analyzer/src/generated/testing/element_factory.dart';
 import 'package:analyzer/src/task/dart.dart';
 import 'package:analyzer/src/task/driver.dart';
 import 'package:analyzer/src/task/general.dart';
 import 'package:analyzer/src/task/manager.dart';
 import 'package:analyzer/task/dart.dart';
 import 'package:analyzer/task/general.dart';
 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(BuildCompilationUnitElementTaskTest);
   runReflectiveTests(BuildDirectiveElementsTaskTest);
   runReflectiveTests(BuildEnumMemberElementsTaskTest);
   runReflectiveTests(BuildExportSourceClosureTaskTest);
   runReflectiveTests(BuildExportNamespaceTaskTest);
   runReflectiveTests(BuildFunctionTypeAliasesTaskTest);
   runReflectiveTests(BuildLibraryElementTaskTest);
   runReflectiveTests(BuildPublicNamespaceTaskTest);
   runReflectiveTests(BuildTypeProviderTaskTest);
   runReflectiveTests(ParseDartTaskTest);
-  runReflectiveTests(ResolveTypeNamesTaskTest);
+  runReflectiveTests(ResolveUnitTypeNamesTaskTest);
+  runReflectiveTests(ResolveLibraryTypeNamesTaskTest);
   runReflectiveTests(ScanDartTaskTest);
 }
 
 @reflectiveTest
 class BuildCompilationUnitElementTaskTest extends _AbstractDartTaskTest {
   test_buildInputs() {
     LibraryUnitTarget target = new LibraryUnitTarget(emptySource, emptySource);
     Map<String, TaskInput> inputs =
         BuildCompilationUnitElementTask.buildInputs(target);
     expect(inputs, isNotNull);
@@ skipping 43 matching lines @@
   void _performBuildTask(String content) {
     Source source = _newSource('/test.dart', content);
     AnalysisTarget target = new LibraryUnitTarget(source, source);
     _computeResult(target, RESOLVED_UNIT1);
     expect(task, new isInstanceOf<BuildCompilationUnitElementTask>());
   }
 }
 
 @reflectiveTest
 class BuildDirectiveElementsTaskTest extends _AbstractDartTaskTest {
-  test_buildInputs() {
-    ExtendedAnalysisContext context = new _MockContext();
-    // prepare sources
-    File fileA = resourceProvider.newFile('/libA.dart', '');
-    File fileB = resourceProvider.newFile('/libB.dart', '');
-    File fileC = resourceProvider.newFile('/libC.dart', '');
-    Source sourceA = fileA.createSource();
-    Source sourceB = fileB.createSource();
-    Source sourceC = fileC.createSource();
-    // configure "sourceA"
-    CompilationUnit unitA = AstFactory.compilationUnit();
-    context.getCacheEntry(sourceA).setValue(
-        IMPORTED_LIBRARIES, <Source>[sourceB]);
-    context.getCacheEntry(sourceA).setValue(
-        EXPORTED_LIBRARIES, <Source>[sourceC]);
-    context.getCacheEntry(sourceA).setValue(RESOLVED_UNIT2, unitA);
-    // configure "sourceB"
-    LibraryElement libraryElementB = ElementFactory.library(context, 'libB');
-    context.getCacheEntry(sourceB).setValue(LIBRARY_ELEMENT1, libraryElementB);
-    context.getCacheEntry(sourceB).setValue(SOURCE_KIND, SourceKind.LIBRARY);
-    // configure "sourceC"
-    LibraryElement libraryElementC = ElementFactory.library(context, 'libC');
-    context.getCacheEntry(sourceC).setValue(LIBRARY_ELEMENT1, libraryElementC);
-    context.getCacheEntry(sourceC).setValue(SOURCE_KIND, SourceKind.LIBRARY);
-    // request inputs
-    WorkItem workItem =
-        new WorkItem(context, sourceA, BuildDirectiveElementsTask.DESCRIPTOR);
-    workItem.gatherInputs(null);
-    Map<String, dynamic> inputs = workItem.inputs;
-    expect(inputs, hasLength(5));
-    expect(inputs[BuildDirectiveElementsTask.RESOLVED_UNIT2_INPUT_NAME], unitA);
-    expect(
-        inputs[BuildDirectiveElementsTask.IMPORTS_LIBRARY_ELEMENT_INPUT_NAME],
-        containsPair(sourceB, libraryElementB));
-    expect(
-        inputs[BuildDirectiveElementsTask.EXPORTS_LIBRARY_ELEMENT_INPUT_NAME],
-        containsPair(sourceC, libraryElementC));
-    expect(inputs[BuildDirectiveElementsTask.IMPORTS_SOURCE_KIND_INPUT_NAME],
-        containsPair(sourceB, SourceKind.LIBRARY));
-    expect(inputs[BuildDirectiveElementsTask.EXPORTS_SOURCE_KIND_INPUT_NAME],
-        containsPair(sourceC, SourceKind.LIBRARY));
-  }
-
   test_constructor() {
     BuildDirectiveElementsTask task =
         new BuildDirectiveElementsTask(context, emptySource);
     expect(task, isNotNull);
     expect(task.context, context);
     expect(task.target, emptySource);
   }
 
   test_createTask() {
     BuildDirectiveElementsTask task =
@@ skipping 25 matching lines @@
 library libB;
 ''',
       '/libC.dart': '''
 library libC;
 '''
     });
     Source sourceA = sources[0];
     Source sourceB = sources[1];
     Source sourceC = sources[2];
     // perform task
-    _computeResult(sourceA, RESOLVED_UNIT3);
+    _computeResult(sourceA, LIBRARY_ELEMENT2);
     expect(task, new isInstanceOf<BuildDirectiveElementsTask>());
     // prepare outputs
-    CompilationUnit libraryUnitA = outputs[RESOLVED_UNIT3];
-    LibraryElement libraryElementA = libraryUnitA.element.library;
+    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);
     {
       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 21 matching lines @@
       '/libA.dart': '''
 library libA;
 import 'libB.dart' show A, B hide C, D;
 ''',
       '/libB.dart': '''
 library libB;
 '''
     });
     Source sourceA = sources[0];
     // perform task
-    _computeResult(sourceA, RESOLVED_UNIT3);
+    _computeResult(sourceA, LIBRARY_ELEMENT2);
     expect(task, new isInstanceOf<BuildDirectiveElementsTask>());
     // prepare outputs
-    CompilationUnit libraryUnitA = outputs[RESOLVED_UNIT3];
+    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 11 matching lines @@
       '/libA.dart': '''
 library libA;
 export 'part.dart';
 ''',
       '/part.dart': '''
 part of notLib;
 '''
     });
     Source sourceA = sources[0];
     // perform task
-    _computeResult(sourceA, RESOLVED_UNIT3);
+    _computeResult(sourceA, LIBRARY_ELEMENT2);
     expect(task, new isInstanceOf<BuildDirectiveElementsTask>());
     // validate errors
     _assertErrorsWithCodes([CompileTimeErrorCode.EXPORT_OF_NON_LIBRARY]);
   }
 
   test_perform_error_importOfNonLibrary() {
     List<Source> sources = _newSources({
       '/libA.dart': '''
 library libA;
 import 'part.dart';
 ''',
       '/part.dart': '''
 part of notLib;
 '''
     });
     Source sourceA = sources[0];
     // perform task
-    _computeResult(sourceA, RESOLVED_UNIT3);
+    _computeResult(sourceA, LIBRARY_ELEMENT2);
     expect(task, new isInstanceOf<BuildDirectiveElementsTask>());
     // validate errors
     _assertErrorsWithCodes([CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY]);
   }
 
   test_perform_hasExtUri() {
     List<Source> sources = _newSources({
       '/lib.dart': '''
 import 'dart-ext:doesNotExist.dart';
 '''
     });
     Source source = sources[0];
     // perform task
-    _computeResult(source, RESOLVED_UNIT3);
+    _computeResult(source, LIBRARY_ELEMENT2);
     expect(task, new isInstanceOf<BuildDirectiveElementsTask>());
     // prepare outputs
-    CompilationUnit libraryUnit = outputs[RESOLVED_UNIT3];
-    LibraryElement libraryElement = libraryUnit.element.library;
+    LibraryElement libraryElement = outputs[LIBRARY_ELEMENT2];
     expect(libraryElement.hasExtUri, isTrue);
   }
 
   test_perform_importPrefix() {
     List<Source> sources = _newSources({
       '/libA.dart': '''
 library libA;
 import 'libB.dart' as pref;
 import 'libC.dart' as pref;
 ''',
       '/libB.dart': '''
 library libB;
 ''',
       '/libC.dart': '''
 library libC;
 '''
     });
     Source sourceA = sources[0];
     Source sourceB = sources[1];
     // perform task
-    _computeResult(sourceA, RESOLVED_UNIT3);
+    _computeResult(sourceA, LIBRARY_ELEMENT2);
     expect(task, new isInstanceOf<BuildDirectiveElementsTask>());
     // prepare outputs
-    CompilationUnit libraryUnitA = outputs[RESOLVED_UNIT3];
+    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 24 matching lines @@
 }
 
 @reflectiveTest
 class BuildEnumMemberElementsTaskTest extends _AbstractDartTaskTest {
   test_perform() {
     Source source = _newSource('/test.dart', '''
 enum MyEnum {
   A, B
 }
 ''');
-    _computeResult(source, RESOLVED_UNIT4);
+    _computeResult(new LibraryUnitTarget(source, source), RESOLVED_UNIT2);
     expect(task, new isInstanceOf<BuildEnumMemberElementsTask>());
-    CompilationUnit unit = outputs[RESOLVED_UNIT4];
+    CompilationUnit unit = outputs[RESOLVED_UNIT2];
     // validate Element
     ClassElement enumElement = unit.element.getEnum('MyEnum');
     List<FieldElement> fields = enumElement.fields;
     expect(fields, hasLength(4));
     {
       FieldElementImpl index = fields[0];
       expect(index, isNotNull);
       expect(index.name, 'index');
       expect(index.isStatic, isFalse);
       expect(index.evaluationResult, isNull);
@@ skipping 33 matching lines @@
   static void _assertGetter(FieldElement field) {
     PropertyAccessorElement getter = field.getter;
     expect(getter, isNotNull);
     expect(getter.variable, same(field));
     expect(getter.type, isNotNull);
   }
 }
 
 @reflectiveTest
 class BuildExportNamespaceTaskTest extends _AbstractDartTaskTest {
-  test_perform_entyrPoint() {
+  test_perform_entryPoint() {
     Source sourceA = _newSource('/a.dart', '''
 library lib_a;
 export 'b.dart';
 ''');
     Source sourceB = _newSource('/b.dart', '''
 library lib_b;
 main() {}
 ''');
     _computeResult(sourceA, LIBRARY_ELEMENT4);
     expect(task, new isInstanceOf<BuildExportNamespaceTask>());
@@ skipping 128 matching lines @@
 }
 
 @reflectiveTest
 class BuildFunctionTypeAliasesTaskTest extends _AbstractDartTaskTest {
   test_perform() {
     Source source = _newSource('/test.dart', '''
 typedef int F(G g);
 typedef String G(int p);
 ''');
     LibraryUnitTarget target = new LibraryUnitTarget(source, source);
-    _computeResult(target, RESOLVED_UNIT5);
+    _computeResult(target, RESOLVED_UNIT3);
     expect(task, new isInstanceOf<BuildFunctionTypeAliasesTask>());
     // validate
-    CompilationUnit unit = outputs[RESOLVED_UNIT5];
+    CompilationUnit unit = outputs[RESOLVED_UNIT3];
     FunctionTypeAlias nodeF = unit.declarations[0];
     FunctionTypeAlias nodeG = unit.declarations[1];
     {
       FormalParameter parameter = nodeF.parameters.parameters[0];
       DartType parameterType = parameter.element.type;
       Element returnTypeElement = nodeF.returnType.type.element;
       expect(returnTypeElement.displayName, 'int');
       expect(parameterType.element, nodeG.element);
     }
     {
@@ skipping 61 matching lines @@
 part 'part1.dart';
 part 'part2.dart';
 ''',
       '/part1.dart': '''
 part of lib;
 ''',
       '/part2.dart': '''
 part of lib;
 '''
     });
-    expect(outputs, hasLength(5));
+    expect(outputs, hasLength(4));
     // simple outputs
     expect(outputs[BUILD_LIBRARY_ERRORS], isEmpty);
-    expect(outputs[RESOLVED_UNIT2], same(libraryUnit));
     expect(outputs[IS_LAUNCHABLE], isFalse);
     expect(outputs[HAS_HTML_IMPORT], 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]));
     // LibraryElement references
@@ skipping 156 matching lines @@
     expect(unitElement2.topLevelVariables, [variable]);
   }
 
   void _assertErrorsWithCodes(List<ErrorCode> expectedErrorCodes) {
     _fillErrorListener(BUILD_LIBRARY_ERRORS);
     errorListener.assertErrorsWithCodes(expectedErrorCodes);
   }
 
   void _performBuildTask(Map<String, String> sourceMap) {
     List<Source> sources = _newSources(sourceMap);
-    _computeResult(sources.first, RESOLVED_UNIT2);
+    Source libSource = sources.first;
+    _computeResult(libSource, LIBRARY_ELEMENT1);
     expect(task, new isInstanceOf<BuildLibraryElementTask>());
-    libraryUnit = outputs[RESOLVED_UNIT2];
+    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_RESOLVED_UNIT1_INPUT_NAME];
+        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 153 matching lines @@
 
   static void _assertHasCore(List<Source> sources, int lenght) {
     expect(sources, hasLength(lenght));
     expect(sources, contains(predicate((Source s) {
       return s.fullName.endsWith('core.dart');
     })));
   }
 }
 
 @reflectiveTest
-class ResolveTypeNamesTaskTest extends _AbstractDartTaskTest {
+class ResolveLibraryTypeNamesTaskTest extends _AbstractDartTaskTest {
+  test_perform() {
+    Source sourceLib = _newSource('/my_lib.dart', '''
+library my_lib;
+part 'my_part.dart';
+class A {}
+class B extends A {}
+''');
+    _newSource('/my_part.dart', '''
+part of my_lib;
+class C extends A {}
+''');
+    _computeResult(sourceLib, LIBRARY_ELEMENT5);
+    expect(task, new isInstanceOf<ResolveLibraryTypeNamesTask>());
+    // validate
+    LibraryElement library = outputs[LIBRARY_ELEMENT5];
+    {
+      ClassElement classB = library.getType('B');
+      expect(classB.supertype.displayName, 'A');
+    }
+    {
+      ClassElement classC = library.getType('C');
+      expect(classC.supertype.displayName, 'A');
+    }
+  }
+}
+
+@reflectiveTest
+class ResolveUnitTypeNamesTaskTest extends _AbstractDartTaskTest {
   test_perform() {
     Source source = _newSource('/test.dart', '''
 class A {}
 class B extends A {}
 int f(String p) => p.length;
 ''');
     LibraryUnitTarget target = new LibraryUnitTarget(source, source);
-    _computeResult(target, RESOLVED_UNIT6);
-    expect(task, new isInstanceOf<ResolveTypeNamesTask>());
+    _computeResult(target, RESOLVED_UNIT4);
+    expect(task, new isInstanceOf<ResolveUnitTypeNamesTask>());
     // validate
-    CompilationUnit unit = outputs[RESOLVED_UNIT6];
+    CompilationUnit unit = outputs[RESOLVED_UNIT4];
     {
       ClassDeclaration nodeA = unit.declarations[0];
       ClassDeclaration nodeB = unit.declarations[1];
       DartType extendsType = nodeB.extendsClause.superclass.type;
       expect(extendsType, nodeA.element.type);
     }
     {
       FunctionDeclaration functionNode = unit.declarations[2];
       DartType returnType = functionNode.returnType.type;
       List<FormalParameter> parameters =
           functionNode.functionExpression.parameters.parameters;
       expect(returnType.displayName, 'int');
       expect(parameters[0].element.type.displayName, 'String');
     }
   }
 
   test_perform_errors() {
     Source source = _newSource('/test.dart', '''
 NoSuchClass f() => null;
 ''');
     LibraryUnitTarget target = new LibraryUnitTarget(source, source);
     _computeResult(target, RESOLVE_TYPE_NAMES_ERRORS);
-    expect(task, new isInstanceOf<ResolveTypeNamesTask>());
+    expect(task, new isInstanceOf<ResolveUnitTypeNamesTask>());
     // validate
     _fillErrorListener(RESOLVE_TYPE_NAMES_ERRORS);
     errorListener
         .assertErrorsWithCodes(<ErrorCode>[StaticWarningCode.UNDEFINED_CLASS]);
   }
 }
 
 @reflectiveTest
 class ScanDartTaskTest extends _AbstractDartTaskTest {
   test_buildInputs() {
@@ skipping 81 matching lines @@
     taskManager.addTaskDescriptor(ParseDartTask.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(ResolveTypeNamesTask.DESCRIPTOR);
+    taskManager.addTaskDescriptor(ResolveUnitTypeNamesTask.DESCRIPTOR);
+    taskManager.addTaskDescriptor(ResolveLibraryTypeNamesTask.DESCRIPTOR);
     // prepare AnalysisDriver
     analysisDriver = new AnalysisDriver(taskManager, context);
   }
 
   void _computeResult(AnalysisTarget target, ResultDescriptor result) {
     task = analysisDriver.computeResult(target, result);
     expect(task.caughtException, isNull);
     outputs = task.outputs;
   }
 
@@ skipping 39 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);
   }
 }