ResolveLibraryTypeNamesTask to force type name resolution in parts.

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/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
@@ skipping 97 matching lines @@
  * libraries exports one.
  *
  * Also [LibraryElement.exportNamespace] is set.
  *
  * The result is only available for targets representing a Dart library.
  */
 final ResultDescriptor<LibraryElement> LIBRARY_ELEMENT4 =
     new ResultDescriptor<LibraryElement>('LIBRARY_ELEMENT4', null);
 
 /**
+ * The partial [LibraryElement] associated with a library.
+ *
+ * [LIBRARY_ELEMENT4] plus [RESOLVED_UNIT4] for every unit.
+ *
+ * The result is only available for targets representing a Dart library.
+ */
+final ResultDescriptor<LibraryElement> LIBRARY_ELEMENT5 =
+    new ResultDescriptor<LibraryElement>('LIBRARY_ELEMENT5', null);
+
+/**
  * The errors produced while resolving type names.
  *
  * The list will be empty if there were no errors, but will not be `null`.
  *
  * The result is only available for targets representing a Dart library.
  */
 final ResultDescriptor<List<AnalysisError>> RESOLVE_TYPE_NAMES_ERRORS =
     new ResultDescriptor<List<AnalysisError>>(
         'RESOLVE_TYPE_NAMES_ERRORS', AnalysisError.NO_ERRORS,
         contributesTo: DART_ERRORS);
 
 /**
  * The partially resolved [CompilationUnit] associated with a unit.
  *
  * All declarations bound to the element defined by the declaration.
  *
  * The result is only available for targets representing a unit.
  */
 final ResultDescriptor<CompilationUnit> RESOLVED_UNIT1 =
     new ResultDescriptor<CompilationUnit>('RESOLVED_UNIT1', null);
 
 /**
  * The partially resolved [CompilationUnit] associated with a unit.
  *
- * Directives 'library', 'part' and 'part of' are resolved.
+ * All the enum member elements are built.
  *
- * The result is only available for targets representing a library.
+ * The result is only available for targets representing a unit.
  */
 final ResultDescriptor<CompilationUnit> RESOLVED_UNIT2 =
     new ResultDescriptor<CompilationUnit>('RESOLVED_UNIT2', null);
 
 /**
- * The partially resolved [CompilationUnit] associated with a library.
+ * The partially resolved [CompilationUnit] associated with a unit.
  *
- * All the directives are resolved.
+ * All the function type aliases are resolved.
  *
- * The result is only available for targets representing a library.
+ * The result is only available for targets representing a unit.
  */
 final ResultDescriptor<CompilationUnit> RESOLVED_UNIT3 =
     new ResultDescriptor<CompilationUnit>('RESOLVED_UNIT3', null);
 
 /**
  * The partially resolved [CompilationUnit] associated with a unit.
  *
- * All the enum member elements are built.
+ * [RESOLVED_UNIT3] with resolved type names.
  *
  * The result is only available for targets representing a unit.
  */
 final ResultDescriptor<CompilationUnit> RESOLVED_UNIT4 =
     new ResultDescriptor<CompilationUnit>('RESOLVED_UNIT4', null);
 
 /**
- * The partially resolved [CompilationUnit] associated with a unit.
- *
- * All the function type aliases are resolved.
- *
- * The result is only available for targets representing a unit.
- */
-final ResultDescriptor<CompilationUnit> RESOLVED_UNIT5 =
-    new ResultDescriptor<CompilationUnit>('RESOLVED_UNIT5', null);
-
-/**
- * The partially resolved [CompilationUnit] associated with a unit.
- *
- * [RESOLVED_UNIT5] with resolved type names.
- *
- * The result is only available for targets representing a unit.
- */
-final ResultDescriptor<CompilationUnit> RESOLVED_UNIT6 =
-    new ResultDescriptor<CompilationUnit>('RESOLVED_UNIT6', null);
-
-/**
  * The [TypeProvider] of the context.
  */
 final ResultDescriptor<TypeProvider> TYPE_PROVIDER =
     new ResultDescriptor<TypeProvider>('TYPE_PROVIDER', null);
 
 /**
  * A task that builds a compilation unit element for a single compilation unit.
  */
 class BuildCompilationUnitElementTask extends SourceBasedAnalysisTask {
   /**
    * The name of the input whose value is the line information for the
    * compilation unit.
    */
   static const String LINE_INFO_INPUT_NAME = 'LINE_INFO_INPUT_NAME';
 
   /**
    * The name of the input whose value is the AST for the compilation unit.
    */
   static const String PARSED_UNIT_INPUT_NAME = 'PARSED_UNIT_INPUT_NAME';
 
   /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
-      'BUILD_COMPILATION_UNIT_ELEMENT', createTask, buildInputs,
+      'BuildCompilationUnitElementTask', createTask, buildInputs,
       <ResultDescriptor>[COMPILATION_UNIT_ELEMENT, RESOLVED_UNIT1]);
 
   /**
    * Initialize a newly created task to build a compilation unit element for
    * the given [target] in the given [context].
    */
   BuildCompilationUnitElementTask(
       InternalAnalysisContext context, AnalysisTarget target)
       : super(context, target);
 
