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

pkg/analyzer/lib/src/task/dart.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.src.task.dart;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 316 matching lines @@
     new ResultDescriptor<bool>('CREATED_RESOLVED_UNIT9', false);
 
 /**
  * All [AnalysisError]s results for [Source]s.
  */
 final List<ListResultDescriptor<AnalysisError>> ERROR_SOURCE_RESULTS =
     <ListResultDescriptor<AnalysisError>>[
   BUILD_DIRECTIVES_ERRORS,
   BUILD_LIBRARY_ERRORS,
   PARSE_ERRORS,
+  RESOLVE_DIRECTIVES_ERRORS,
   SCAN_ERRORS,
 ];
 
 /**
  * All [AnalysisError]s results in for [LibrarySpecificUnit]s.
  */
 final List<ListResultDescriptor<AnalysisError>> ERROR_UNIT_RESULTS =
     <ListResultDescriptor<AnalysisError>>[
   HINTS,
   LIBRARY_UNIT_ERRORS,
@@ skipping 272 matching lines @@
  *
  * The list will be empty if there were no errors, but will not be `null`.
  *
  * The result is only available for [Source]s representing a compilation unit.
  */
 final ListResultDescriptor<AnalysisError> PARSE_ERRORS =
     new ListResultDescriptor<AnalysisError>(
         'PARSE_ERRORS', AnalysisError.NO_ERRORS);
 
 /**
+ * The compilation unit AST produced while parsing a compilation unit.
+ *
+ * The AST structure will not have resolution information associated with it.
+ *
+ * The result is only available for [Source]s representing a compilation unit.
+ */
+final ResultDescriptor<CompilationUnit> PARSED_UNIT1 =
+    new ResultDescriptor<CompilationUnit>('PARSED_UNIT1', null,
+        cachingPolicy: AST_CACHING_POLICY);
+
+/**
  * The list of [PendingError]s for a compilation unit.
  *
  * The result is only available for [LibrarySpecificUnit]s.
  */
 final ListResultDescriptor<PendingError> PENDING_ERRORS =
     new ListResultDescriptor<PendingError>(
         'PENDING_ERRORS', const <PendingError>[]);
 
 /**
  * A list of the [VariableElement]s whose type should be known to propagate
@@ skipping 83 matching lines @@
 /**
  * The list of [ConstantEvaluationTarget]s on which error verification depends.
  *
  * The result is only available for [LibrarySpecificUnit]s.
  */
 final ListResultDescriptor<ConstantEvaluationTarget> REQUIRED_CONSTANTS =
     new ListResultDescriptor<ConstantEvaluationTarget>(
         'REQUIRED_CONSTANTS', const <ConstantEvaluationTarget>[]);
 
 /**
+ * The errors produced while resolving [UriBasedDirective]s in a unit.
+ *
+ * The list will be empty if there were no errors, but will not be `null`.
+ *
+ * The result is only available for [Source]s representing a compilation unit.
+ */
+final ListResultDescriptor<AnalysisError> RESOLVE_DIRECTIVES_ERRORS =
+    new ListResultDescriptor<AnalysisError>(
+        'PARSE_ERRORS2', AnalysisError.NO_ERRORS);
+
+/**
  * The errors produced while resolving bounds of type parameters of classes,
  * class and function aliases.
  *
  * The list will be empty if there were no errors, but will not be `null`.
  *
  * The result is only available for [LibrarySpecificUnit]s.
  */
 final ListResultDescriptor<AnalysisError> RESOLVE_TYPE_BOUNDS_ERRORS =
     new ListResultDescriptor<AnalysisError>(
         'RESOLVE_TYPE_BOUNDS_ERRORS', AnalysisError.NO_ERRORS);
@@ skipping 2008 matching lines @@
         targetLibrary = target;
       }
     }
     // We don't know what to do with the given target, invalidate it.
     if (targetUnit == null || targetUnit != targetLibrary) {
       return DeltaResult.INVALIDATE;
     }
     // Keep results that don't change: any library.
     if (_isTaskResult(ScanDartTask.DESCRIPTOR, descriptor) ||
         _isTaskResult(ParseDartTask.DESCRIPTOR, descriptor) ||
+        _isTaskResult(ResolveDirectivesTask.DESCRIPTOR, descriptor) ||
         _isTaskResult(BuildCompilationUnitElementTask.DESCRIPTOR, descriptor) ||
         _isTaskResult(BuildLibraryElementTask.DESCRIPTOR, descriptor) ||
         _isTaskResult(BuildDirectiveElementsTask.DESCRIPTOR, descriptor) ||
         _isTaskResult(ResolveDirectiveElementsTask.DESCRIPTOR, descriptor) ||
         _isTaskResult(BuildEnumMemberElementsTask.DESCRIPTOR, descriptor) ||
         _isTaskResult(BuildSourceExportClosureTask.DESCRIPTOR, descriptor) ||
         _isTaskResult(ReadyLibraryElement2Task.DESCRIPTOR, descriptor) ||
         _isTaskResult(ComputeLibraryCycleTask.DESCRIPTOR, descriptor)) {
       return DeltaResult.KEEP_CONTINUE;
     }
