Extract unresolved AST parsing (PARSED_UNIT1) from full parsing, which includes UriBasedDirective(s…

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 analyzer.test.src.task.dart_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 49 matching lines @@
   runReflectiveTests(InferInstanceMembersInUnitTaskTest);
   runReflectiveTests(InferStaticVariableTypesInUnitTaskTest);
   runReflectiveTests(InferStaticVariableTypeTaskTest);
   runReflectiveTests(LibraryErrorsReadyTaskTest);
   runReflectiveTests(LibraryUnitErrorsTaskTest);
   runReflectiveTests(ParseDartTaskTest);
   runReflectiveTests(PartiallyResolveUnitReferencesTaskTest);
   runReflectiveTests(PropagateVariableTypesInUnitTaskTest);
   runReflectiveTests(PropagateVariableTypeTaskTest);
   runReflectiveTests(ReferencedNamesBuilderTest);
+  runReflectiveTests(ResolveDirectivesTaskTest);
   runReflectiveTests(ResolveDirectiveElementsTaskTest);
   runReflectiveTests(ResolveInstanceFieldsInUnitTaskTest);
   runReflectiveTests(ResolveLibraryTaskTest);
   runReflectiveTests(ResolveLibraryTypeNamesTaskTest);
   runReflectiveTests(ResolveTopLevelUnitTypeBoundsTaskTest);
   runReflectiveTests(ResolveUnitTaskTest);
   runReflectiveTests(ResolveUnitTypeNamesTaskTest);
   runReflectiveTests(ResolveVariableReferencesTaskTest);
   runReflectiveTests(ScanDartTaskTest);
   runReflectiveTests(StrongModeInferenceTest);
@@ skipping 48 matching lines @@
     new isInstanceOf<LibraryUnitErrorsTask>();
 isInstanceOf isParseDartTask = new isInstanceOf<ParseDartTask>();
 isInstanceOf isPartiallyResolveUnitReferencesTask =
     new isInstanceOf<PartiallyResolveUnitReferencesTask>();
 isInstanceOf isPropagateVariableTypesInUnitTask =
     new isInstanceOf<PropagateVariableTypesInUnitTask>();
 isInstanceOf isPropagateVariableTypeTask =
     new isInstanceOf<PropagateVariableTypeTask>();
 isInstanceOf isResolveDirectiveElementsTask =
     new isInstanceOf<ResolveDirectiveElementsTask>();
+isInstanceOf isResolveDirectivesTask =
+    new isInstanceOf<ResolveDirectivesTask>();
 isInstanceOf isResolveLibraryReferencesTask =
     new isInstanceOf<ResolveLibraryReferencesTask>();
 isInstanceOf isResolveLibraryTask = new isInstanceOf<ResolveLibraryTask>();
 isInstanceOf isResolveLibraryTypeNamesTask =
     new isInstanceOf<ResolveLibraryTypeNamesTask>();
 isInstanceOf isResolveTopLevelUnitTypeBoundsTask =
     new isInstanceOf<ResolveTopLevelUnitTypeBoundsTask>();
 isInstanceOf isResolveUnitTask = new isInstanceOf<ResolveUnitTask>();
 isInstanceOf isResolveUnitTypeNamesTask =
     new isInstanceOf<ResolveUnitTypeNamesTask>();
@@ skipping 3062 matching lines @@
     List<AnalysisError> errors = getLibraryUnitErrors(outputs);
     expect(errors, hasLength(0));
   }
 }
 
 @reflectiveTest
 class ParseDartTaskTest extends _AbstractDartTaskTest {
   Source source;
 
   test_perform() {
-    _performParseTask(r'''
+    _performTask(r'''
 part of lib;
 class B {}''');
-    expect(outputs, hasLength(11));
-    expect(outputs[EXPLICITLY_IMPORTED_LIBRARIES], hasLength(0));
-    expect(outputs[EXPORTED_LIBRARIES], hasLength(0));
-    _assertHasCore(outputs[IMPORTED_LIBRARIES], 1);
-    expect(outputs[INCLUDED_PARTS], hasLength(0));
-    expect(outputs[LIBRARY_SPECIFIC_UNITS], hasLength(1));
+    expect(outputs, hasLength(4));
     expect(outputs[PARSE_ERRORS], hasLength(0));
-    expect(outputs[PARSED_UNIT], isNotNull);
+    expect(outputs[PARSED_UNIT1], isNotNull);
     expect(outputs[REFERENCED_NAMES], isNotNull);
-    expect(outputs[REFERENCED_SOURCES], hasLength(2));
     expect(outputs[SOURCE_KIND], SourceKind.PART);
-    expect(outputs[UNITS], hasLength(1));
   }
 
   test_perform_computeSourceKind_noDirectives_hasContainingLibrary() {
     // Parse "lib.dart" to let the context know that "test.dart" is included.
     computeResult(
         newSource(
             '/lib.dart',
             r'''
 library lib;
 part 'test.dart';
 '''),
-        PARSED_UNIT);
+        PARSED_UNIT1);
     // If there are no the "part of" directive, then it is not a part.
-    _performParseTask('');
+    _performTask('');
     expect(outputs[SOURCE_KIND], SourceKind.LIBRARY);
   }
 
   test_perform_computeSourceKind_noDirectives_noContainingLibrary() {
-    _performParseTask('');
+    _performTask('');
     expect(outputs[SOURCE_KIND], SourceKind.LIBRARY);
   }
 
   test_perform_doesNotExist() {
-    _performParseTask(null);
-    expect(outputs, hasLength(11));
-    expect(outputs[EXPLICITLY_IMPORTED_LIBRARIES], hasLength(0));
-    expect(outputs[EXPORTED_LIBRARIES], hasLength(0));
-    _assertHasCore(outputs[IMPORTED_LIBRARIES], 1);
-    expect(outputs[INCLUDED_PARTS], hasLength(0));
-    expect(outputs[LIBRARY_SPECIFIC_UNITS], hasLength(1));
+    _performTask(null);
+    expect(outputs, hasLength(4));
     expect(outputs[PARSE_ERRORS], hasLength(0));
-    expect(outputs[PARSED_UNIT], isNotNull);
+    expect(outputs[PARSED_UNIT1], isNotNull);
     expect(outputs[REFERENCED_NAMES], isNotNull);
-    expect(outputs[REFERENCED_SOURCES], hasLength(2));
     expect(outputs[SOURCE_KIND], SourceKind.LIBRARY);
-    expect(outputs[UNITS], hasLength(1));
   }
 
   test_perform_enableAsync_false() {
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.enableAsync = false;
     prepareAnalysisContext(options);
-    _performParseTask(r'''
+    _performTask(r'''
 import 'dart:async';
 class B {void foo() async {}}''');
-    expect(outputs, hasLength(11));
-    expect(outputs[EXPLICITLY_IMPORTED_LIBRARIES], hasLength(1));
-    expect(outputs[EXPORTED_LIBRARIES], hasLength(0));
-    _assertHasCore(outputs[IMPORTED_LIBRARIES], 2);
-    expect(outputs[INCLUDED_PARTS], hasLength(0));
-    expect(outputs[LIBRARY_SPECIFIC_UNITS], hasLength(1));
+    expect(outputs, hasLength(4));
     expect(outputs[PARSE_ERRORS], hasLength(1));
-    expect(outputs[PARSED_UNIT], isNotNull);
+    expect(outputs[PARSED_UNIT1], isNotNull);
     expect(outputs[REFERENCED_NAMES], isNotNull);
-    expect(outputs[REFERENCED_SOURCES], hasLength(3));
     expect(outputs[SOURCE_KIND], SourceKind.LIBRARY);
-    expect(outputs[UNITS], hasLength(1));
   }
 
   test_perform_enableAsync_true() {
-    _performParseTask(r'''
+    _performTask(r'''
 import 'dart:async';
 class B {void foo() async {}}''');
-    expect(outputs, hasLength(11));
-    expect(outputs[EXPLICITLY_IMPORTED_LIBRARIES], hasLength(1));
-    expect(outputs[EXPORTED_LIBRARIES], hasLength(0));
-    _assertHasCore(outputs[IMPORTED_LIBRARIES], 2);
-    expect(outputs[INCLUDED_PARTS], hasLength(0));
-    expect(outputs[LIBRARY_SPECIFIC_UNITS], hasLength(1));
+    expect(outputs, hasLength(4));
     expect(outputs[PARSE_ERRORS], hasLength(0));
-    expect(outputs[PARSED_UNIT], isNotNull);
+    expect(outputs[PARSED_UNIT1], isNotNull);
     expect(outputs[REFERENCED_NAMES], isNotNull);
-    expect(outputs[REFERENCED_SOURCES], hasLength(3));
     expect(outputs[SOURCE_KIND], SourceKind.LIBRARY);
-    expect(outputs[UNITS], hasLength(1));
   }
 
   test_perform_flushTokenStream() {
-    _performParseTask(r'''
+    _performTask(r'''
 class Test {}
 ''');
     expect(analysisCache.getState(source, TOKEN_STREAM), CacheState.FLUSHED);
   }
 
   test_perform_invalidDirectives() {
-    _performParseTask(r'''
+    _performTask(r'''
 library lib;
 import '/does/not/exist.dart';
 import '://invaliduri.dart';
 export '${a}lib3.dart';
 part 'part.dart';
 class A {}''');
-    expect(outputs, hasLength(11));
-    expect(outputs[EXPLICITLY_IMPORTED_LIBRARIES], hasLength(1));
-    expect(outputs[EXPORTED_LIBRARIES], hasLength(0));
-    _assertHasCore(outputs[IMPORTED_LIBRARIES], 2);
-    expect(outputs[INCLUDED_PARTS], hasLength(1));
-    expect(outputs[LIBRARY_SPECIFIC_UNITS], hasLength(2));
-    expect(outputs[PARSE_ERRORS], hasLength(2));
-    expect(outputs[PARSED_UNIT], isNotNull);
+    expect(outputs, hasLength(4));
+    expect(outputs[PARSE_ERRORS], hasLength(0));
+    expect(outputs[PARSED_UNIT1], isNotNull);
     expect(outputs[REFERENCED_NAMES], isNotNull);
-    expect(outputs[REFERENCED_SOURCES], hasLength(4));
     expect(outputs[SOURCE_KIND], SourceKind.LIBRARY);
-    expect(outputs[UNITS], hasLength(2));
   }
 
   test_perform_library() {
-    _performParseTask(r'''
+    _performTask(r'''
 library lib;
 import 'lib2.dart';
 export 'lib3.dart';
 part 'part.dart';
 class A {''');
-    expect(outputs, hasLength(11));
-    expect(outputs[EXPLICITLY_IMPORTED_LIBRARIES], hasLength(1));
-    expect(outputs[EXPORTED_LIBRARIES], hasLength(1));
-    _assertHasCore(outputs[IMPORTED_LIBRARIES], 2);
-    expect(outputs[INCLUDED_PARTS], hasLength(1));
-    expect(outputs[LIBRARY_SPECIFIC_UNITS], hasLength(2));
+    expect(outputs, hasLength(4));
     expect(outputs[PARSE_ERRORS], hasLength(1));
-    expect(outputs[PARSED_UNIT], isNotNull);
+    expect(outputs[PARSED_UNIT1], isNotNull);
     expect(outputs[REFERENCED_NAMES], isNotNull);
-    expect(outputs[REFERENCED_SOURCES], hasLength(5));
     expect(outputs[SOURCE_KIND], SourceKind.LIBRARY);
-    expect(outputs[UNITS], hasLength(2));
-  }
-
-  test_perform_library_selfReferenceAsPart() {
-    _performParseTask(r'''
-library lib;
-part 'test.dart';
-''');
-    expect(outputs[INCLUDED_PARTS], unorderedEquals(<Source>[source]));
   }
 
   test_perform_part() {
-    _performParseTask(r'''
+    _performTask(r'''
 part of lib;
 class B {}''');
-    expect(outputs, hasLength(11));
-    expect(outputs[EXPLICITLY_IMPORTED_LIBRARIES], hasLength(0));
-    expect(outputs[EXPORTED_LIBRARIES], hasLength(0));
-    _assertHasCore(outputs[IMPORTED_LIBRARIES], 1);
-    expect(outputs[INCLUDED_PARTS], hasLength(0));
-    expect(outputs[LIBRARY_SPECIFIC_UNITS], hasLength(1));
+    expect(outputs, hasLength(4));
     expect(outputs[PARSE_ERRORS], hasLength(0));
-    expect(outputs[PARSED_UNIT], isNotNull);
+    expect(outputs[PARSED_UNIT1], isNotNull);
     expect(outputs[REFERENCED_NAMES], isNotNull);
-    expect(outputs[REFERENCED_SOURCES], hasLength(2));
     expect(outputs[SOURCE_KIND], SourceKind.PART);
-    expect(outputs[UNITS], hasLength(1));
   }
 
-  void _performParseTask(String content) {
+  void _performTask(String content) {
     if (content == null) {
       source = resourceProvider.getFile('/test.dart').createSource();
     } else {
       source = newSource('/test.dart', content);
     }
-    computeResult(source, PARSED_UNIT, matcher: isParseDartTask);
+    computeResult(source, PARSED_UNIT1, matcher: isParseDartTask);
   }
 
-  static void _assertHasCore(dynamic sourceList, int lenght) {
+  static void _assertHasCore(dynamic sourceList, int length) {
     List<Source> sources = sourceList as List<Source>;
-    expect(sources, hasLength(lenght));
+    expect(sources, hasLength(length));
     expect(sources, contains(predicate((Source s) {
       return s.fullName.endsWith('core.dart');
     })));
   }
 }
 
 @reflectiveTest
 class PartiallyResolveUnitReferencesTaskTest extends _AbstractDartTaskTest {
   test_perform_propagable() {
     enableStrongMode();
@@ skipping 127 matching lines @@
     computeResult(target, RESOLVED_UNIT7,
         matcher: isPartiallyResolveUnitReferencesTask);
     CompilationUnit unit = outputs[RESOLVED_UNIT7];
     NodeList<CompilationUnitMember> declarations = unit.declarations;
 
     void expectReference(BlockFunctionBody body, bool isResolved) {
       ExpressionStatement statement = body.block.statements[0];
       SimpleIdentifier reference = statement.expression;
       expect(reference.staticElement, isResolved ? isNotNull : isNull);
     }
+
     //
     // The reference to 'A' in 'f1' should not be resolved.
     //
     FunctionDeclaration f1 = declarations[1];
     expectReference(f1.functionExpression.body, false);
     //
     // The references to 'A' in 'f2' should be resolved.
     //
     TopLevelVariableDeclaration f2 = declarations[2];
     FunctionExpression expression2 = f2.variables.variables[0].initializer;
@@ skipping 657 matching lines @@
     {
       ExportDirective exportNode = unitA.directives[2];
       ExportElement exportElement = exportNode.element;
       expect(exportElement, isNotNull);
       expect(exportElement.exportedLibrary, libraryElementC);
     }
   }
 }
 
 @reflectiveTest
+class ResolveDirectivesTaskTest extends _AbstractDartTaskTest {
+  Source source;
+
+  test_perform() {
+    _performTask(r'''
+part of lib;
+class B {}''');
+    expect(outputs, hasLength(9));
+    expect(outputs[EXPLICITLY_IMPORTED_LIBRARIES], hasLength(0));
+    expect(outputs[EXPORTED_LIBRARIES], hasLength(0));
+    _assertHasCore(outputs[IMPORTED_LIBRARIES], 1);
+    expect(outputs[INCLUDED_PARTS], hasLength(0));
+    expect(outputs[LIBRARY_SPECIFIC_UNITS], hasLength(1));
+    expect(outputs[PARSED_UNIT], isNotNull);
+    expect(outputs[REFERENCED_SOURCES], hasLength(2));
+    expect(outputs[RESOLVE_DIRECTIVES_ERRORS], hasLength(0));
+    expect(outputs[UNITS], hasLength(1));
+  }
+
+  test_perform_doesNotExist() {
+    _performTask(null);
+    expect(outputs, hasLength(9));
+    expect(outputs[EXPLICITLY_IMPORTED_LIBRARIES], hasLength(0));
+    expect(outputs[EXPORTED_LIBRARIES], hasLength(0));
+    _assertHasCore(outputs[IMPORTED_LIBRARIES], 1);
+    expect(outputs[INCLUDED_PARTS], hasLength(0));
+    expect(outputs[LIBRARY_SPECIFIC_UNITS], hasLength(1));
+    expect(outputs[PARSED_UNIT], isNotNull);
+    expect(outputs[REFERENCED_SOURCES], hasLength(2));
+    expect(outputs[RESOLVE_DIRECTIVES_ERRORS], hasLength(0));
+    expect(outputs[UNITS], hasLength(1));
+  }
+
+  test_perform_enableAsync_false() {
+    AnalysisOptionsImpl options = new AnalysisOptionsImpl();
+    options.enableAsync = false;
+    prepareAnalysisContext(options);
+    _performTask(r'''
+import 'dart:async';
+class B {void foo() async {}}''');
+    expect(outputs, hasLength(9));
+    expect(outputs[EXPLICITLY_IMPORTED_LIBRARIES], hasLength(1));
+    expect(outputs[EXPORTED_LIBRARIES], hasLength(0));
+    _assertHasCore(outputs[IMPORTED_LIBRARIES], 2);
+    expect(outputs[INCLUDED_PARTS], hasLength(0));
+    expect(outputs[LIBRARY_SPECIFIC_UNITS], hasLength(1));
+    expect(outputs[PARSED_UNIT], isNotNull);
+    expect(outputs[REFERENCED_SOURCES], hasLength(3));
+    expect(outputs[RESOLVE_DIRECTIVES_ERRORS], hasLength(0));
+    expect(outputs[UNITS], hasLength(1));
+  }
+
+  test_perform_enableAsync_true() {
+    _performTask(r'''
+import 'dart:async';
+class B {void foo() async {}}''');
+    expect(outputs, hasLength(9));
+    expect(outputs[EXPLICITLY_IMPORTED_LIBRARIES], hasLength(1));
+    expect(outputs[EXPORTED_LIBRARIES], hasLength(0));
+    _assertHasCore(outputs[IMPORTED_LIBRARIES], 2);
+    expect(outputs[INCLUDED_PARTS], hasLength(0));
+    expect(outputs[LIBRARY_SPECIFIC_UNITS], hasLength(1));
+    expect(outputs[PARSED_UNIT], isNotNull);
+    expect(outputs[REFERENCED_SOURCES], hasLength(3));
+    expect(outputs[RESOLVE_DIRECTIVES_ERRORS], hasLength(0));
+    expect(outputs[UNITS], hasLength(1));
+  }
+
+  test_perform_flushParsedUnit1() {
+    _performTask(r'''
+class Test {}
+''');
+    expect(analysisCache.getState(source, PARSED_UNIT1), CacheState.FLUSHED);
+  }
+
+  test_perform_invalidDirectives() {
+    _performTask(r'''
+library lib;
+import '/does/not/exist.dart';
+import '://invaliduri.dart';
+export '${a}lib3.dart';
+part 'part.dart';
+class A {}''');
+    expect(outputs, hasLength(9));
+    expect(outputs[EXPLICITLY_IMPORTED_LIBRARIES], hasLength(1));
+    expect(outputs[EXPORTED_LIBRARIES], hasLength(0));
+    _assertHasCore(outputs[IMPORTED_LIBRARIES], 2);
+    expect(outputs[INCLUDED_PARTS], hasLength(1));
+    expect(outputs[LIBRARY_SPECIFIC_UNITS], hasLength(2));
+    expect(outputs[PARSED_UNIT], isNotNull);
+    expect(outputs[REFERENCED_SOURCES], hasLength(4));
+    expect(outputs[RESOLVE_DIRECTIVES_ERRORS], hasLength(2));
+    expect(outputs[UNITS], hasLength(2));
+  }
+
+  test_perform_library() {
+    _performTask(r'''
+library lib;
+import 'lib2.dart';
+export 'lib3.dart';
+part 'part.dart';
+class A {''');
+    expect(outputs, hasLength(9));
+    expect(outputs[EXPLICITLY_IMPORTED_LIBRARIES], hasLength(1));
+    expect(outputs[EXPORTED_LIBRARIES], hasLength(1));
+    _assertHasCore(outputs[IMPORTED_LIBRARIES], 2);
+    expect(outputs[INCLUDED_PARTS], hasLength(1));
+    expect(outputs[LIBRARY_SPECIFIC_UNITS], hasLength(2));
+    expect(outputs[PARSED_UNIT], isNotNull);
+    expect(outputs[REFERENCED_SOURCES], hasLength(5));
+    expect(outputs[RESOLVE_DIRECTIVES_ERRORS], hasLength(0));
+    expect(outputs[UNITS], hasLength(2));
+  }
+
+  test_perform_library_selfReferenceAsPart() {
+    _performTask(r'''
+library lib;
+part 'test.dart';
+''');
+    expect(outputs[INCLUDED_PARTS], unorderedEquals(<Source>[source]));
+  }
+
+  test_perform_part() {
+    _performTask(r'''
+part of lib;
+class B {}''');
+    expect(outputs, hasLength(9));
+    expect(outputs[EXPLICITLY_IMPORTED_LIBRARIES], hasLength(0));
+    expect(outputs[EXPORTED_LIBRARIES], hasLength(0));
+    _assertHasCore(outputs[IMPORTED_LIBRARIES], 1);
+    expect(outputs[INCLUDED_PARTS], hasLength(0));
+    expect(outputs[LIBRARY_SPECIFIC_UNITS], hasLength(1));
+    expect(outputs[PARSED_UNIT], isNotNull);
+    expect(outputs[REFERENCED_SOURCES], hasLength(2));
+    expect(outputs[RESOLVE_DIRECTIVES_ERRORS], hasLength(0));
+    expect(outputs[UNITS], hasLength(1));
+  }
+
+  void _performTask(String content) {
+    if (content == null) {
+      source = resourceProvider.getFile('/test.dart').createSource();
+    } else {
+      source = newSource('/test.dart', content);
+    }
+    computeResult(source, PARSED_UNIT, matcher: isResolveDirectivesTask);
+  }
+
+  static void _assertHasCore(dynamic sourceList, int length) {
+    List<Source> sources = sourceList as List<Source>;
+    expect(sources, hasLength(length));
+    expect(sources, contains(predicate((Source s) {
+      return s.fullName.endsWith('core.dart');
+    })));
+  }
+}
+
+@reflectiveTest
 class ResolveInstanceFieldsInUnitTaskTest extends _AbstractDartTaskTest {
   @override
   void setUp() {
     super.setUp();
     enableStrongMode();
   }
 
   test_created_resolved_unit() {
     Source source = newSource(
         '/test.dart',
@@ skipping 1544 matching lines @@
   }
 
   List<dynamic> computeLibraryResults(
       List<Source> sources, ResultDescriptor result,
       {isInstanceOf matcher: null}) {
     dynamic compute(Source source) {
       computeResult(new LibrarySpecificUnit(source, source), result,
           matcher: matcher);
       return outputs[result];
     }
+
     return sources.map(compute).toList();
   }
 
   List<Map<ResultDescriptor, dynamic>> computeLibraryResultsMap(
       List<Source> sources, ResultDescriptor result,
       {isInstanceOf matcher: null}) {
     Map<ResultDescriptor, dynamic> compute(Source source) {
       computeResult(source, result, matcher: matcher);
       return outputs;
     }
+
     return sources.map(compute).toList();
   }
 
   /**
    * Create a script object with a single fragment containing the given
    * [scriptContent].
    */
   DartScript createScript(String scriptContent) {
     String htmlContent = '''
 <!DOCTYPE html>
@@ skipping 27 matching lines @@
   /**
    * Fill [errorListener] with [result] errors in the current [task].
    */
   void _fillErrorListener(ResultDescriptor<List<AnalysisError>> result) {
     List<AnalysisError> errors = task.outputs[result] as List<AnalysisError>;
     expect(errors, isNotNull, reason: result.name);
     errorListener = new GatheringErrorListener();
     errorListener.addAll(errors);
   }
 }