Remove IMPORT_EXPORT_SOURCE_CLOSURE and IS_CLIENT results.

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, AnalysisContextImpl, WorkManager;
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/utilities_general.dart';
 import 'package:analyzer/src/task/inputs.dart';
 import 'package:analyzer/src/task/manager.dart';
 import 'package:analyzer/task/model.dart';
 
+final PerformanceTag analysisDriverProcessOutputs =
+    new PerformanceTag('AnalysisDriver.processOutputs');
+
 final PerformanceTag workOrderMoveNextPerformanceTag =
     new PerformanceTag('WorkOrder.moveNext');
 
 /**
  * An object that is used to cause analysis to be performed until all of the
  * required analysis information has been computed.
  */
 class AnalysisDriver {
   /**
    * The task manager used to figure out how to compute analysis results.
@@ skipping 229 matching lines @@
       // Mark all of the results that the task would have computed as being in
       // ERROR with the exception recorded on the work item.
       CacheEntry targetEntry = context.getCacheEntry(item.target);
       targetEntry.setErrorState(item.exception, item.descriptor.results);
       return null;
     }
     // Otherwise, perform the task.
     AnalysisTask task = item.buildTask();
     _onTaskStartedController.add(task);
     task.perform();
-    AnalysisTarget target = task.target;
-    CacheEntry entry = context.getCacheEntry(target);
-    if (task.caughtException == null) {
-      List<TargetedResult> dependedOn = item.inputTargetedResults.toList();
-      Map<ResultDescriptor, dynamic> outputs = task.outputs;
-      for (ResultDescriptor result in task.descriptor.results) {
-        // TODO(brianwilkerson) We could check here that a value was produced
-        // and throw an exception if not (unless we want to allow null values).
-        entry.setValue(result, outputs[result], dependedOn);
+    analysisDriverProcessOutputs.makeCurrentWhile(() {
+      AnalysisTarget target = task.target;
+      CacheEntry entry = context.getCacheEntry(target);
+      if (task.caughtException == null) {
+        List<TargetedResult> dependedOn = item.inputTargetedResults.toList();
+        Map<ResultDescriptor, dynamic> outputs = task.outputs;
+        for (ResultDescriptor result in task.descriptor.results) {
+          // TODO(brianwilkerson) We could check here that a value was produced
+          // and throw an exception if not (unless we want to allow null values).
+          entry.setValue(result, outputs[result], dependedOn);
 //        if (dependedOn.length > 250) {
 //          print('[${dependedOn.length}] $result or $target dependsOn: $dependedOn');
 //        }
+        }
+        outputs.forEach((ResultDescriptor descriptor, value) {
+          StreamController<ComputedResult> controller =
+              resultComputedControllers[descriptor];
+          if (controller != null) {
+            ComputedResult event =
+                new ComputedResult(context, descriptor, target, value);
+            controller.add(event);
+          }
+        });
+        for (WorkManager manager in workManagers) {
+          manager.resultsComputed(target, outputs);
+        }
+      } else {
+        entry.setErrorState(task.caughtException, item.descriptor.results);
       }
-      outputs.forEach((ResultDescriptor descriptor, value) {
-        StreamController<ComputedResult> controller =
-            resultComputedControllers[descriptor];
-        if (controller != null) {
-          ComputedResult event =
-              new ComputedResult(context, descriptor, target, value);
-          controller.add(event);
-        }
-      });
-      for (WorkManager manager in workManagers) {
-        manager.resultsComputed(target, outputs);
-      }
-    } else {
-      entry.setErrorState(task.caughtException, item.descriptor.results);
-    }
+    });
     _onTaskCompletedController.add(task);
     return task;
   }
 
   /**
    * Reset the state of the driver in response to a change in the state of one
    * or more analysis targets. This will cause any analysis that was currently
    * in process to be stopped and for analysis to resume based on the new state.
    */
   void reset() {
@@ skipping 426 matching lines @@
  * A description of the work to be done to compute a desired analysis result.
  * The class implements a lazy depth-first traversal of the work item's input.
  */
 class WorkOrder implements Iterator<WorkItem> {
   /**
    * The dependency walker which is being used to determine what work to do
    * next.
    */
   final _WorkOrderDependencyWalker _dependencyWalker;
 
-  List<WorkItem> get workItems => _dependencyWalker._path;
-
   /**
    * The strongly connected component most recently returned by
    * [_dependencyWalker], minus any [WorkItem]s that the iterator has already
    * moved past.
    *
    * Null if the [_dependencyWalker] hasn't been used yet.
    */
   List<WorkItem> currentItems;
 
   /**
    * Initialize a newly created work order to compute the result described by
    * the given work item.
    */
   WorkOrder(TaskManager taskManager, WorkItem item)
       : _dependencyWalker = new _WorkOrderDependencyWalker(taskManager, item);
 
   @override
   WorkItem get current {
     if (currentItems == null) {
       return null;
     } else {
       return currentItems.last;
     }
   }
 
+  List<WorkItem> get workItems => _dependencyWalker._path;
+
   @override
   bool moveNext() {
     return workOrderMoveNextPerformanceTag.makeCurrentWhile(() {
       if (currentItems != null && currentItems.length > 1) {
         // Yield more items.
         currentItems.removeLast();
         return true;
       } else {
         // Get a new strongly connected component.
         StronglyConnectedComponent<WorkItem> nextStronglyConnectedComponent =
@@ skipping 27 matching lines @@
   final TaskManager taskManager;
 
   _WorkOrderDependencyWalker(this.taskManager, WorkItem startingNode)
       : super(startingNode);
 
   @override
   WorkItem getNextInput(WorkItem node, List<WorkItem> skipInputs) {
     return node.gatherInputs(taskManager, skipInputs);
   }
 }