Next steps toward HTML support

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';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart'
     hide AnalysisCache, AnalysisTask;
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/error_verifier.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/task/driver.dart';
 import 'package:analyzer/src/task/general.dart';
+import 'package:analyzer/src/task/html.dart';
 import 'package:analyzer/src/task/inputs.dart';
 import 'package:analyzer/src/task/model.dart';
 import 'package:analyzer/task/dart.dart';
 import 'package:analyzer/task/general.dart';
 import 'package:analyzer/task/model.dart';
 
 /**
  * The [ResultCachingPolicy] for ASTs.
  */
 const ResultCachingPolicy AST_CACHING_POLICY =
@@ skipping 500 matching lines @@
       outputs[CONSTRUCTORS] = classElement.constructors;
       outputs[CONSTRUCTORS_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 [classElement].
    */
-  static Map<String, TaskInput> buildInputs(ClassElement classElement) {
-    Source librarySource = classElement.library.source;
-    DartType superType = classElement.supertype;
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+    ClassElement element = target;
+    Source librarySource = element.library.source;
+    DartType superType = element.supertype;
     if (superType is InterfaceType) {
-      if (classElement.isMixinApplication || classElement.mixins.isNotEmpty) {
+      if (element.isMixinApplication || element.mixins.isNotEmpty) {
         ClassElement superElement = superType.element;
         return <String, TaskInput>{
           'libraryDep': LIBRARY_ELEMENT5.of(librarySource),
           SUPER_CONSTRUCTORS: CONSTRUCTORS.of(superElement)
         };
       }
     }
     // No implicit constructors.
     // Depend on LIBRARY_ELEMENT5 for invalidation.
     return <String, TaskInput>{
@@ skipping 183 matching lines @@
     outputs[COMPILATION_UNIT_ELEMENT] = element;
     outputs[RESOLVED_UNIT1] = unit;
     outputs[COMPILATION_UNIT_CONSTANTS] = constants;
   }
 
   /**
    * 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) {
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+    LibrarySpecificUnit unit = target;
     return <String, TaskInput>{
-      PARSED_UNIT_INPUT_NAME: PARSED_UNIT.of(target.unit)
+      PARSED_UNIT_INPUT_NAME: PARSED_UNIT.of(unit.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 178 matching lines @@
     //
     outputs[LIBRARY_ELEMENT2] = libraryElement;
     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 [libSource].
    */
-  static Map<String, TaskInput> buildInputs(Source libSource) {
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+    Source source = target;
     return <String, TaskInput>{
-      LIBRARY_INPUT: LIBRARY_ELEMENT1.of(libSource),
+      LIBRARY_INPUT: LIBRARY_ELEMENT1.of(source),
       UNIT_INPUT_NAME:
-          RESOLVED_UNIT1.of(new LibrarySpecificUnit(libSource, libSource)),
+          RESOLVED_UNIT1.of(new LibrarySpecificUnit(source, source)),
       IMPORTS_LIBRARY_ELEMENT_INPUT_NAME:
-          IMPORTED_LIBRARIES.of(libSource).toMapOf(LIBRARY_ELEMENT1),
+          IMPORTED_LIBRARIES.of(source).toMapOf(LIBRARY_ELEMENT1),
       EXPORTS_LIBRARY_ELEMENT_INPUT_NAME:
-          EXPORTED_LIBRARIES.of(libSource).toMapOf(LIBRARY_ELEMENT1),
+          EXPORTED_LIBRARIES.of(source).toMapOf(LIBRARY_ELEMENT1),
       IMPORTS_SOURCE_KIND_INPUT_NAME:
-          IMPORTED_LIBRARIES.of(libSource).toMapOf(SOURCE_KIND),
+          IMPORTED_LIBRARIES.of(source).toMapOf(SOURCE_KIND),
       EXPORTS_SOURCE_KIND_INPUT_NAME:
-          EXPORTED_LIBRARIES.of(libSource).toMapOf(SOURCE_KIND)
+          EXPORTED_LIBRARIES.of(source).toMapOf(SOURCE_KIND)
     };
   }
 
   /**
    * Create a [BuildDirectiveElementsTask] based on the given [target] in
    * the given [context].
    */
   static BuildDirectiveElementsTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new BuildDirectiveElementsTask(context, target);
@@ skipping 72 matching lines @@
     EnumMemberBuilder builder = new EnumMemberBuilder(typeProvider);
     unit.accept(builder);
     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(LibrarySpecificUnit target) {
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+    LibrarySpecificUnit unit = target;
     return <String, TaskInput>{
       TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request),
-      UNIT_INPUT: RESOLVED_UNIT1.of(target)
+      UNIT_INPUT: RESOLVED_UNIT1.of(unit)
     };
   }
 
   /**
    * 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 45 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 [libSource].
    */
-  static Map<String, TaskInput> buildInputs(Source libSource) {
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+    Source source = target;
     return <String, TaskInput>{
-      LIBRARY_INPUT: LIBRARY_ELEMENT3.of(libSource),
+      LIBRARY_INPUT: LIBRARY_ELEMENT3.of(source),
       'exportsLibraryPublicNamespace':
-          EXPORT_SOURCE_CLOSURE.of(libSource).toMapOf(LIBRARY_ELEMENT3)
+          EXPORT_SOURCE_CLOSURE.of(source).toMapOf(LIBRARY_ELEMENT3)
     };
   }
 
   /**
    * Create a [BuildExportNamespaceTask] based on the given [target] in
    * the given [context].
    */
   static BuildExportNamespaceTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new BuildExportNamespaceTask(context, target);
@@ skipping 60 matching lines @@
         removeDuplicateErrors(errorListener.errors);
     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(LibrarySpecificUnit target) {
+    LibrarySpecificUnit unit = target;
     return <String, TaskInput>{
       TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request),
       'importsExportNamespace':
-          IMPORTED_LIBRARIES.of(target.library).toMapOf(LIBRARY_ELEMENT4),
-      LIBRARY_INPUT: LIBRARY_ELEMENT4.of(target.library),
-      UNIT_INPUT: RESOLVED_UNIT2.of(target)
+          IMPORTED_LIBRARIES.of(unit.library).toMapOf(LIBRARY_ELEMENT4),
+      LIBRARY_INPUT: LIBRARY_ELEMENT4.of(unit.library),
+      UNIT_INPUT: RESOLVED_UNIT2.of(unit)
     };
   }
 
   /**
    * Create a [BuildFunctionTypeAliasesTask] based on the given [target] in
    * the given [context].
    */
   static BuildFunctionTypeAliasesTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new BuildFunctionTypeAliasesTask(context, target);
@@ skipping 28 matching lines @@
   void internalPerform() {
     LibraryElement library = getRequiredInput(LIBRARY_INPUT);
     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) {
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+    Source source = target;
     return <String, TaskInput>{
-      LIBRARY_INPUT: LIBRARY_ELEMENT5.of(libSource),
-      'resolvedConstructors':
-          CLASS_ELEMENTS.of(libSource).toListOf(CONSTRUCTORS),
+      LIBRARY_INPUT: LIBRARY_ELEMENT5.of(source),
+      'resolvedConstructors': CLASS_ELEMENTS.of(source).toListOf(CONSTRUCTORS),
     };
   }
 
   /**
    * Create a [BuildLibraryConstructorsTask] based on the given [target] in
    * the given [context].
    */
   static BuildLibraryConstructorsTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new BuildLibraryConstructorsTask(context, target);
@@ skipping 247 matching lines @@
         (setter as PropertyAccessorElementImpl).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
    * [libSource].
    */
-  static Map<String, TaskInput> buildInputs(Source libSource) {
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+    Source source = target;
     return <String, TaskInput>{
       DEFINING_UNIT_INPUT:
-          RESOLVED_UNIT1.of(new LibrarySpecificUnit(libSource, libSource)),
-      PARTS_UNIT_INPUT: INCLUDED_PARTS.of(libSource).toList((Source unit) {
-        return RESOLVED_UNIT1.of(new LibrarySpecificUnit(libSource, unit));
+          RESOLVED_UNIT1.of(new LibrarySpecificUnit(source, source)),
+      PARTS_UNIT_INPUT: INCLUDED_PARTS.of(source).toList((Source unit) {
+        return RESOLVED_UNIT1.of(new LibrarySpecificUnit(source, unit));
       })
     };
   }
 
   /**
    * Create a [BuildLibraryElementTask] based on the given [target] in the
    * given [context].
    */
   static BuildLibraryElementTask createTask(
       AnalysisContext context, AnalysisTarget target) {
@@ skipping 29 matching lines @@
     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 [libSource].
    */
-  static Map<String, TaskInput> buildInputs(Source libSource) {
-    return <String, TaskInput>{LIBRARY_INPUT: LIBRARY_ELEMENT2.of(libSource)};
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+    Source source = target;
+    return <String, TaskInput>{LIBRARY_INPUT: LIBRARY_ELEMENT2.of(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 50 matching lines @@
     outputs[EXPORT_SOURCE_CLOSURE] = exportClosure;
     outputs[IMPORT_EXPORT_SOURCE_CLOSURE] = importExportClosure;
     outputs[IS_CLIENT] = importExportClosure.contains(htmlSource);
   }
 
   /**
    * 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 [libSource].
    */
-  static Map<String, TaskInput> buildInputs(Source libSource) {
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+    Source source = target;
     return <String, TaskInput>{
-      IMPORT_INPUT: new _ImportSourceClosureTaskInput(libSource),
-      EXPORT_INPUT: new _ExportSourceClosureTaskInput(libSource),
-      IMPORT_EXPORT_INPUT: new _ImportExportSourceClosureTaskInput(libSource)
+      IMPORT_INPUT: new _ImportSourceClosureTaskInput(source),
+      EXPORT_INPUT: new _ExportSourceClosureTaskInput(source),
+      IMPORT_EXPORT_INPUT: new _ImportExportSourceClosureTaskInput(source)
     };
   }
 
   /**
    * Create a [BuildSourceClosuresTask] based on the given [target] in
    * the given [context].
    */
   static BuildSourceClosuresTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new BuildSourceClosuresTask(context, target);
@@ skipping 36 matching lines @@
     Namespace asyncNamespace = asyncLibrary.publicNamespace;
     //
     // Record outputs.
     //
     TypeProvider typeProvider =
         new TypeProviderImpl.forNamespaces(coreNamespace, asyncNamespace);
     (context as InternalAnalysisContext).typeProvider = typeProvider;
     outputs[TYPE_PROVIDER] = typeProvider;
   }
 
-  static Map<String, TaskInput> buildInputs(AnalysisContextTarget target) {
-    SourceFactory sourceFactory = target.context.sourceFactory;
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+    AnalysisContextTarget contextTarget = target;
+    SourceFactory sourceFactory = contextTarget.context.sourceFactory;
     Source coreSource = sourceFactory.forUri(DartSdk.DART_CORE);
     Source asyncSource = sourceFactory.forUri(DartSdk.DART_ASYNC);
     return <String, TaskInput>{
       CORE_INPUT: LIBRARY_ELEMENT3.of(coreSource),
       ASYNC_INPUT: LIBRARY_ELEMENT3.of(asyncSource)
     };
   }
 
   /**
    * Create a [BuildTypeProviderTask] based on the given [context].
    */
   static BuildTypeProviderTask createTask(
-      AnalysisContext context, AnalysisContextTarget target) {
+      AnalysisContext context, AnalysisTarget target) {
     return new BuildTypeProviderTask(context, target);
   }
 }
 
 /**
  * A task that computes [CONSTANT_DEPENDENCIES] for a constant.
  */
 class ComputeConstantDependenciesTask extends ConstantEvaluationAnalysisTask {
   /**
    * The name of the [RESOLVED_UNIT6] input.
@@ skipping 38 matching lines @@
     // Record outputs.
     //
     outputs[CONSTANT_DEPENDENCIES] = dependencies;
   }
 
   /**
    * 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(ConstantEvaluationTarget target) {
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
     if (target is Element) {
-      CompilationUnitElementImpl unit = (target as Element)
+      CompilationUnitElementImpl unit = target
           .getAncestor((Element element) => element is CompilationUnitElement);
       return <String, TaskInput>{
         UNIT_INPUT: RESOLVED_UNIT6
             .of(new LibrarySpecificUnit(unit.librarySource, target.source)),
         TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request)
       };
     } else if (target is ConstantEvaluationTarget_Annotation) {
       return <String, TaskInput>{
         UNIT_INPUT: RESOLVED_UNIT6
             .of(new LibrarySpecificUnit(target.librarySource, target.source)),
         TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request)
       };
-    } else {
-      // Should never happen.
-      assert(false);
-      return <String, TaskInput>{};
     }
+    throw new AnalysisException(
+        'Cannot build inputs for a ${target.runtimeType}');
   }
 
   /**
    * Create a [ResolveUnitReferencesTask] based on the given [target] in
    * the given [context].
    */
   static ComputeConstantDependenciesTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new ComputeConstantDependenciesTask(context, target);
   }
@@ skipping 63 matching lines @@
     // Record outputs.
     //
     outputs[CONSTANT_VALUE] = constant;
   }
 
   /**
    * 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(ConstantEvaluationTarget target) {
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+    ConstantEvaluationTarget evaluationTarget = target;
     return <String, TaskInput>{
       DEPENDENCIES_INPUT:
-          CONSTANT_DEPENDENCIES.of(target).toListOf(CONSTANT_VALUE),
+          CONSTANT_DEPENDENCIES.of(evaluationTarget).toListOf(CONSTANT_VALUE),
       TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request)
     };
   }
 
   /**
    * Create a [ComputeConstantValueTask] based on the given [target] in the
    * given [context].
    */
   static ComputeConstantValueTask createTask(
       AnalysisContext context, AnalysisTarget target) {
@@ skipping 59 matching lines @@
     // cache appropriately.
     Source source = getRequiredSource();
     outputs[CONTAINING_LIBRARIES] = context.getLibrariesContaining(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].
    */
-  static Map<String, TaskInput> buildInputs(Source target) {
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
     return <String, TaskInput>{};
   }
 
   /**
    * Create a [ContainingLibrariesTask] based on the given [target] in the given
    * [context].
    */
   static ContainingLibrariesTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new ContainingLibrariesTask(context, target);
@@ skipping 61 matching lines @@
     // Record outputs.
     //
     outputs[DART_ERRORS] = AnalysisError.mergeLists(errorLists);
   }
 
   /**
    * 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 target) {
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+    Source source = target;
     return <String, TaskInput>{
-      BUILD_DIRECTIVES_ERRORS_INPUT: BUILD_DIRECTIVES_ERRORS.of(target),
-      BUILD_LIBRARY_ERRORS_INPUT: BUILD_LIBRARY_ERRORS.of(target),
-      PARSE_ERRORS_INPUT: PARSE_ERRORS.of(target),
-      SCAN_ERRORS_INPUT: SCAN_ERRORS.of(target),
+      BUILD_DIRECTIVES_ERRORS_INPUT: BUILD_DIRECTIVES_ERRORS.of(source),
+      BUILD_LIBRARY_ERRORS_INPUT: BUILD_LIBRARY_ERRORS.of(source),
+      PARSE_ERRORS_INPUT: PARSE_ERRORS.of(source),
+      SCAN_ERRORS_INPUT: SCAN_ERRORS.of(source),
       LIBRARY_UNIT_ERRORS_INPUT: CONTAINING_LIBRARIES
-          .of(target)
+          .of(source)
           .toMap((Source library) {
-        LibrarySpecificUnit unit = new LibrarySpecificUnit(library, target);
+        LibrarySpecificUnit unit = new LibrarySpecificUnit(library, source);
         return LIBRARY_UNIT_ERRORS.of(unit);
       })
     };
   }
 
   /**
    * Create a [DartErrorsTask] based on the given [target] in the given
    * [context].
    */
   static DartErrorsTask createTask(
@@ skipping 35 matching lines @@
     // all constants are evaluated before this method is called.
     CompilationUnit unit = getRequiredInput(UNIT_INPUT);
     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) {
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+    LibrarySpecificUnit unit = target;
     return <String, TaskInput>{
-      'libraryElement': LIBRARY_ELEMENT.of(target.library),
-      UNIT_INPUT: RESOLVED_UNIT6.of(target),
+      'libraryElement': LIBRARY_ELEMENT.of(unit.library),
+      UNIT_INPUT: RESOLVED_UNIT6.of(unit),
       CONSTANT_VALUES:
-          COMPILATION_UNIT_CONSTANTS.of(target).toListOf(CONSTANT_VALUE)
+          COMPILATION_UNIT_CONSTANTS.of(unit).toListOf(CONSTANT_VALUE)
     };
   }
 
   /**
    * Create an [EvaluateUnitConstantsTask] based on the given [target] in
    * the given [context].
    */
   static EvaluateUnitConstantsTask createTask(
-      AnalysisContext context, LibrarySpecificUnit target) {
+      AnalysisContext context, AnalysisTarget target) {
     return new EvaluateUnitConstantsTask(context, target);
   }
 }
 
 /**
  * The helper for building the export [Namespace] of a [LibraryElement].
  */
 class ExportNamespaceBuilder {
   /**
    * Build the export [Namespace] of the given [LibraryElement].
@@ skipping 132 matching lines @@
     // Record outputs.
     //
     outputs[USED_IMPORTED_ELEMENTS] = visitor.usedElements;
   }
 
   /**
    * 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>{UNIT_INPUT: RESOLVED_UNIT6.of(target)};
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+    LibrarySpecificUnit unit = target;
+    return <String, TaskInput>{UNIT_INPUT: RESOLVED_UNIT6.of(unit)};
   }
 
   /**
    * Create a [GatherUsedImportedElementsTask] based on the given [target] in
    * the given [context].
    */
   static GatherUsedImportedElementsTask createTask(
-      AnalysisContext context, LibrarySpecificUnit target) {
+      AnalysisContext context, AnalysisTarget target) {
     return new GatherUsedImportedElementsTask(context, target);
   }
 }
 
 /**
  * A task that builds [USED_LOCAL_ELEMENTS] for a unit.
  */
 class GatherUsedLocalElementsTask extends SourceBasedAnalysisTask {
   /**
    * The name of the [RESOLVED_UNIT6] input.
@@ skipping 29 matching lines @@
     // Record outputs.
     //
     outputs[USED_LOCAL_ELEMENTS] = visitor.usedElements;
   }
 
   /**
    * 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>{UNIT_INPUT: RESOLVED_UNIT6.of(target)};
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+    LibrarySpecificUnit unit = target;
+    return <String, TaskInput>{UNIT_INPUT: RESOLVED_UNIT6.of(unit)};
   }
 
   /**
    * Create a [GatherUsedLocalElementsTask] based on the given [target] in
    * the given [context].
    */
   static GatherUsedLocalElementsTask createTask(
-      AnalysisContext context, LibrarySpecificUnit target) {
+      AnalysisContext context, AnalysisTarget target) {
     return new GatherUsedLocalElementsTask(context, target);
   }
 }
 
 /**
  * A task that generates [HINTS] for a unit.
  */
 class GenerateHintsTask extends SourceBasedAnalysisTask {
   /**
    * The name of the [RESOLVED_UNIT6] input.
@@ skipping 86 matching lines @@
     // Record outputs.
     //
     outputs[HINTS] = errorListener.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].
    */
-  static Map<String, TaskInput> buildInputs(LibrarySpecificUnit target) {
-    Source libSource = target.library;
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+    LibrarySpecificUnit unit = target;
+    Source libSource = unit.library;
     return <String, TaskInput>{
-      RESOLVED_UNIT_INPUT: RESOLVED_UNIT.of(target),
+      RESOLVED_UNIT_INPUT: RESOLVED_UNIT.of(unit),
       USED_LOCAL_ELEMENTS_INPUT: UNITS.of(libSource).toList((unit) {
         LibrarySpecificUnit target = new LibrarySpecificUnit(libSource, unit);
         return USED_LOCAL_ELEMENTS.of(target);
       }),
       USED_IMPORTED_ELEMENTS_INPUT: UNITS.of(libSource).toList((unit) {
         LibrarySpecificUnit target = new LibrarySpecificUnit(libSource, unit);
         return USED_IMPORTED_ELEMENTS.of(target);
       }),
       TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request)
     };
@@ skipping 30 matching lines @@
   @override
   void internalPerform() {
     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) {
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+    Source source = target;
     return <String, TaskInput>{
-      'allErrors': UNITS.of(library).toListOf(DART_ERRORS)
+      'allErrors': UNITS.of(source).toListOf(DART_ERRORS)
     };
   }
 
   /**
    * Create a [LibraryErrorsReadyTask] based on the given [target] in the given
    * [context].
    */
   static LibraryErrorsReadyTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new LibraryErrorsReadyTask(context, target);
@@ skipping 74 matching lines @@
     // Record outputs.
     //
     outputs[LIBRARY_UNIT_ERRORS] = AnalysisError.mergeLists(errorLists);
   }
 
   /**
    * 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 [unit].
    */
-  static Map<String, TaskInput> buildInputs(LibrarySpecificUnit unit) {
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+    LibrarySpecificUnit unit = target;
     return <String, TaskInput>{
       BUILD_FUNCTION_TYPE_ALIASES_ERRORS_INPUT:
           BUILD_FUNCTION_TYPE_ALIASES_ERRORS.of(unit),
       CONSTRUCTORS_ERRORS_INPUT: COMPILATION_UNIT_ELEMENT
           .of(unit)
           .mappedToList((CompilationUnitElement element) => element.types)
           .toListOf(CONSTRUCTORS_ERRORS),
       HINTS_INPUT: HINTS.of(unit),
       RESOLVE_REFERENCES_ERRORS_INPUT: RESOLVE_REFERENCES_ERRORS.of(unit),
       RESOLVE_TYPE_NAMES_ERRORS_INPUT: RESOLVE_TYPE_NAMES_ERRORS.of(unit),
@@ skipping 55 matching lines @@
   ParseDartTask(InternalAnalysisContext context, AnalysisTarget target)
       : super(context, target);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
     Source source = getRequiredSource();
     LineInfo lineInfo = getRequiredInput(LINE_INFO_INPUT_NAME);
-    int modificationTime = getRequiredInput(MODIFICATION_TIME_INPUT_NAME);
     Token tokenStream = getRequiredInput(TOKEN_STREAM_INPUT_NAME);
 
     RecordingErrorListener errorListener = new RecordingErrorListener();
     Parser parser = new Parser(source, errorListener);
     AnalysisOptions options = context.analysisOptions;
     parser.parseFunctionBodies = options.analyzeFunctionBodiesPredicate(source);
     CompilationUnit unit = parser.parseCompilationUnit(tokenStream);
     unit.lineInfo = lineInfo;
 
     bool hasNonPartOfDirective = false;
@@ skipping 28 matching lines @@
     // Always include "dart:core" source.
     //
     HashSet<Source> importedSourceSet =
         new HashSet.from(explicitlyImportedSourceSet);
     Source coreLibrarySource = context.sourceFactory.forUri(DartSdk.DART_CORE);
     importedSourceSet.add(coreLibrarySource);
     //
     // Compute kind.
     //
     SourceKind sourceKind = SourceKind.LIBRARY;
-    if (modificationTime == -1) {
-      sourceKind = SourceKind.UNKNOWN;
-    } else if (hasPartOfDirective && !hasNonPartOfDirective) {
+    if (hasPartOfDirective && !hasNonPartOfDirective) {
       sourceKind = SourceKind.PART;
     }
     //
     // 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 =
         removeDuplicateErrors(errorListener.errors);
     List<Source> unitSources = <Source>[source]..addAll(includedSourceSet);
     outputs[EXPLICITLY_IMPORTED_LIBRARIES] = explicitlyImportedSources;
     outputs[EXPORTED_LIBRARIES] = exportedSources;
     outputs[IMPORTED_LIBRARIES] = importedSources;
     outputs[INCLUDED_PARTS] = includedSources;
     outputs[PARSE_ERRORS] = parseErrors;
     outputs[PARSED_UNIT] = unit;
     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
    * [source].
    */
-  static Map<String, TaskInput> buildInputs(Source source) {
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
     return <String, TaskInput>{
-      LINE_INFO_INPUT_NAME: LINE_INFO.of(source),
-      MODIFICATION_TIME_INPUT_NAME: MODIFICATION_TIME.of(source),
-      TOKEN_STREAM_INPUT_NAME: TOKEN_STREAM.of(source)
+      LINE_INFO_INPUT_NAME: LINE_INFO.of(target),
+      TOKEN_STREAM_INPUT_NAME: TOKEN_STREAM.of(target)
     };
   }
 
   /**
    * 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 106 matching lines @@
   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) {
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+    Source source = target;
     return <String, TaskInput>{
-      LIBRARY_INPUT: LIBRARY_ELEMENT6.of(libSource),
+      LIBRARY_INPUT: LIBRARY_ELEMENT6.of(source),
       'resolvedUnits': IMPORT_EXPORT_SOURCE_CLOSURE
-          .of(libSource)
+          .of(source)
           .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].
    */
@@ skipping 31 matching lines @@
   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) {
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+    Source source = target;
     return <String, TaskInput>{
-      LIBRARY_INPUT: LIBRARY_ELEMENT4.of(libSource),
+      LIBRARY_INPUT: LIBRARY_ELEMENT4.of(source),
       'resolvedUnits': IMPORT_EXPORT_SOURCE_CLOSURE
-          .of(libSource)
+          .of(source)
           .toMapOf(UNITS)
           .toFlattenList((Source library, Source unit) =>
               RESOLVED_UNIT4.of(new LibrarySpecificUnit(library, unit))),
     };
   }
 
   /**
    * Create a [ResolveLibraryTypeNamesTask] based on the given [target] in
    * the given [context].
    */
@@ skipping 62 matching lines @@
     outputs[RESOLVE_REFERENCES_ERRORS] =
         removeDuplicateErrors(errorListener.errors);
     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) {
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+    LibrarySpecificUnit unit = target;
     return <String, TaskInput>{
-      LIBRARY_INPUT: LIBRARY_ELEMENT6.of(target.library),
-      UNIT_INPUT: RESOLVED_UNIT5.of(target),
+      LIBRARY_INPUT: LIBRARY_ELEMENT6.of(unit.library),
+      UNIT_INPUT: RESOLVED_UNIT5.of(unit),
       TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request)
     };
   }
 
   /**
    * Create a [ResolveUnitReferencesTask] based on the given [target] in
    * the given [context].
    */
   static ResolveUnitReferencesTask createTask(
       AnalysisContext context, AnalysisTarget target) {
@@ skipping 58 matching lines @@
     outputs[RESOLVE_TYPE_NAMES_ERRORS] =
         removeDuplicateErrors(errorListener.errors);
     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(LibrarySpecificUnit target) {
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+    LibrarySpecificUnit unit = target;
     return <String, TaskInput>{
-      LIBRARY_INPUT: LIBRARY_ELEMENT4.of(target.library),
-      UNIT_INPUT: RESOLVED_UNIT3.of(target),
+      LIBRARY_INPUT: LIBRARY_ELEMENT4.of(unit.library),
+      UNIT_INPUT: RESOLVED_UNIT3.of(unit),
       TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request)
     };
   }
 
   /**
    * Create a [ResolveUnitTypeNamesTask] based on the given [target] in
    * the given [context].
    */
   static ResolveUnitTypeNamesTask createTask(
       AnalysisContext context, AnalysisTarget target) {
@@ skipping 57 matching lines @@
     outputs[RESOLVED_UNIT5] = unit;
     outputs[VARIABLE_REFERENCE_ERRORS] =
         removeDuplicateErrors(errorListener.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].
    */
-  static Map<String, TaskInput> buildInputs(LibrarySpecificUnit target) {
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+    LibrarySpecificUnit unit = target;
     return <String, TaskInput>{
       'fullyBuiltLibraryElements': IMPORT_EXPORT_SOURCE_CLOSURE
-          .of(target.library)
+          .of(unit.library)
           .toListOf(LIBRARY_ELEMENT6),
-      LIBRARY_INPUT: LIBRARY_ELEMENT6.of(target.library),
-      UNIT_INPUT: RESOLVED_UNIT4.of(target),
+      LIBRARY_INPUT: LIBRARY_ELEMENT6.of(unit.library),
+      UNIT_INPUT: RESOLVED_UNIT4.of(unit),
       TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request)
     };
   }
 
   /**
    * Create a [ResolveVariableReferencesTask] based on the given [target] in
    * the given [context].
    */
   static ResolveVariableReferencesTask createTask(
       AnalysisContext context, AnalysisTarget target) {
@@ skipping 26 matching lines @@
    */
   ScanDartTask(InternalAnalysisContext context, AnalysisTarget target)
       : super(context, target);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
     Source source = getRequiredSource();
-    String content = getRequiredInput(CONTENT_INPUT_NAME);
+    if (target is DartScript) {
+      DartScript script = target;
+      List<ScriptFragment> fragments = script.fragments;
+      if (fragments.length < 1) {
+        throw new AnalysisException('Cannot scan scripts with no fragments');
+      } else if (fragments.length > 1) {
+        throw new AnalysisException(
+            'Cannot scan scripts with multiple fragments');
+      }
+      ScriptFragment fragment = fragments[0];
 
-    RecordingErrorListener errorListener = new RecordingErrorListener();
-    Scanner scanner =
-        new Scanner(source, new CharSequenceReader(content), errorListener);
-    scanner.preserveComments = context.analysisOptions.preserveComments;
-    scanner.enableNullAwareOperators =
-        context.analysisOptions.enableNullAwareOperators;
+      RecordingErrorListener errorListener = new RecordingErrorListener();
+      Scanner scanner = new Scanner(source,
+          new SubSequenceReader(fragment.content, fragment.offset),
+          errorListener);
+      scanner.setSourceStart(fragment.line, fragment.column);
+      scanner.preserveComments = context.analysisOptions.preserveComments;
+      scanner.enableNullAwareOperators =
+          context.analysisOptions.enableNullAwareOperators;
 
-    outputs[TOKEN_STREAM] = scanner.tokenize();
-    outputs[LINE_INFO] = new LineInfo(scanner.lineStarts);
-    outputs[SCAN_ERRORS] = removeDuplicateErrors(errorListener.errors);
+      outputs[TOKEN_STREAM] = scanner.tokenize();
+      outputs[LINE_INFO] = new LineInfo(scanner.lineStarts);
+      outputs[SCAN_ERRORS] = removeDuplicateErrors(errorListener.errors);
+    } else if (target is Source) {
+      String content = getRequiredInput(CONTENT_INPUT_NAME);
+
+      RecordingErrorListener errorListener = new RecordingErrorListener();
+      Scanner scanner =
+          new Scanner(source, new CharSequenceReader(content), errorListener);
+      scanner.preserveComments = context.analysisOptions.preserveComments;
+      scanner.enableNullAwareOperators =
+          context.analysisOptions.enableNullAwareOperators;
+
+      outputs[TOKEN_STREAM] = scanner.tokenize();
+      outputs[LINE_INFO] = new LineInfo(scanner.lineStarts);
+      outputs[SCAN_ERRORS] = removeDuplicateErrors(errorListener.errors);
+    } else {
+      throw new AnalysisException(
+          'Cannot scan Dart code from a ${target.runtimeType}');
+    }
   }
 
   /**
    * 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
    * [source].
    */
-  static Map<String, TaskInput> buildInputs(Source source) {
-    return <String, TaskInput>{CONTENT_INPUT_NAME: CONTENT.of(source)};
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+    if (target is Source) {
+      return <String, TaskInput>{CONTENT_INPUT_NAME: CONTENT.of(target)};
+    } else if (target is DartScript) {
+      // This task does not use the following input; it is included only to add
+      // a dependency between this value and the containing source so that when
+      // the containing source is modified these results will be invalidated.
+      return <String, TaskInput>{'-': DART_SCRIPTS.of(target.source)};
+    }
+    throw new AnalysisException(
+        'Cannot build inputs for a ${target.runtimeType}');
   }
 
   /**
    * Create a [ScanDartTask] based on the given [target] in the given [context].
    */
   static ScanDartTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new ScanDartTask(context, target);
   }
 }
@@ skipping 94 matching lines @@
     StringLiteral uriLiteral = directive.uri;
     errorReporter.reportErrorForNode(CompileTimeErrorCode.URI_DOES_NOT_EXIST,
         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) {
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+    LibrarySpecificUnit unit = target;
     return <String, TaskInput>{
       'resolvedUnits': IMPORT_EXPORT_SOURCE_CLOSURE
-          .of(target.library)
+          .of(unit.library)
           .toMapOf(UNITS)
           .toFlattenList((Source library, Source unit) =>
               RESOLVED_UNIT.of(new LibrarySpecificUnit(library, unit))),
-      UNIT_INPUT: RESOLVED_UNIT.of(target),
+      UNIT_INPUT: RESOLVED_UNIT.of(unit),
       TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request)
     };
   }
 
   /**
    * Create a [VerifyUnitTask] based on the given [target] in
    * the given [context].
    */
   static VerifyUnitTask createTask(
       AnalysisContext context, AnalysisTarget target) {
@@ skipping 101 matching lines @@
   @override
   bool moveNext() {
     if (_newSources.isEmpty) {
       return false;
     }
     currentTarget = _newSources.first;
     _newSources.remove(currentTarget);
     return true;
   }
 }