In the new task model, use explicit dependencies on the type provider.

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/generated/ast.dart';
@@ skipping 1662 matching lines @@
 
 /**
  * A task that computes [CONSTANT_DEPENDENCIES] for a constant.
  */
 class ComputeConstantDependenciesTask extends ConstantEvaluationAnalysisTask {
   /**
    * The name of the [RESOLVED_UNIT6] input.
    */
   static const String UNIT_INPUT = 'UNIT_INPUT';
 
+  /**
+   * The name of the [TYPE_PROVIDER] input.
+   */
+  static const String TYPE_PROVIDER_INPUT = 'TYPE_PROVIDER_INPUT';
+
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'ComputeConstantDependenciesTask', createTask, buildInputs,
       <ResultDescriptor>[CONSTANT_DEPENDENCIES]);
 
   ComputeConstantDependenciesTask(
       InternalAnalysisContext context, ConstantEvaluationTarget constant)
       : super(context, constant);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
     //
     // Prepare inputs.
     //
     // Note: UNIT_INPUT is not needed.  It is merely a bookkeeping dependency
     // to ensure that resolution has occurred before we attempt to determine
     // constant dependencies.
     //
     ConstantEvaluationTarget constant = target;
     AnalysisContext context = constant.context;
-    TypeProvider typeProvider = context.typeProvider;
+    TypeProvider typeProvider = getRequiredInput(TYPE_PROVIDER_INPUT);
     //
     // Compute dependencies.
     //
     List<ConstantEvaluationTarget> dependencies = <ConstantEvaluationTarget>[];
     new ConstantEvaluationEngine(typeProvider, context.declaredVariables)
         .computeDependencies(constant, dependencies.add);
     //
     // 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) {
     if (target is Element) {
       CompilationUnitElementImpl unit = (target as Element)
           .getAncestor((Element element) => element is CompilationUnitElement);
       return <String, TaskInput>{
         UNIT_INPUT: RESOLVED_UNIT6
-            .of(new LibrarySpecificUnit(unit.librarySource, target.source))
+            .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))
+            .of(new LibrarySpecificUnit(target.librarySource, target.source)),
+        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
    * 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
  * stores it in the element model.
  */
 class ComputeConstantValueTask extends ConstantEvaluationAnalysisTask {
   /**
    * The name of the input which ensures that dependent constants are evaluated
    * before the target.
    */
   static const String DEPENDENCIES_INPUT = 'DEPENDENCIES_INPUT';
 
+  /**
+   * The name of the [TYPE_PROVIDER] input.
+   */
+  static const String TYPE_PROVIDER_INPUT = 'TYPE_PROVIDER_INPUT';
+
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'ComputeConstantValueTask', createTask, buildInputs,
       <ResultDescriptor>[CONSTANT_VALUE]);
 
   ComputeConstantValueTask(
       InternalAnalysisContext context, ConstantEvaluationTarget constant)
       : super(context, constant);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
     //
     // Prepare inputs.
     //
     // Note: DEPENDENCIES_INPUT is not needed.  It is merely a bookkeeping
     // dependency to ensure that the constants that this constant depends on
     // are computed first.
     ConstantEvaluationTarget constant = target;
     AnalysisContext context = constant.context;
