Start analyzing LibraryUnitTarget(s) from BuildLibraryElementTask.

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';
 import 'package:analyzer/src/generated/engine.dart' hide AnalysisTask;
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/parser.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/source.dart';
+import 'package:analyzer/src/generated/utilities_general.dart';
 import 'package:analyzer/src/task/driver.dart';
 import 'package:analyzer/src/task/general.dart';
 import 'package:analyzer/src/task/inputs.dart';
 import 'package:analyzer/task/dart.dart';
 import 'package:analyzer/task/general.dart';
 import 'package:analyzer/task/model.dart';
 
 /**
  * The errors produced while resolving a library directives.
  *
@@ skipping 103 matching lines @@
    */
   BuildCompilationUnitElementTask(
       InternalAnalysisContext context, AnalysisTarget target)
       : super(context, target);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
+    //
+    // Prepare inputs.
+    //
     Source source = getRequiredSource();
     CompilationUnit unit = getRequiredInput(PARSED_UNIT_INPUT_NAME);
-
+    //
+    // Process inputs.
+    //
+    unit = AstCloner.clone(unit);
     CompilationUnitBuilder builder = new CompilationUnitBuilder();
     CompilationUnitElement element = builder.buildCompilationUnit(source, unit);
-
+    //
+    // Record outputs.
+    //
     outputs[COMPILATION_UNIT_ELEMENT] = element;
     outputs[RESOLVED_UNIT1] = 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].
+   * 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>{
-      PARSED_UNIT_INPUT_NAME: PARSED_UNIT.inputFor(target)
+      PARSED_UNIT_INPUT_NAME: PARSED_UNIT.inputFor(target.unit)
     };
   }
 
   /**
    * Create a [BuildCompilationUnitElementTask] based on the given [target] in
    * the given [context].
    */
   static BuildCompilationUnitElementTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new BuildCompilationUnitElementTask(context, target);
@@ skipping 182 matching lines @@
     //
     // Record outputs.
     //
     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 [target].
+   * given library [source].
    */