@@ skipping 1258 matching lines @@
   /**
    * The name of the input whose value is the token stream produced for the file.
    */
   static const String TOKEN_STREAM_INPUT_NAME = 'TOKEN_STREAM_INPUT_NAME';
 
   /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'ParseDartTask', createTask, buildInputs, <ResultDescriptor>[
-    EXPLICITLY_IMPORTED_LIBRARIES,
-    EXPORTED_LIBRARIES,
-    IMPORTED_LIBRARIES,
-    INCLUDED_PARTS,
-    LIBRARY_SPECIFIC_UNITS,
     PARSE_ERRORS,
-    PARSED_UNIT,
+    PARSED_UNIT1,
     REFERENCED_NAMES,
-    REFERENCED_SOURCES,
     SOURCE_KIND,
-    UNITS,
   ]);
 
   /**
    * Initialize a newly created task to parse the content of the Dart file
    * associated with the given [target] in the given [context].
    */
   ParseDartTask(InternalAnalysisContext context, AnalysisTarget target)
       : super(context, target);
 
   @override
@@ skipping 11 matching lines @@
     AnalysisOptions options = context.analysisOptions;
     parser.parseAsync = options.enableAsync;
     parser.parseFunctionBodies = options.analyzeFunctionBodiesPredicate(source);
     parser.parseGenericMethods = options.enableGenericMethods;
     parser.parseGenericMethodComments = options.strongMode;
     CompilationUnit unit = parser.parseCompilationUnit(tokenStream);
     unit.lineInfo = lineInfo;
 
     bool hasNonPartOfDirective = false;
     bool hasPartOfDirective = false;
-    HashSet<Source> explicitlyImportedSourceSet = new HashSet<Source>();
-    HashSet<Source> exportedSourceSet = new HashSet<Source>();
-    HashSet<Source> includedSourceSet = new HashSet<Source>();
-    NodeList<Directive> directives = unit.directives;
+    List<Directive> directives = unit.directives;
     int length = directives.length;
     for (int i = 0; i < length; i++) {
       Directive directive = directives[i];
       if (directive is PartOfDirective) {
         hasPartOfDirective = true;
       } else {
         hasNonPartOfDirective = true;
-        if (directive is UriBasedDirective) {
-          Source referencedSource =
-              resolveDirective(context, source, directive, errorListener);
-          if (referencedSource != null) {
-            if (directive is ExportDirective) {
-              exportedSourceSet.add(referencedSource);
-            } else if (directive is ImportDirective) {
-              explicitlyImportedSourceSet.add(referencedSource);
-            } else if (directive is PartDirective) {
-              includedSourceSet.add(referencedSource);
-            } else {
-              throw new AnalysisException(
-                  '$runtimeType failed to handle a ${directive.runtimeType}');
-            }
-          }
-        }
       }
     }
     //