@@ skipping 39 matching lines @@
       AnalysisContext context, AnalysisTarget target) {
     return new BuildCompilationUnitElementTask(context, target);
   }
 }
 
 /**
  * A task that builds imports and export directive elements for a library.
  */
 class BuildDirectiveElementsTask extends SourceBasedAnalysisTask {
   /**
-   * The name of the input for [RESOLVED_UNIT2] of a library unit.
+   * The name of the input for [RESOLVED_UNIT1] of a library unit.
    */
-  static const String RESOLVED_UNIT2_INPUT_NAME = 'RESOLVED_UNIT2_INPUT_NAME';
+  static const String UNIT_INPUT_NAME = 'UNIT_INPUT_NAME';
 
   /**
    * The input with a list of [LIBRARY_ELEMENT3]s of imported libraries.
    */
   static const String IMPORTS_LIBRARY_ELEMENT_INPUT_NAME =
       'IMPORTS_LIBRARY_ELEMENT1_INPUT_NAME';
 
   /**
    * The input with a list of [LIBRARY_ELEMENT3]s of exported libraries.
    */
   static const String EXPORTS_LIBRARY_ELEMENT_INPUT_NAME =
       'EXPORTS_LIBRARY_ELEMENT_INPUT_NAME';
 
   /**
    * The input with a list of [SOURCE_KIND]s of imported libraries.
    */
   static const String IMPORTS_SOURCE_KIND_INPUT_NAME =
       'IMPORTS_SOURCE_KIND_INPUT_NAME';
 
   /**
    * The input with a list of [SOURCE_KIND]s of exported libraries.
    */
   static const String EXPORTS_SOURCE_KIND_INPUT_NAME =
       'EXPORTS_SOURCE_KIND_INPUT_NAME';
 
   /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
-      'BUILD_RESOLVED_UNIT3', createTask, buildInputs, <ResultDescriptor>[
+      'BuildDirectiveElementsTask', createTask, buildInputs, <ResultDescriptor>[
     LIBRARY_ELEMENT2,
-    RESOLVED_UNIT3,
     BUILD_DIRECTIVES_ERRORS
   ]);
 
   BuildDirectiveElementsTask(
       InternalAnalysisContext context, AnalysisTarget target)
       : super(context, target);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
     List<AnalysisError> errors = <AnalysisError>[];
     //
     // Prepare inputs.
     //
-    CompilationUnit libraryUnit = getRequiredInput(RESOLVED_UNIT2_INPUT_NAME);
+    CompilationUnit libraryUnit = getRequiredInput(UNIT_INPUT_NAME);
     Map<Source, LibraryElement> importLibraryMap =
         getRequiredInput(IMPORTS_LIBRARY_ELEMENT_INPUT_NAME);
     Map<Source, LibraryElement> exportLibraryMap =
         getRequiredInput(EXPORTS_LIBRARY_ELEMENT_INPUT_NAME);
     Map<Source, SourceKind> importSourceKindMap =
         getRequiredInput(IMPORTS_SOURCE_KIND_INPUT_NAME);
     Map<Source, SourceKind> exportSourceKindMap =
         getRequiredInput(EXPORTS_SOURCE_KIND_INPUT_NAME);
     //
     // Process inputs.
@@ skipping 98 matching lines @@
     }
     //
     // Populate the library element.
     //
     libraryElement.imports = imports;
     libraryElement.exports = exports;
     //
     // Record outputs.
     //
     outputs[LIBRARY_ELEMENT2] = libraryElement;
