Build LIBRARY_ELEMENT after RESOLVED_UNIT6 for all units in the closure of a library.

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 'dart:math' as math;
 
 import 'package:analyzer/src/context/cache.dart';
@@ skipping 234 matching lines @@
  *
  * [LIBRARY_ELEMENT4] plus resolved types for every element.
  *
  * The result is only available for [Source]s representing a library.
  */
 final ResultDescriptor<LibraryElement> LIBRARY_ELEMENT5 =
     new ResultDescriptor<LibraryElement>('LIBRARY_ELEMENT5', null,
         cachingPolicy: ELEMENT_CACHING_POLICY);
 
 /**
+ * The partial [LibraryElement] associated with a library.
+ *
+ * [LIBRARY_ELEMENT5] plus resolved elements and types for all expressions.
+ *
+ * The result is only available for [Source]s representing a library.
+ */
+final ResultDescriptor<LibraryElement> LIBRARY_ELEMENT6 =
+    new ResultDescriptor<LibraryElement>('LIBRARY_ELEMENT6', null,
+        cachingPolicy: ELEMENT_CACHING_POLICY);
+
+/**
  * The flag specifying whether all analysis errors are computed in a specific
  * library.
  *
  * The result is only available for [Source]s representing a library.
  */
 final ResultDescriptor<bool> LIBRARY_ERRORS_READY =
     new ResultDescriptor<bool>('LIBRARY_ERRORS_READY', false);
 
 /**
  * The analysis errors associated with a compilation unit in a specific library.
@@ skipping 945 matching lines @@
    * Create a [BuildFunctionTypeAliasesTask] based on the given [target] in
    * the given [context].
    */
   static BuildFunctionTypeAliasesTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new BuildFunctionTypeAliasesTask(context, target);
   }
 }
 
 /**
- * This task finishes building [LIBRARY_ELEMENT] by forcing building
- * constructors for classes in the defining and part units of a library.
+ * This task builds [LIBRARY_ELEMENT6] by forcing building constructors for
+ * all the classes of the defining and part units of a library.
  */
 class BuildLibraryConstructorsTask extends SourceBasedAnalysisTask {
   /**
    * The name of the [LIBRARY_ELEMENT5] input.
    */
   static const String LIBRARY_INPUT = 'LIBRARY_INPUT';
 
   /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'BuildLibraryConstructorsTask', createTask, buildInputs,
-      <ResultDescriptor>[LIBRARY_ELEMENT]);
+      <ResultDescriptor>[LIBRARY_ELEMENT6]);
 
   BuildLibraryConstructorsTask(
       InternalAnalysisContext context, AnalysisTarget target)
       : super(context, target);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
     LibraryElement library = getRequiredInput(LIBRARY_INPUT);
-    outputs[LIBRARY_ELEMENT] = library;
+    outputs[LIBRARY_ELEMENT6] = library;
   }
 
   /**
    * 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(Source libSource) {
     return <String, TaskInput>{
       LIBRARY_INPUT: LIBRARY_ELEMENT5.of(libSource),
@@ skipping 538 matching lines @@
         TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request)
       };
     } else {
       // Should never happen.
       assert(false);
       return <String, TaskInput>{};
     }
   }
 
   /**
-   * Create a [ResolveReferencesTask] based on the given [target] in
+   * Create a [ResolveUnitReferencesTask] based on the given [target] in
    * the given [context].
    */
   static ComputeConstantDependenciesTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new ComputeConstantDependenciesTask(context, target);
   }
 }
 
 /**
  * A task that computes the value of a constant ([CONSTANT_VALUE]) and
@@ skipping 291 matching lines @@
     outputs[RESOLVED_UNIT] = unit;
   }
 
   /**
    * 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(LibrarySpecificUnit target) {
     return <String, TaskInput>{
+      'libraryElement': LIBRARY_ELEMENT.of(target.library),

[Brian Wilkerson, 2015/06/11 13:52:54]

In a future CL, we should probably add comments in places where we're depending
on inputs that we're not using so that we don't forget that we really need them
and think that they can be deleted.

       UNIT_INPUT: RESOLVED_UNIT6.of(target),
       CONSTANT_VALUES:
           COMPILATION_UNIT_CONSTANTS.of(target).toListOf(CONSTANT_VALUE)
     };
   }
 
   /**
    * Create an [EvaluateUnitConstantsTask] based on the given [target] in
    * the given [context].
    */