-    // Always include "dart:core" source.
-    //
-    HashSet<Source> importedSourceSet =
-        new HashSet.from(explicitlyImportedSourceSet);
-    Source coreLibrarySource = context.sourceFactory.forUri(DartSdk.DART_CORE);
-    if (coreLibrarySource == null) {
-      String message;
-      DartSdk sdk = context.sourceFactory.dartSdk;
-      if (sdk == null) {
-        message = 'Could not resolve "dart:core": SDK not defined';
-      } else {
-        message = 'Could not resolve "dart:core": SDK incorrectly configured';
-      }
-      throw new AnalysisException(message);
-    }
-    importedSourceSet.add(coreLibrarySource);
-    //
     // Compute kind.
     //
     SourceKind sourceKind = SourceKind.LIBRARY;
     if (modificationTime == -1) {
       sourceKind = SourceKind.UNKNOWN;
     } else if (hasPartOfDirective && !hasNonPartOfDirective) {
       sourceKind = SourceKind.PART;
     }
     //
     // Compute referenced names.
     //
     ReferencedNames referencedNames = new ReferencedNames(source);
     new ReferencedNamesBuilder(referencedNames).build(unit);
     //
     // Record outputs.
     //
-    List<Source> explicitlyImportedSources =
-        explicitlyImportedSourceSet.toList();
-    List<Source> exportedSources = exportedSourceSet.toList();
-    List<Source> importedSources = importedSourceSet.toList();
-    List<Source> includedSources = includedSourceSet.toList();
     List<AnalysisError> parseErrors = getUniqueErrors(errorListener.errors);
-    List<Source> unitSources = <Source>[source]..addAll(includedSourceSet);
-    List<Source> referencedSources = (new Set<Source>()
-          ..addAll(importedSources)
-          ..addAll(exportedSources)
-          ..addAll(unitSources))
-        .toList();
-    List<LibrarySpecificUnit> librarySpecificUnits =
-        unitSources.map((s) => new LibrarySpecificUnit(source, s)).toList();
-    outputs[EXPLICITLY_IMPORTED_LIBRARIES] = explicitlyImportedSources;
-    outputs[EXPORTED_LIBRARIES] = exportedSources;
-    outputs[IMPORTED_LIBRARIES] = importedSources;
-    outputs[INCLUDED_PARTS] = includedSources;
-    outputs[LIBRARY_SPECIFIC_UNITS] = librarySpecificUnits;
     outputs[PARSE_ERRORS] = parseErrors;
-    outputs[PARSED_UNIT] = unit;
+    outputs[PARSED_UNIT1] = unit;
     outputs[REFERENCED_NAMES] = referencedNames;
-    outputs[REFERENCED_SOURCES] = referencedSources;
     outputs[SOURCE_KIND] = sourceKind;
-    outputs[UNITS] = unitSources;
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the given
    * [target].
    */
   static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
     return <String, TaskInput>{
       LINE_INFO_INPUT_NAME: LINE_INFO.of(target),
       MODIFICATION_TIME_INPUT_NAME: MODIFICATION_TIME.of(target),
       TOKEN_STREAM_INPUT_NAME: TOKEN_STREAM.of(target, flushOnAccess: true)
     };
   }
 
   /**
    * Create a [ParseDartTask] based on the given [target] in the given
    * [context].
    */
   static ParseDartTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new ParseDartTask(context, target);
   }