-    outputs[RESOLVED_UNIT3] = libraryUnit;
     outputs[BUILD_DIRECTIVES_ERRORS] = errors;
   }
 
   /**
    * 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 [source].
+   * given library [libSource].
    */
-  static Map<String, TaskInput> buildInputs(Source source) {
+  static Map<String, TaskInput> buildInputs(Source libSource) {
     return <String, TaskInput>{
-      RESOLVED_UNIT2_INPUT_NAME: RESOLVED_UNIT2.inputFor(source),
+      'defining_LIBRARY_ELEMENT1': LIBRARY_ELEMENT1.inputFor(libSource),
+      UNIT_INPUT_NAME:
+          RESOLVED_UNIT1.inputFor(new LibraryUnitTarget(libSource, libSource)),
       IMPORTS_LIBRARY_ELEMENT_INPUT_NAME:
           new ListToMapTaskInput<Source, LibraryElement>(
-              IMPORTED_LIBRARIES.inputFor(source),
+              IMPORTED_LIBRARIES.inputFor(libSource),
               (Source source) => LIBRARY_ELEMENT1.inputFor(source)),
       EXPORTS_LIBRARY_ELEMENT_INPUT_NAME:
           new ListToMapTaskInput<Source, LibraryElement>(
-              EXPORTED_LIBRARIES.inputFor(source),
+              EXPORTED_LIBRARIES.inputFor(libSource),
               (Source source) => LIBRARY_ELEMENT1.inputFor(source)),
       IMPORTS_SOURCE_KIND_INPUT_NAME:
           new ListToMapTaskInput<Source, SourceKind>(
-              IMPORTED_LIBRARIES.inputFor(source),
+              IMPORTED_LIBRARIES.inputFor(libSource),
               (Source source) => SOURCE_KIND.inputFor(source)),
       EXPORTS_SOURCE_KIND_INPUT_NAME:
           new ListToMapTaskInput<Source, SourceKind>(
-              EXPORTED_LIBRARIES.inputFor(source),
+              EXPORTED_LIBRARIES.inputFor(libSource),
               (Source source) => SOURCE_KIND.inputFor(source))
     };
   }
 
   /**
    * Create a [BuildDirectiveElementsTask] based on the given [target] in
    * the given [context].
    */
   static BuildDirectiveElementsTask createTask(
       AnalysisContext context, AnalysisTarget target) {
@@ skipping 35 matching lines @@
  * A task that builds the elements representing the members of enum
  * declarations.
  */
 class BuildEnumMemberElementsTask extends SourceBasedAnalysisTask {
   /**
    * The name of the [TYPE_PROVIDER] input.
    */
   static const String TYPE_PROVIDER_INPUT = 'TYPE_PROVIDER_INPUT';
 
   /**
-   * The name of the [RESOLVED_UNIT3] input.
+   * The name of the [RESOLVED_UNIT1] input.
    */
   static const String UNIT_INPUT = 'UNIT_INPUT';
 
   /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'BuildEnumMemberElementsTask', createTask, buildInputs,
-      <ResultDescriptor>[RESOLVED_UNIT4]);
+      <ResultDescriptor>[RESOLVED_UNIT2]);
 
   BuildEnumMemberElementsTask(
       InternalAnalysisContext context, AnalysisTarget target)
       : super(context, target);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
     //
     // Prepare inputs.
     //
     TypeProvider typeProvider = getRequiredInput(TYPE_PROVIDER_INPUT);
     CompilationUnit unit = getRequiredInput(UNIT_INPUT);
     //
     // Record outputs.
     //
     EnumMemberBuilder builder = new EnumMemberBuilder(typeProvider);
     unit.accept(builder);
-    outputs[RESOLVED_UNIT4] = unit;
+    outputs[RESOLVED_UNIT2] = 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(AnalysisTarget target) {
+  static Map<String, TaskInput> buildInputs(LibraryUnitTarget target) {
     return <String, TaskInput>{
       TYPE_PROVIDER_INPUT:
           TYPE_PROVIDER.inputFor(AnalysisContextTarget.request),
-      UNIT_INPUT: RESOLVED_UNIT3.inputFor(target)
+      UNIT_INPUT: RESOLVED_UNIT1.inputFor(target)
     };
   }
 
   /**
    * Create a [BuildEnumMemberElementsTask] based on the given [target] in
    * the given [context].
    */
   static BuildEnumMemberElementsTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new BuildEnumMemberElementsTask(context, target);
@@ skipping 43 matching lines @@
     }
     //
     // Record outputs.
     //
     outputs[LIBRARY_ELEMENT4] = 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 library [source].
+   * given library [libSource].
    */
-  static Map<String, TaskInput> buildInputs(Source source) {
+  static Map<String, TaskInput> buildInputs(Source libSource) {
     return <String, TaskInput>{
-      LIBRARY_INPUT: LIBRARY_ELEMENT3.inputFor(source),
+      LIBRARY_INPUT: LIBRARY_ELEMENT3.inputFor(libSource),
       'exportsLibraryPublicNamespace':
           new ListToMapTaskInput<Source, LibraryElement>(
-              EXPORT_SOURCE_CLOSURE.inputFor(source),
+              EXPORT_SOURCE_CLOSURE.inputFor(libSource),
               (Source source) => LIBRARY_ELEMENT3.inputFor(source))
     };
   }
 
   /**
    * Create a [BuildExportNamespaceTask] based on the given [target] in
    * the given [context].
    */
   static BuildExportNamespaceTask createTask(
       AnalysisContext context, AnalysisTarget target) {
@@ skipping 35 matching lines @@
     List<Source> sources = libraries.map((lib) => lib.source).toList();
     //
     // Record outputs.
     //
     outputs[EXPORT_SOURCE_CLOSURE] = sources;
   }
 
   /**
    * 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 [source].
+   * given library [libSource].
    */
-  static Map<String, TaskInput> buildInputs(Source source) {
+  static Map<String, TaskInput> buildInputs(Source libSource) {
     return <String, TaskInput>{
-      LIBRARY2_ELEMENT_INPUT: LIBRARY_ELEMENT2.inputFor(source)
+      LIBRARY2_ELEMENT_INPUT: LIBRARY_ELEMENT2.inputFor(libSource)
     };
   }
 
   /**
    * Create a [BuildExportSourceClosureTask] based on the given [target] in
    * the given [context].
    */
   static BuildExportSourceClosureTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new BuildExportSourceClosureTask(context, target);
   }
 
   /**
    * Create a set representing the export closure of the given [library].
    */
   static void _buildExportClosure(
       Set<LibraryElement> libraries, LibraryElement library) {
     if (library != null && libraries.add(library)) {
       for (ExportElement exportElement in library.exports) {
         _buildExportClosure(libraries, exportElement.exportedLibrary);
       }
     }
   }
 }
 
 /**
- * A task that builds [RESOLVED_UNIT5] for a unit.
+ * A task that builds [RESOLVED_UNIT3] for a unit.
  */
 class BuildFunctionTypeAliasesTask extends SourceBasedAnalysisTask {
   /**
    * The name of the [TYPE_PROVIDER] input.
    */
   static const String TYPE_PROVIDER_INPUT = 'TYPE_PROVIDER_INPUT';
 
   /**
-   * The name of the [RESOLVED_UNIT3] input.
+   * The name of the [LIBRARY_ELEMENT4] input.
+   */
+  static const String LIBRARY_INPUT = 'LIBRARY_INPUT';
+
+  /**
+   * The name of the [RESOLVED_UNIT2] input.
    */
   static const String UNIT_INPUT = 'UNIT_INPUT';
 
   /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'BuildFunctionTypeAliasesTask', createTask, buildInputs,
-      <ResultDescriptor>[BUILD_FUNCTION_TYPE_ALIASES_ERRORS, RESOLVED_UNIT5]);
+      <ResultDescriptor>[BUILD_FUNCTION_TYPE_ALIASES_ERRORS, RESOLVED_UNIT3]);
 
   BuildFunctionTypeAliasesTask(
       InternalAnalysisContext context, AnalysisTarget target)
       : super(context, target);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
     RecordingErrorListener errorListener = new RecordingErrorListener();
     //
     // Prepare inputs.
     //
     Source source = getRequiredSource();
     TypeProvider typeProvider = getRequiredInput(TYPE_PROVIDER_INPUT);
     CompilationUnit unit = getRequiredInput(UNIT_INPUT);