@@ skipping 375 matching lines @@
     outputs[LIBRARY_ERRORS_READY] = true;
   }
 
   /**
    * 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 [library].
    */
   static Map<String, TaskInput> buildInputs(Source library) {
     return <String, TaskInput>{
+      'allLibraryElements':
+          IMPORT_EXPORT_SOURCE_CLOSURE.of(library).toListOf(LIBRARY_ELEMENT),
       'allErrors': UNITS.of(library).toListOf(DART_ERRORS)
     };
   }
 
   /**
    * Create a [LibraryErrorsReadyTask] based on the given [target] in the given
    * [context].
    */
   static LibraryErrorsReadyTask createTask(
       AnalysisContext context, AnalysisTarget target) {
@@ skipping 330 matching lines @@
   void _addPublicNames(CompilationUnitElement compilationUnit) {
     compilationUnit.accessors.forEach(_addIfPublic);
     compilationUnit.enums.forEach(_addIfPublic);
     compilationUnit.functions.forEach(_addIfPublic);
     compilationUnit.functionTypeAliases.forEach(_addIfPublic);
     compilationUnit.types.forEach(_addIfPublic);
   }
 }
 
 /**
+ * A task that finishes resolution by requesting [RESOLVED_UNIT6] for every
+ * unit in the libraries closure and produces [LIBRARY_ELEMENT].
+ */
+class ResolveLibraryReferencesTask extends SourceBasedAnalysisTask {
+  /**
+   * The name of the [LIBRARY_ELEMENT6] input.
+   */
+  static const String LIBRARY_INPUT = 'LIBRARY_INPUT';
+
+  /**
+   * The task descriptor describing this kind of task.
+   */
+  static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
+      'ResolveLibraryReferencesTask', createTask, buildInputs,
+      <ResultDescriptor>[LIBRARY_ELEMENT]);
+
+  ResolveLibraryReferencesTask(
+      InternalAnalysisContext context, AnalysisTarget target)
+      : super(context, target);
+
+  @override
+  TaskDescriptor get descriptor => DESCRIPTOR;
+
+  @override
+  void internalPerform() {
+    LibraryElement library = getRequiredInput(LIBRARY_INPUT);
+    outputs[LIBRARY_ELEMENT] = library;
+  }
+
+  /**
+   * 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(Source libSource) {
+    return <String, TaskInput>{
+      LIBRARY_INPUT: LIBRARY_ELEMENT6.of(libSource),
+      'resolvedUnits': IMPORT_EXPORT_SOURCE_CLOSURE
+          .of(libSource)
+          .toMapOf(UNITS)
+          .toFlattenList((Source library, Source unit) =>
+              RESOLVED_UNIT6.of(new LibrarySpecificUnit(library, unit))),
+    };
+  }
+
+  /**
+   * Create a [ResolveLibraryReferencesTask] based on the given [target] in
+   * the given [context].
+   */
+  static ResolveLibraryReferencesTask createTask(
+      AnalysisContext context, AnalysisTarget target) {
+    return new ResolveLibraryReferencesTask(context, target);
+  }
+}
+
+/**
  * An artifitial task that does nothing except to force type names resolution
  * for the defining and part units of a library.
  */
 class ResolveLibraryTypeNamesTask extends SourceBasedAnalysisTask {
   /**
    * The name of the [LIBRARY_ELEMENT4] input.
    */
   static const String LIBRARY_INPUT = 'LIBRARY_INPUT';
 
   /**
@@ skipping 38 matching lines @@
    */
   static ResolveLibraryTypeNamesTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new ResolveLibraryTypeNamesTask(context, target);
   }
 }
 
 /**
  * A task that builds [RESOLVED_UNIT6] for a unit.
  */