-
-  /**
-   * Return the result of resolving the URI of the given URI-based [directive]
-   * against the URI of the given library, or `null` if the URI is not valid.
-   *
-   * Resolution is to be performed in the given [context]. Errors should be
-   * reported to the [errorListener].
-   */
-  static Source resolveDirective(AnalysisContext context, Source librarySource,
-      UriBasedDirective directive, AnalysisErrorListener errorListener) {
-    StringLiteral uriLiteral = directive.uri;
-    String uriContent = uriLiteral.stringValue;
-    if (uriContent != null) {
-      uriContent = uriContent.trim();
-      directive.uriContent = uriContent;
-    }
-    UriValidationCode code = directive.validate();
-    if (code == null) {
-      String encodedUriContent = Uri.encodeFull(uriContent);
-      Source source =
-          context.sourceFactory.resolveUri(librarySource, encodedUriContent);
-      directive.source = source;
-      return source;
-    }
-    if (code == UriValidationCode.URI_WITH_DART_EXT_SCHEME) {
-      return null;
-    }
-    if (code == UriValidationCode.URI_WITH_INTERPOLATION) {
-      errorListener.onError(new AnalysisError(librarySource, uriLiteral.offset,
-          uriLiteral.length, CompileTimeErrorCode.URI_WITH_INTERPOLATION));
-      return null;
-    }
-    if (code == UriValidationCode.INVALID_URI) {
-      errorListener.onError(new AnalysisError(librarySource, uriLiteral.offset,
-          uriLiteral.length, CompileTimeErrorCode.INVALID_URI, [uriContent]));
-      return null;
-    }
-    throw new AnalysisException('Failed to handle validation code: $code');
-  }
 }
 
 /**
  * A task that builds [RESOLVED_UNIT7] for a unit.
  */
 class PartiallyResolveUnitReferencesTask extends SourceBasedAnalysisTask {
   /**
    * The name of the [LIBRARY_ELEMENT6] input.
    */
   static const String LIBRARY_INPUT = 'LIBRARY_INPUT';
@@ skipping 1077 matching lines @@
    * Create a [ResolveDirectiveElementsTask] based on the given [target] in
    * the given [context].
    */
   static ResolveDirectiveElementsTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new ResolveDirectiveElementsTask(context, target);
   }
 }
 
 /**
+ * A task that resolves URIs of [UriBasedDirective]s and reports errors.
+ */
+class ResolveDirectivesTask extends SourceBasedAnalysisTask {
+  /**
+   * The name of the input whose value is the [PARSED_UNIT1] for the file.
+   */
+  static const String PARSED_UNIT_INPUT = 'PARSED_UNIT_INPUT';
+
+  /**
+   * The task descriptor describing this kind of task.
+   */
+  static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
+      'ResolveDirectivesTask', createTask, buildInputs, <ResultDescriptor>[
+    EXPLICITLY_IMPORTED_LIBRARIES,
+    EXPORTED_LIBRARIES,
+    IMPORTED_LIBRARIES,
+    INCLUDED_PARTS,
+    LIBRARY_SPECIFIC_UNITS,
+    PARSED_UNIT,
+    RESOLVE_DIRECTIVES_ERRORS,
+    REFERENCED_SOURCES,
+    UNITS,
+  ]);
+
+  /**
+   * Initialize a newly created task to parse the content of the Dart file
+   * associated with the given [target] in the given [context].
+   */
+  ResolveDirectivesTask(InternalAnalysisContext context, AnalysisTarget target)
+      : super(context, target);
+
+  @override
+  TaskDescriptor get descriptor => DESCRIPTOR;
+
+  @override
+  void internalPerform() {
+    Source source = getRequiredSource();
+    CompilationUnit unit = getRequiredInput(PARSED_UNIT_INPUT);
+
+    RecordingErrorListener errorListener = new RecordingErrorListener();
+    HashSet<Source> explicitlyImportedSourceSet = new HashSet<Source>();
+    HashSet<Source> exportedSourceSet = new HashSet<Source>();
+    HashSet<Source> includedSourceSet = new HashSet<Source>();
+    NodeList<Directive> directives = unit.directives;
+    int length = directives.length;
+    for (int i = 0; i < length; i++) {
+      Directive directive = directives[i];
+      if (directive is UriBasedDirective) {
+        Source referencedSource =
+            resolveDirective(context, source, directive, errorListener);
+        if (referencedSource != null) {
+          if (directive is ExportDirective) {
+            exportedSourceSet.add(referencedSource);
+          } else if (directive is ImportDirective) {
+            explicitlyImportedSourceSet.add(referencedSource);
+          } else if (directive is PartDirective) {
+            includedSourceSet.add(referencedSource);
+          } else {
+            throw new AnalysisException(
+                '$runtimeType failed to handle a ${directive.runtimeType}');
+          }
+        }
+      }
+    }
+    //
+    // Always include "dart:core" source.
+    //
+    HashSet<Source> importedSourceSet =
+        new HashSet.from(explicitlyImportedSourceSet);
+    Source coreLibrarySource = context.sourceFactory.forUri(DartSdk.DART_CORE);
+    if (coreLibrarySource == null) {
+      String message;
+      DartSdk sdk = context.sourceFactory.dartSdk;
+      if (sdk == null) {
+        message = 'Could not resolve "dart:core": SDK not defined';
+      } else {
+        message = 'Could not resolve "dart:core": SDK incorrectly configured';
+      }
+      throw new AnalysisException(message);
+    }
+    importedSourceSet.add(coreLibrarySource);
+    //
+    // Record outputs.
+    //
+    List<Source> explicitlyImportedSources =
+        explicitlyImportedSourceSet.toList();
+    List<Source> exportedSources = exportedSourceSet.toList();
+    List<Source> importedSources = importedSourceSet.toList();
+    List<Source> includedSources = includedSourceSet.toList();
+    List<AnalysisError> errors = getUniqueErrors(errorListener.errors);
+    List<Source> unitSources = <Source>[source]..addAll(includedSourceSet);
+    List<Source> referencedSources = (new Set<Source>()
+          ..addAll(importedSources)
+          ..addAll(exportedSources)
+          ..addAll(unitSources))
+        .toList();
+    List<LibrarySpecificUnit> librarySpecificUnits =
+        unitSources.map((s) => new LibrarySpecificUnit(source, s)).toList();
+    outputs[EXPLICITLY_IMPORTED_LIBRARIES] = explicitlyImportedSources;
+    outputs[EXPORTED_LIBRARIES] = exportedSources;
+    outputs[IMPORTED_LIBRARIES] = importedSources;
+    outputs[INCLUDED_PARTS] = includedSources;
+    outputs[LIBRARY_SPECIFIC_UNITS] = librarySpecificUnits;
+    outputs[PARSED_UNIT] = unit;
+    outputs[RESOLVE_DIRECTIVES_ERRORS] = errors;
+    outputs[REFERENCED_SOURCES] = referencedSources;
+    outputs[UNITS] = unitSources;
+  }
+
+  /**
+   * Return a map from the names of the inputs of this kind of task to the task
+   * input descriptors describing those inputs for a task with the given
+   * [target].
+   */
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+    return <String, TaskInput>{
+      PARSED_UNIT_INPUT: PARSED_UNIT1.of(target, flushOnAccess: true)
+    };
+  }
+
+  /**
+   * Create a [ResolveDirectivesTask] based on the given [target] in the given
+   * [context].
+   */
+  static ResolveDirectivesTask createTask(
+      AnalysisContext context, AnalysisTarget target) {
+    return new ResolveDirectivesTask(context, target);
+  }
+
+  /**
+   * Return the result of resolving the URI of the given URI-based [directive]
+   * against the URI of the given library, or `null` if the URI is not valid.
+   *
+   * Resolution is to be performed in the given [context]. Errors should be
+   * reported to the [errorListener].
+   */
+  static Source resolveDirective(AnalysisContext context, Source librarySource,
+      UriBasedDirective directive, AnalysisErrorListener errorListener) {
+    StringLiteral uriLiteral = directive.uri;
+    String uriContent = uriLiteral.stringValue;
+    if (uriContent != null) {
+      uriContent = uriContent.trim();
+      directive.uriContent = uriContent;
+    }
+    UriValidationCode code = directive.validate();
+    if (code == null) {
+      String encodedUriContent = Uri.encodeFull(uriContent);
+      Source source =
+          context.sourceFactory.resolveUri(librarySource, encodedUriContent);
+      directive.source = source;
+      return source;
+    }
+    if (code == UriValidationCode.URI_WITH_DART_EXT_SCHEME) {
+      return null;
+    }
+    if (code == UriValidationCode.URI_WITH_INTERPOLATION) {
+      errorListener.onError(new AnalysisError(librarySource, uriLiteral.offset,
+          uriLiteral.length, CompileTimeErrorCode.URI_WITH_INTERPOLATION));
+      return null;
+    }
+    if (code == UriValidationCode.INVALID_URI) {
+      errorListener.onError(new AnalysisError(librarySource, uriLiteral.offset,
+          uriLiteral.length, CompileTimeErrorCode.INVALID_URI, [uriContent]));
+      return null;
+    }
+    throw new AnalysisException('Failed to handle validation code: $code');
+  }
+}
+
+/**
  * A task that ensures that all of the inferable instance members in a
  * compilation unit have had their right hand sides re-resolved
  */
 class ResolveInstanceFieldsInUnitTask extends SourceBasedAnalysisTask {
   /**
    * The name of the [LIBRARY_ELEMENT6] input.
    */
   static const String LIBRARY_INPUT = 'LIBRARY_INPUT';
 
   /**
@@ skipping 1241 matching lines @@
 
   @override
   bool moveNext() {
     if (_newSources.isEmpty) {
       return false;
     }
     currentTarget = _newSources.removeLast();
     return true;
   }
 }