-    LibraryElement libraryElement = unit.element.library;
+    LibraryElement libraryElement = getRequiredInput(LIBRARY_INPUT);
     //
     // Resolve FunctionTypeAlias declarations.
     //
     TypeResolverVisitor visitor = new TypeResolverVisitor.con2(
         libraryElement, source, typeProvider, errorListener);
     for (CompilationUnitMember member in unit.declarations) {
       if (member is FunctionTypeAlias) {
         member.accept(visitor);
       }
     }
     //
     // Record outputs.
     //
     outputs[BUILD_FUNCTION_TYPE_ALIASES_ERRORS] = errorListener.errors;
-    outputs[RESOLVED_UNIT5] = unit;
+    outputs[RESOLVED_UNIT3] = 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(LibraryUnitTarget target) {
     return <String, TaskInput>{
       TYPE_PROVIDER_INPUT:
           TYPE_PROVIDER.inputFor(AnalysisContextTarget.request),
       'importsExportNamespace': new ListToMapTaskInput<Source, LibraryElement>(
           IMPORTED_LIBRARIES.inputFor(target.library),
           (Source importSource) => LIBRARY_ELEMENT4.inputFor(importSource)),
-      UNIT_INPUT: RESOLVED_UNIT4.inputFor(target.unit)
+      LIBRARY_INPUT: LIBRARY_ELEMENT4.inputFor(target.library),
+      UNIT_INPUT: RESOLVED_UNIT2.inputFor(target)
     };
   }
 
   /**
    * Create a [BuildFunctionTypeAliasesTask] based on the given [target] in
    * the given [context].
    */
   static BuildFunctionTypeAliasesTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new BuildFunctionTypeAliasesTask(context, target);
   }
 }
 
 /**
  * A task that builds a library element for a Dart library.
  */
 class BuildLibraryElementTask extends SourceBasedAnalysisTask {
   /**
    * The name of the input whose value is the defining [RESOLVED_UNIT1].
    */
-  static const String DEFINING_RESOLVER_UNIT1_INPUT_NAME =
-      'DEFINING_RESOLVER_UNIT1_INPUT_NAME';
+  static const String DEFINING_UNIT_INPUT = 'DEFINING_UNIT_INPUT';
 
   /**
    * The name of the input whose value is a list of built [RESOLVED_UNIT1]s
    * of the parts sourced by a library.
    */
-  static const String PARTS_RESOLVED_UNIT1_INPUT_NAME =
-      'PARTS_RESOLVED_UNIT1_INPUT_NAME';
+  static const String PARTS_UNIT_INPUT = 'PARTS_UNIT_INPUT';
 
   /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
-      'BUILD_LIBRARY_ELEMENT', createTask, buildInputs, <ResultDescriptor>[
+      'BuildLibraryElementTask', createTask, buildInputs, <ResultDescriptor>[
     BUILD_LIBRARY_ERRORS,
-    RESOLVED_UNIT2,
     LIBRARY_ELEMENT1,
     IS_LAUNCHABLE,
     HAS_HTML_IMPORT
   ]);
 
   /**
    * The constant used as an unknown common library name in parts.
    */
   static const String _UNKNOWN_LIBRARY_NAME = 'unknown-library-name';
 
   /**
    * Initialize a newly created task to build a library element for the given
    * [target] in the given [context].
    */
   BuildLibraryElementTask(
       InternalAnalysisContext context, AnalysisTarget target)
       : super(context, target);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
     List<AnalysisError> errors = <AnalysisError>[];
     //
     // Prepare inputs.
     //
     Source librarySource = getRequiredSource();
     CompilationUnit definingCompilationUnit =
-        getRequiredInput(DEFINING_RESOLVER_UNIT1_INPUT_NAME);
-    List<CompilationUnit> partUnits =
-        getRequiredInput(PARTS_RESOLVED_UNIT1_INPUT_NAME);
+        getRequiredInput(DEFINING_UNIT_INPUT);
+    List<CompilationUnit> partUnits = getRequiredInput(PARTS_UNIT_INPUT);
     //
     // Process inputs.
     //
     CompilationUnitElementImpl definingCompilationUnitElement =
         definingCompilationUnit.element;
     Map<Source, CompilationUnit> partUnitMap =
         new HashMap<Source, CompilationUnit>();
     for (CompilationUnit partUnit in partUnits) {
       Source partSource = partUnit.element.source;
       partUnitMap[partSource] = partUnit;
@@ skipping 85 matching lines @@
     for (Directive directive in directivesToResolve) {
       directive.element = libraryElement;
     }
     if (sourcedCompilationUnits.isNotEmpty) {
       _patchTopLevelAccessors(libraryElement);
     }
     //
     // Record outputs.
     //
     outputs[BUILD_LIBRARY_ERRORS] = errors;
-    outputs[RESOLVED_UNIT2] = definingCompilationUnit;
     outputs[LIBRARY_ELEMENT1] = libraryElement;
     outputs[IS_LAUNCHABLE] = entryPoint != null;
     outputs[HAS_HTML_IMPORT] = hasHtmlImport;
   }
 
   /**
    * Add all of the non-synthetic [getters] and [setters] defined in the given
    * [unit] that have no corresponding accessor to one of the given collections.
    */
   void _collectAccessors(Map<String, PropertyAccessorElement> getters,
@@ skipping 65 matching lines @@
         setterUnit.replaceTopLevelVariable(setterVariable, variable);
         variable.setter = setter;
         setter.variable = variable;
       }
     }
   }
 
   /**
    * 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
-   * [librarySource].
+   * [libSource].
    */