-    TypeProvider typeProvider = context.typeProvider;
+    TypeProvider typeProvider = getRequiredInput(TYPE_PROVIDER_INPUT);
     //
     // Compute the value of the constant.
     //
     new ConstantEvaluationEngine(typeProvider, context.declaredVariables)
         .computeConstantValue(constant);
     //
     // 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) {
     return <String, TaskInput>{
       DEPENDENCIES_INPUT:
-          CONSTANT_DEPENDENCIES.of(target).toListOf(CONSTANT_VALUE)
+          CONSTANT_DEPENDENCIES.of(target).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) {
     return new ComputeConstantValueTask(context, target);
@@ skipping 464 matching lines @@
    * The name of a list of [USED_LOCAL_ELEMENTS] for each library unit input.
    */
   static const String USED_LOCAL_ELEMENTS_INPUT = 'USED_LOCAL_ELEMENTS';
 
   /**
    * The name of a list of [USED_IMPORTED_ELEMENTS] for each library unit input.
    */
   static const String USED_IMPORTED_ELEMENTS_INPUT = 'USED_IMPORTED_ELEMENTS';
 
   /**
+   * 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(
       'GenerateHintsTask', createTask, buildInputs, <ResultDescriptor>[HINTS]);
 
   GenerateHintsTask(InternalAnalysisContext context, AnalysisTarget target)
       : super(context, target);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
@@ skipping 33 matching lines @@
           new UnusedLocalElementsVerifier(errorListener, usedElements);
       unitElement.accept(visitor);
     }
     // Dart2js analysis.
     if (context.analysisOptions.dart2jsHint) {
       unit.accept(new Dart2JSVerifier(errorReporter));
     }
     // Dart best practices.
     InheritanceManager inheritanceManager =
         new InheritanceManager(libraryElement);
-    TypeProvider typeProvider = context.typeProvider;
+    TypeProvider typeProvider = getRequiredInput(TYPE_PROVIDER_INPUT);
     unit.accept(new BestPracticesVerifier(errorReporter, typeProvider));
     unit.accept(new OverrideVerifier(errorReporter, inheritanceManager));
     // Find to-do comments.
     new ToDoFinder(errorReporter).findIn(unit);
     //
     // 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;
     return <String, TaskInput>{
       RESOLVED_UNIT_INPUT: RESOLVED_UNIT.of(target),
       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)
     };
   }
 
   /**
    * Create a [GenerateHintsTask] based on the given [target] in
    * the given [context].
    */
   static GenerateHintsTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new GenerateHintsTask(context, target);
@@ skipping 414 matching lines @@
    * The name of the [LIBRARY_ELEMENT] 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>[
     RESOLVE_REFERENCES_ERRORS,
     RESOLVED_UNIT6
   ]);
 
   ResolveReferencesTask(InternalAnalysisContext context, AnalysisTarget target)
       : super(context, target);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
     RecordingErrorListener errorListener = new RecordingErrorListener();
     //
     // Prepare inputs.
     //
     LibraryElement libraryElement = getRequiredInput(LIBRARY_INPUT);
     CompilationUnit unit = getRequiredInput(UNIT_INPUT);
     CompilationUnitElement unitElement = unit.element;
