Compute TYPE_PROVIDER using BuildTypeProviderTask.

pkg/analyzer/lib/src/task/driver.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.driver;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/generated/engine.dart' hide AnalysisTask;
 import 'package:analyzer/src/generated/java_engine.dart';
+import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/task/inputs.dart';
 import 'package:analyzer/src/task/manager.dart';
 import 'package:analyzer/task/model.dart';
 
 /**
  * An object that is used to cause analysis to be performed until all of the
  * required analysis information has been computed.
  */
 class AnalysisDriver {
   /**
@@ skipping 203 matching lines @@
   }
 }
 
 /**
  * A place to define the behaviors that need to be added to
  * [InternalAnalysisContext].
  */
 abstract class ExtendedAnalysisContext implements InternalAnalysisContext {
   List<AnalysisTarget> get explicitTargets;
   List<AnalysisTarget> get priorityTargets;
+  void set typeProvider(TypeProvider typeProvider);
   CacheEntry getCacheEntry(AnalysisTarget target);
 }
 
 /**
  * A description of a single anaysis task that can be performed to advance
  * analysis.
  */
 class WorkItem {
   /**
    * The context in which the task will be performed.
@@ skipping 28 matching lines @@
    * results that this task would have computed need to be marked as being in
    * ERROR with this exception.
    */
   CaughtException exception = null;
 
   /**
    * Initialize a newly created work item to compute the inputs for the task
    * described by the given descriptor.
    */
   WorkItem(this.context, this.target, this.descriptor) {
+    AnalysisTarget actualTarget = identical(
+            target, AnalysisContextTarget.request)
+        ? new AnalysisContextTarget(context)
+        : target;
     Map<String, TaskInput> inputDescriptors =
-        descriptor.createTaskInputs(target);
+        descriptor.createTaskInputs(actualTarget);
     builder = new TopLevelTaskInputBuilder(inputDescriptors);
     if (!builder.moveNext()) {
       builder = null;
     }
     inputs = new HashMap<String, dynamic>();
   }
 
   /**
    * Build the task represented by this work item.
    */
@@ skipping 23 matching lines @@
   WorkItem gatherInputs(TaskManager taskManager) {
     while (builder != null) {
       //
       // TODO(brianwilkerson) Capture information about which inputs were used
       // to compute the results. This information can later be used to compute
       // which results depend on a given result, and hence which results need to
       // be invalidated when one result is invalidated.
       //
       AnalysisTarget inputTarget = builder.currentTarget;
       ResultDescriptor inputResult = builder.currentResult;
       CacheEntry inputEntry = context.getCacheEntry(inputTarget);

[Brian Wilkerson, 2015/03/14 03:03:18]

I was expecting some "magic" to happen here. Perhaps it isn't necessary. We
should talk on Monday.

       CacheState inputState = inputEntry.getState(inputResult);
       if (inputState == CacheState.ERROR) {
         exception = inputEntry.exception;
         return null;
       } else if (inputState == CacheState.IN_PROCESS) {
         //
         // TODO(brianwilkerson) Implement this case.
         //
         // One possibility would be to return a WorkItem that would perform a
         // no-op task in order to cause us to come back to this work item on the
@@ skipping 65 matching lines @@
     currentItem = pendingItems.removeLast();
     WorkItem childItem = currentItem.gatherInputs(taskManager);
     while (childItem != null) {
       pendingItems.add(currentItem);
       currentItem = childItem;
       childItem = currentItem.gatherInputs(taskManager);
     }
     return true;
   }
 }