-  static Map<String, TaskInput> buildInputs(Source librarySource) {
+  static Map<String, TaskInput> buildInputs(Source libSource) {
     return <String, TaskInput>{
-      DEFINING_RESOLVER_UNIT1_INPUT_NAME: RESOLVED_UNIT1
-          .inputFor(new LibraryUnitTarget(librarySource, librarySource)),
-      PARTS_RESOLVED_UNIT1_INPUT_NAME:
-          new ListToListTaskInput<Source, CompilationUnit>(
-              INCLUDED_PARTS.inputFor(librarySource),
-              (Source source) => RESOLVED_UNIT1
-                  .inputFor(new LibraryUnitTarget(librarySource, source)))
+      DEFINING_UNIT_INPUT:
+          RESOLVED_UNIT1.inputFor(new LibraryUnitTarget(libSource, libSource)),
+      PARTS_UNIT_INPUT: new ListToListTaskInput<Source, CompilationUnit>(
+          INCLUDED_PARTS.inputFor(libSource), (Source source) =>
+              RESOLVED_UNIT1.inputFor(new LibraryUnitTarget(libSource, source)))
     };
   }
 
   /**
    * Create a [BuildLibraryElementTask] based on the given [target] in the
    * given [context].
    */
   static BuildLibraryElementTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new BuildLibraryElementTask(context, target);
@@ skipping 26 matching lines @@
   @override
   void internalPerform() {
     LibraryElementImpl library = getRequiredInput(LIBRARY_INPUT);
     library.publicNamespace = new PublicNamespaceBuilder().build(library);
     outputs[LIBRARY_ELEMENT3] = 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 library [source].
+   * given library [libSource].
    */
-  static Map<String, TaskInput> buildInputs(Source source) {
+  static Map<String, TaskInput> buildInputs(Source libSource) {
     return <String, TaskInput>{
-      LIBRARY_INPUT: LIBRARY_ELEMENT2.inputFor(source)
+      LIBRARY_INPUT: LIBRARY_ELEMENT2.inputFor(libSource)
     };
   }
 
   /**
    * Create a [BuildPublicNamespaceTask] based on the given [target] in
    * the given [context].
    */
   static BuildPublicNamespaceTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new BuildPublicNamespaceTask(context, target);
@@ skipping 201 matching lines @@
   static const String LINE_INFO_INPUT_NAME = 'LINE_INFO_INPUT_NAME';
 
   /**
    * 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('PARSE_DART',
+  static final TaskDescriptor DESCRIPTOR = new TaskDescriptor('ParseDartTask',
       createTask, buildInputs, <ResultDescriptor>[
     EXPORTED_LIBRARIES,
     IMPORTED_LIBRARIES,
     INCLUDED_PARTS,
     PARSE_ERRORS,
     PARSED_UNIT,
     SOURCE_KIND
   ]);
 
   /**
@@ skipping 168 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 builds [RESOLVED_UNIT6] for a unit.
+ * An artifitial task that does nothing exept of forcing type names resolution

[Brian Wilkerson, 2015/03/20 21:57:41]

"exept of forcing type names" --> "except to force type name"

+ * for the defining and part units of a library.
  */
-class ResolveTypeNamesTask extends SourceBasedAnalysisTask {
+class ResolveLibraryTypeNamesTask extends SourceBasedAnalysisTask {
   /**
-   * The name of the [RESOLVED_UNIT5] input.
+   * The name of the [LIBRARY_ELEMENT4] input.
+   */
+  static const String LIBRARY_INPUT = 'LIBRARY_INPUT';
+
+  /**
+   * The task descriptor describing this kind of task.
+   */
+  static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
+      'ResolveLibraryTypeNamesTask', createTask, buildInputs,
+      <ResultDescriptor>[LIBRARY_ELEMENT5]);
+
+  ResolveLibraryTypeNamesTask(
+      InternalAnalysisContext context, AnalysisTarget target)
+      : super(context, target);
+
+  @override
+  TaskDescriptor get descriptor => DESCRIPTOR;
+
+  @override
+  void internalPerform() {
+    LibraryElement library = getRequiredInput(LIBRARY_INPUT);
+    outputs[LIBRARY_ELEMENT5] = 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_ELEMENT4.inputFor(libSource),
+      'resolvedDefiningUnit':
+          RESOLVED_UNIT4.inputFor(new LibraryUnitTarget(libSource, libSource)),
+      'resolvedPartsUnit': new ListToMapTaskInput<Source, CompilationUnit>(
+          INCLUDED_PARTS.inputFor(libSource), (Source source) => RESOLVED_UNIT4
+              .inputFor(new LibraryUnitTarget(libSource, source))),
+    };
+  }
+
+  /**
+   * Create a [ResolveLibraryTypeNamesTask] based on the given [target] in
+   * the given [context].
+   */
+  static ResolveLibraryTypeNamesTask createTask(
+      AnalysisContext context, AnalysisTarget target) {
+    return new ResolveLibraryTypeNamesTask(context, target);
+  }
+}
+
+/**
+ * A task that builds [RESOLVED_UNIT4] for a unit.
+ */
+class ResolveUnitTypeNamesTask extends SourceBasedAnalysisTask {
+  /**
+   * The name of the [RESOLVED_UNIT3] input.
    */
   static const String UNIT_INPUT = 'UNIT_INPUT';
 
   /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
-      'ResolveTypeNamesTask', createTask, buildInputs, <ResultDescriptor>[
+      'ResolveUnitTypeNamesTask', createTask, buildInputs, <ResultDescriptor>[
     RESOLVE_TYPE_NAMES_ERRORS,
-    RESOLVED_UNIT6
+    RESOLVED_UNIT4
   ]);
 
-  ResolveTypeNamesTask(InternalAnalysisContext context, AnalysisTarget target)
+  ResolveUnitTypeNamesTask(
+      InternalAnalysisContext context, AnalysisTarget target)
       : super(context, target);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
     RecordingErrorListener errorListener = new RecordingErrorListener();
     //
     // Prepare inputs.
     //
     CompilationUnit unit = getRequiredInput(UNIT_INPUT);
     CompilationUnitElement unitElement = unit.element;
     //
     // Resolve TypeName nodes.
     //
     TypeResolverVisitor visitor = new TypeResolverVisitor.con2(
         unitElement.library, unitElement.source, context.typeProvider,
         errorListener);
     unit.accept(visitor);
     //
     // Record outputs.
     //
     outputs[RESOLVE_TYPE_NAMES_ERRORS] = errorListener.errors;
-    outputs[RESOLVED_UNIT6] = unit;
+    outputs[RESOLVED_UNIT4] = 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(LibraryUnitTarget target) {
-    return <String, TaskInput>{UNIT_INPUT: RESOLVED_UNIT5.inputFor(target)};
+    return <String, TaskInput>{UNIT_INPUT: RESOLVED_UNIT3.inputFor(target)};
   }
 
   /**
-   * Create a [ResolveTypeNamesTask] based on the given [target] in
+   * Create a [ResolveUnitTypeNamesTask] based on the given [target] in
    * the given [context].
    */
-  static ResolveTypeNamesTask createTask(
+  static ResolveUnitTypeNamesTask createTask(
       AnalysisContext context, AnalysisTarget target) {
-    return new ResolveTypeNamesTask(context, target);
+    return new ResolveUnitTypeNamesTask(context, target);
   }
 }
 
 /**
  * A task that scans the content of a file, producing a set of Dart tokens.
  */
 class ScanDartTask extends SourceBasedAnalysisTask {
   /**
    * The name of the input whose value is the content of the file.
    */
   static const String CONTENT_INPUT_NAME = 'CONTENT_INPUT_NAME';
 
   /**
    * The task descriptor describing this kind of task.
    */
-  static final TaskDescriptor DESCRIPTOR = new TaskDescriptor('SCAN_DART',
+  static final TaskDescriptor DESCRIPTOR = new TaskDescriptor('ScanDartTask',
       createTask, buildInputs, <ResultDescriptor>[
     LINE_INFO,
     SCAN_ERRORS,
     TOKEN_STREAM
   ]);
 
   /**
    * Initialize a newly created task to access the content of the source
    * associated with the given [target] in the given [context].
    */
@@ skipping 27 matching lines @@
   }
 
   /**
    * Create a [ScanDartTask] based on the given [target] in the given [context].
    */
   static ScanDartTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new ScanDartTask(context, target);
   }
 }