-  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+  static Map<String, TaskInput> buildInputs(Source source) {
     return <String, TaskInput>{
-      RESOLVED_UNIT2_INPUT_NAME: RESOLVED_UNIT2.inputFor(target),
+      RESOLVED_UNIT2_INPUT_NAME: RESOLVED_UNIT2.inputFor(source),
       IMPORTS_LIBRARY_ELEMENT1_INPUT_NAME:
           new ListToMapTaskInput<Source, LibraryElement>(
-              IMPORTED_LIBRARIES.inputFor(target),
+              IMPORTED_LIBRARIES.inputFor(source),
               (Source source) => LIBRARY_ELEMENT1.inputFor(source)),
       EXPORTS_LIBRARY_ELEMENT1_INPUT_NAME:
           new ListToMapTaskInput<Source, LibraryElement>(
-              EXPORTED_LIBRARIES.inputFor(target),
+              EXPORTED_LIBRARIES.inputFor(source),
               (Source source) => LIBRARY_ELEMENT1.inputFor(source)),
       IMPORTS_SOURCE_KIND_INPUT_NAME:
           new ListToMapTaskInput<Source, SourceKind>(
-              IMPORTED_LIBRARIES.inputFor(target),
+              IMPORTED_LIBRARIES.inputFor(source),
               (Source source) => SOURCE_KIND.inputFor(source)),
       EXPORTS_SOURCE_KIND_INPUT_NAME:
           new ListToMapTaskInput<Source, SourceKind>(
-              EXPORTED_LIBRARIES.inputFor(target),
+              EXPORTED_LIBRARIES.inputFor(source),
               (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 338 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
-   * [target].
+   * [librarySource].
    */
-  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+  static Map<String, TaskInput> buildInputs(Source librarySource) {
     return <String, TaskInput>{
-      DEFINING_RESOLVER_UNIT1_INPUT_NAME:
-          new SimpleTaskInput(target, RESOLVED_UNIT1),
+      DEFINING_RESOLVER_UNIT1_INPUT_NAME: RESOLVED_UNIT1
+          .inputFor(new LibraryUnitTarget(librarySource, librarySource)),
       PARTS_RESOLVED_UNIT1_INPUT_NAME:
           new ListToListTaskInput<Source, CompilationUnit>(
-              INCLUDED_PARTS.inputFor(target),
-              (Source source) => RESOLVED_UNIT1.inputFor(source))
+              INCLUDED_PARTS.inputFor(librarySource),
+              (Source source) => RESOLVED_UNIT1
+                  .inputFor(new LibraryUnitTarget(librarySource, 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 30 matching lines @@
 
     NamespaceBuilder builder = new NamespaceBuilder();
     Namespace namespace = builder.createPublicNamespaceForLibrary(library);
 
     outputs[PUBLIC_NAMESPACE] = namespace;
   }
 
   /**
    * 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].
+   * given library [source].
    */
-  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+  static Map<String, TaskInput> buildInputs(Source source) {
     return <String, TaskInput>{
-      BUILT_LIBRARY_ELEMENT_INPUT_NAME: LIBRARY_ELEMENT1.inputFor(target)
+      BUILT_LIBRARY_ELEMENT_INPUT_NAME: LIBRARY_ELEMENT1.inputFor(source)
     };
   }
 
   /**
    * 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 55 matching lines @@
   /**
    * Create a [BuildTypeProviderTask] based on the given [context].
    */
   static BuildTypeProviderTask createTask(
       AnalysisContext context, AnalysisContextTarget target) {
     return new BuildTypeProviderTask(context, target);
   }
 }
 
 /**
+ * A pair of a library [Source] and a unit [Source] in this library.
+ */
+class LibraryUnitTarget implements AnalysisTarget {
+  final Source library;
+  final Source unit;
+  LibraryUnitTarget(this.library, this.unit);
+
+  @override
+  int get hashCode {
+    return JenkinsSmiHash.combine(library.hashCode, unit.hashCode);
+  }
+
+  @override
+  Source get source => unit;
+
+  @override
+  bool operator ==(other) {
+    return other is LibraryUnitTarget &&
+        other.library == library &&
+        other.unit == unit;
+  }
+}
+
+/**
  * A task that parses the content of a Dart file, producing an AST structure.
  */
 class ParseDartTask extends SourceBasedAnalysisTask {
   /**
    * The name of the input whose value is the line information produced for the
    * file.
    */
   static const String LINE_INFO_INPUT_NAME = 'LINE_INFO_INPUT_NAME';
 
   /**
@@ skipping 85 matching lines @@
     outputs[EXPORTED_LIBRARIES] = exportedSources.toList();
     outputs[IMPORTED_LIBRARIES] = importedSources.toList();
     outputs[INCLUDED_PARTS] = includedSources.toList();
     outputs[PARSE_ERRORS] = errorListener.getErrorsForSource(source);
     outputs[PARSED_UNIT] = unit;
     outputs[SOURCE_KIND] = sourceKind;
   }
 
   /**
    * 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].
+   * input descriptors describing those inputs for a task with the given
+   * [source].
    */
-  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+  static Map<String, TaskInput> buildInputs(Source source) {
     return <String, TaskInput>{
-      LINE_INFO_INPUT_NAME: LINE_INFO.inputFor(target),
-      TOKEN_STREAM_INPUT_NAME: TOKEN_STREAM.inputFor(target)
+      LINE_INFO_INPUT_NAME: LINE_INFO.inputFor(source),
+      TOKEN_STREAM_INPUT_NAME: TOKEN_STREAM.inputFor(source)
     };
   }
 
   /**
    * Create a [ParseDartTask] based on the given [target] in the given
    * [context].
    */
   static ParseDartTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new ParseDartTask(context, target);
@@ skipping 79 matching lines @@
     Scanner scanner =
         new Scanner(source, new CharSequenceReader(content), errorListener);
     scanner.preserveComments = context.analysisOptions.preserveComments;
     outputs[TOKEN_STREAM] = scanner.tokenize();
     outputs[LINE_INFO] = new LineInfo(scanner.lineStarts);
     outputs[SCAN_ERRORS] = errorListener.getErrorsForSource(source);
   }
 
   /**
    * 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].
+   * input descriptors describing those inputs for a task with the given
+   * [source].
    */
-  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
-    return <String, TaskInput>{CONTENT_INPUT_NAME: CONTENT.inputFor(target)};
+  static Map<String, TaskInput> buildInputs(Source source) {
+    return <String, TaskInput>{CONTENT_INPUT_NAME: CONTENT.inputFor(source)};
   }
 
   /**
    * Create a [ScanDartTask] based on the given [target] in the given [context].
    */
   static ScanDartTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new ScanDartTask(context, target);
   }
 }