-    TypeProvider typeProvider = unitElement.context.typeProvider;
+    TypeProvider typeProvider = getRequiredInput(TYPE_PROVIDER_INPUT);
     //
     // Resolve references.
     //
     InheritanceManager inheritanceManager =
         new InheritanceManager(libraryElement);
     AstVisitor visitor = new ResolverVisitor.con2(libraryElement,
         unitElement.source, typeProvider, inheritanceManager, errorListener);
     unit.accept(visitor);
     //
     // Record outputs.
     //
     outputs[RESOLVE_REFERENCES_ERRORS] = 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) {
     return <String, TaskInput>{
       LIBRARY_INPUT: LIBRARY_ELEMENT.of(target.library),
-      UNIT_INPUT: RESOLVED_UNIT5.of(target)
+      UNIT_INPUT: RESOLVED_UNIT5.of(target),
+      TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request)
     };
   }
 
   /**
    * Create a [ResolveReferencesTask] based on the given [target] in
    * the given [context].
    */
   static ResolveReferencesTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new ResolveReferencesTask(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 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(
       'ResolveUnitTypeNamesTask', createTask, buildInputs, <ResultDescriptor>[
     RESOLVE_TYPE_NAMES_ERRORS,
     RESOLVED_UNIT4
   ]);
 
   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;
+    TypeProvider typeProvider = getRequiredInput(TYPE_PROVIDER_INPUT);
     //
     // Resolve TypeName nodes.
     //
     TypeResolverVisitor visitor = new TypeResolverVisitor.con2(
-        unitElement.library, unitElement.source, context.typeProvider,
-        errorListener);
+        unitElement.library, unitElement.source, typeProvider, errorListener);
     unit.accept(visitor);
     //
     // Record outputs.
     //
     outputs[RESOLVE_TYPE_NAMES_ERRORS] = 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) {
-    return <String, TaskInput>{UNIT_INPUT: RESOLVED_UNIT3.of(target)};
+    return <String, TaskInput>{
+      UNIT_INPUT: RESOLVED_UNIT3.of(target),
+      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) {
     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.
    */
   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.
+   */
+  static const String TYPE_PROVIDER_INPUT = 'TYPE_PROVIDER_INPUT';
+
+  /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'ResolveVariableReferencesTask', createTask, buildInputs,
       <ResultDescriptor>[RESOLVED_UNIT5]);
 
   ResolveVariableReferencesTask(
       InternalAnalysisContext context, AnalysisTarget target)
       : super(context, target);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
     RecordingErrorListener errorListener = new RecordingErrorListener();
     //
     // Prepare inputs.
     //
     LibraryElement libraryElement = getRequiredInput(LIBRARY_INPUT);
     CompilationUnit unit = getRequiredInput(UNIT_INPUT);
     CompilationUnitElement unitElement = unit.element;
     //
     // Resolve local variables.
     //
-    TypeProvider typeProvider = unitElement.context.typeProvider;
+    TypeProvider typeProvider = getRequiredInput(TYPE_PROVIDER_INPUT);
     Scope nameScope = new LibraryScope(libraryElement, errorListener);
     AstVisitor visitor = new VariableResolverVisitor.con2(libraryElement,
         unitElement.source, typeProvider, nameScope, errorListener);
     unit.accept(visitor);
     //
     // Record outputs.
     //
     outputs[RESOLVED_UNIT5] = 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),
-      UNIT_INPUT: RESOLVED_UNIT4.of(target)
+      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(
       AnalysisContext context, AnalysisTarget target) {
     return new ResolveVariableReferencesTask(context, target);
@@ skipping 70 matching lines @@
 /**
  * A task that builds [VERIFY_ERRORS] for a unit.
  */
 class VerifyUnitTask extends SourceBasedAnalysisTask {
   /**
    * The name of the [RESOLVED_UNIT] 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('VerifyUnitTask',
       createTask, buildInputs, <ResultDescriptor>[VERIFY_ERRORS]);
 
   /**
    * The [ErrorReporter] to report errors to.
    */
   ErrorReporter errorReporter;
 
   VerifyUnitTask(InternalAnalysisContext context, AnalysisTarget target)
       : super(context, target);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
     RecordingErrorListener errorListener = new RecordingErrorListener();
     Source source = getRequiredSource();
     errorReporter = new ErrorReporter(errorListener, source);
-    TypeProvider typeProvider = context.typeProvider;
+    TypeProvider typeProvider = getRequiredInput(TYPE_PROVIDER_INPUT);
     //
     // Prepare inputs.
     //
     CompilationUnit unit = getRequiredInput(UNIT_INPUT);
     CompilationUnitElement unitElement = unit.element;
     LibraryElement libraryElement = unitElement.library;
     //
     // Use the ErrorVerifier to compute errors.
     //
     ErrorVerifier errorVerifier = new ErrorVerifier(errorReporter,
         libraryElement, typeProvider, new InheritanceManager(libraryElement));
     unit.accept(errorVerifier);
     //
     // Record outputs.
     //
     outputs[VERIFY_ERRORS] = 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) {
-    return <String, TaskInput>{UNIT_INPUT: RESOLVED_UNIT.of(target)};
+    return <String, TaskInput>{
+      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(
       AnalysisContext context, AnalysisTarget target) {
     return new VerifyUnitTask(context, target);
   }
@@ skipping 92 matching lines @@
   @override
   bool moveNext() {
     if (_newSources.isEmpty) {
       return false;
     }
     currentTarget = _newSources.first;
     _newSources.remove(currentTarget);
     return true;
   }
 }