-class ResolveReferencesTask extends SourceBasedAnalysisTask {
+class ResolveUnitReferencesTask extends SourceBasedAnalysisTask {
   /**
-   * The name of the [LIBRARY_ELEMENT] input.
+   * The name of the [LIBRARY_ELEMENT6] input.
    */
   static const String LIBRARY_INPUT = 'LIBRARY_INPUT';
 
   /**
    * The name of the [RESOLVED_UNIT5] input.
    */
   static const String UNIT_INPUT = 'UNIT_INPUT';
 
   /**
    * The name of the [TYPE_PROVIDER] input.
    */
   static const String TYPE_PROVIDER_INPUT = 'TYPE_PROVIDER_INPUT';
 
   /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
-      'ResolveReferencesTask', createTask, buildInputs, <ResultDescriptor>[
+      'ResolveUnitReferencesTask', createTask, buildInputs, <ResultDescriptor>[
     RESOLVE_REFERENCES_ERRORS,
     RESOLVED_UNIT6
   ]);
 
-  ResolveReferencesTask(InternalAnalysisContext context, AnalysisTarget target)
+  ResolveUnitReferencesTask(
+      InternalAnalysisContext context, AnalysisTarget target)
       : super(context, target);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
     RecordingErrorListener errorListener = new RecordingErrorListener();
     //
     // Prepare inputs.
@@ skipping 18 matching lines @@
     outputs[RESOLVED_UNIT6] = unit;
   }
 
   /**
    * 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(LibrarySpecificUnit target) {
     return <String, TaskInput>{
-      LIBRARY_INPUT: LIBRARY_ELEMENT.of(target.library),
+      LIBRARY_INPUT: LIBRARY_ELEMENT6.of(target.library),
       UNIT_INPUT: RESOLVED_UNIT5.of(target),
       TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request)
     };
   }
 
   /**
-   * Create a [ResolveReferencesTask] based on the given [target] in
+   * Create a [ResolveUnitReferencesTask] based on the given [target] in
    * the given [context].
    */
-  static ResolveReferencesTask createTask(
+  static ResolveUnitReferencesTask createTask(
       AnalysisContext context, AnalysisTarget target) {
-    return new ResolveReferencesTask(context, target);
+    return new ResolveUnitReferencesTask(context, target);
   }
 }
 
 /**
  * A task that builds [RESOLVED_UNIT4] for a unit.
  */
 class ResolveUnitTypeNamesTask extends SourceBasedAnalysisTask {
   /**
    * The name of the input whose value is the defining [LIBRARY_ELEMENT4].
    */
@@ skipping 70 matching lines @@
       AnalysisContext context, AnalysisTarget target) {
     return new ResolveUnitTypeNamesTask(context, target);
   }
 }
 
 /**
  * A task that builds [RESOLVED_UNIT5] for a unit.
  */
 class ResolveVariableReferencesTask extends SourceBasedAnalysisTask {
   /**
-   * The name of the [LIBRARY_ELEMENT] input.
+   * The name of the [LIBRARY_ELEMENT6] input.
    */
   static const String LIBRARY_INPUT = 'LIBRARY_INPUT';
 
   /**
    * The name of the [RESOLVED_UNIT4] input.
    */
   static const String UNIT_INPUT = 'UNIT_INPUT';
 
   /**
    * The name of the [TYPE_PROVIDER] input.
@@ skipping 41 matching lines @@
 
   /**
    * 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(LibrarySpecificUnit target) {
     return <String, TaskInput>{
       'fullyBuiltLibraryElements': IMPORT_EXPORT_SOURCE_CLOSURE
           .of(target.library)
-          .toListOf(LIBRARY_ELEMENT),
-      LIBRARY_INPUT: LIBRARY_ELEMENT.of(target.library),
+          .toListOf(LIBRARY_ELEMENT6),
+      LIBRARY_INPUT: LIBRARY_ELEMENT6.of(target.library),
       UNIT_INPUT: RESOLVED_UNIT4.of(target),
       TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request)
     };
   }
 
   /**
    * Create a [ResolveVariableReferencesTask] based on the given [target] in
    * the given [context].
    */
   static ResolveVariableReferencesTask createTask(
@@ skipping 164 matching lines @@
         uriLiteral, [directive.uriContent]);
   }
 
   /**
    * 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(LibrarySpecificUnit target) {
     return <String, TaskInput>{
+      'libraryElement': LIBRARY_ELEMENT.of(target.library),
       UNIT_INPUT: RESOLVED_UNIT.of(target),
       TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request)
     };
   }
 
   /**
    * Create a [VerifyUnitTask] based on the given [target] in
    * the given [context].
    */
   static VerifyUnitTask createTask(
@@ skipping 102 matching lines @@
   @override
   bool moveNext() {
     if (_newSources.isEmpty) {
       return false;
     }
     currentTarget = _newSources.first;
     _newSources.remove(currentTarget);
     return true;
   }
 }