Add debug output for issue 24939.

pkg/analyzer/test/src/task/driver_test.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 test.src.task.driver_test;
 
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/generated/engine.dart'
     hide
         AnalysisCache,
@@ skipping 332 matching lines @@
   }
 
   test_performAnalysisTask_onResultComputed() {
     AnalysisTarget target = new TestSource();
     ResultDescriptor result = new ResultDescriptor('result', null);
     TestAnalysisTask task;
     TaskDescriptor descriptor = new TaskDescriptor(
         'task', (context, target) => task, (target) => {}, [result]);
     task = new TestAnalysisTask(context, target,
         descriptor: descriptor, value: 42);
-    WorkItem item = new WorkItem(context, target, descriptor, null);
+    WorkItem item = new WorkItem(context, target, descriptor, null, null);
 
     bool streamNotified = false;
     analysisDriver.onResultComputed(result).listen((event) {
       streamNotified = true;
       expect(event.context, same(context));
       expect(event.target, same(target));
       expect(event.descriptor, same(result));
       expect(event.value, 42);
     });
     analysisDriver.performWorkItem(item);
     expect(streamNotified, isTrue);
   }
 
   test_performWorkItem_exceptionInTask() {
     AnalysisTarget target = new TestSource();
     ResultDescriptor result = new ResultDescriptor('result', null);
     CaughtException exception =
         new CaughtException(new AnalysisException(), null);
     TestAnalysisTask task;
     TaskDescriptor descriptor = new TaskDescriptor(
         'task', (context, target) => task, (target) => {}, [result]);
     task = new TestAnalysisTask(context, target,
         descriptor: descriptor, exception: exception);
-    WorkItem item = new WorkItem(context, target, descriptor, null);
+    WorkItem item = new WorkItem(context, target, descriptor, null, null);
 
     analysisDriver.performWorkItem(item);
     CacheEntry targetEntry = context.getCacheEntry(item.target);
     expect(targetEntry.exception, exception);
     expect(targetEntry.getState(result), CacheState.ERROR);
   }
 
   test_performWorkItem_noException() {
     AnalysisTarget target = new TestSource();
     ResultDescriptor result = new ResultDescriptor('result', null);
     TestAnalysisTask task;
     TaskDescriptor descriptor = new TaskDescriptor(
         'task', (context, target) => task, (target) => {}, [result]);
     task = new TestAnalysisTask(context, target, descriptor: descriptor);
-    WorkItem item = new WorkItem(context, target, descriptor, null);
+    WorkItem item = new WorkItem(context, target, descriptor, null, null);
 
     analysisDriver.performWorkItem(item);
     CacheEntry targetEntry = context.getCacheEntry(item.target);
     expect(targetEntry.exception, isNull);
     expect(targetEntry.getState(result), CacheState.VALID);
   }
 
   test_performWorkItem_preExistingException() {
     AnalysisTarget target = new TestSource();
     ResultDescriptor result = new ResultDescriptor('result', null);
     TaskDescriptor descriptor = new TaskDescriptor(
         'task',
         (context, target) => new TestAnalysisTask(context, target),
         (target) => {},
         [result]);
     CaughtException exception =
         new CaughtException(new AnalysisException(), null);
-    WorkItem item = new WorkItem(context, target, descriptor, null);
+    WorkItem item = new WorkItem(context, target, descriptor, null, null);
     item.exception = exception;
 
     analysisDriver.performWorkItem(item);
     CacheEntry targetEntry = context.getCacheEntry(item.target);
     expect(targetEntry.exception, exception);
     expect(targetEntry.getState(result), CacheState.ERROR);
   }
 
   test_reset() {
     ResultDescriptor inputResult = new ResultDescriptor('input', null);
     TaskDescriptor descriptor = new TaskDescriptor(
         'task',
         (context, target) => new TestAnalysisTask(context, target),
         (target) => {'one': inputResult.of(target)},
         [new ResultDescriptor('output', null)]);
-    analysisDriver.currentWorkOrder =
-        new WorkOrder(taskManager, new WorkItem(null, null, descriptor, null));
+    analysisDriver.currentWorkOrder = new WorkOrder(
+        taskManager, new WorkItem(null, null, descriptor, null, null));
 
     analysisDriver.reset();
     expect(analysisDriver.currentWorkOrder, isNull);
   }
 
   void _configureDescriptors12() {
     descriptor1 = new TaskDescriptor(
         'task1',
         (context, target) =>
             new TestAnalysisTask(context, target, descriptor: descriptor1),
@@ skipping 177 matching lines @@
 
 @reflectiveTest
 class WorkItemTest extends AbstractDriverTest {
   test_buildTask_complete() {
     AnalysisTarget target = new TestSource();
     TaskDescriptor descriptor = new TaskDescriptor(
         'task',
         (context, target) => new TestAnalysisTask(context, target),
         (target) => {},
         [new ResultDescriptor('output', null)]);
-    WorkItem item = new WorkItem(context, target, descriptor, null);
+    WorkItem item = new WorkItem(context, target, descriptor, null, null);
     AnalysisTask task = item.buildTask();
     expect(task, isNotNull);
   }
 
   test_buildTask_incomplete() {
     AnalysisTarget target = new TestSource();
     ResultDescriptor inputResult = new ResultDescriptor('input', null);
     List<ResultDescriptor> outputResults = <ResultDescriptor>[
       new ResultDescriptor('output', null)
     ];
     TaskDescriptor descriptor = new TaskDescriptor(
         'task',
         (context, target) =>
             new TestAnalysisTask(context, target, results: outputResults),
         (target) => {'one': inputResult.of(target)},
         outputResults);
-    WorkItem item = new WorkItem(context, target, descriptor, null);
+    WorkItem item = new WorkItem(context, target, descriptor, null, null);
     expect(() => item.buildTask(), throwsStateError);
   }
 
   test_create() {
     AnalysisTarget target = new TestSource();
     TaskDescriptor descriptor = new TaskDescriptor(
         'task', null, (target) => {}, [new ResultDescriptor('result', null)]);
-    WorkItem item = new WorkItem(context, target, descriptor, null);
+    WorkItem item = new WorkItem(context, target, descriptor, null, null);
     expect(item, isNotNull);
     expect(item.context, context);
     expect(item.descriptor, descriptor);
     expect(item.target, target);
   }
 
   test_gatherInputs_complete() {
     AnalysisTarget target = new TestSource();
     TaskDescriptor descriptor = new TaskDescriptor(
         'task',
         (context, target) => new TestAnalysisTask(context, target),
         (target) => {},
         [new ResultDescriptor('output', null)]);
-    WorkItem item = new WorkItem(context, target, descriptor, null);
+    WorkItem item = new WorkItem(context, target, descriptor, null, null);
     WorkItem result = item.gatherInputs(taskManager, []);
     expect(result, isNull);
     expect(item.exception, isNull);
   }
 
   test_gatherInputs_incomplete() {
     AnalysisTarget target = new TestSource();
     ResultDescriptor resultA = new ResultDescriptor('resultA', null);
     ResultDescriptor resultB = new ResultDescriptor('resultB', null);
     // prepare tasks
     TaskDescriptor task1 = new TaskDescriptor(
         'task',
         (context, target) =>
             new TestAnalysisTask(context, target, results: [resultA]),
         (target) => {},
         [resultA]);
     TaskDescriptor task2 = new TaskDescriptor(
         'task',
         (context, target) => new TestAnalysisTask(context, target),
         (target) => {'one': resultA.of(target)},
         [resultB]);
     taskManager.addTaskDescriptor(task1);
     taskManager.addTaskDescriptor(task2);
     // gather inputs
-    WorkItem item = new WorkItem(context, target, task2, null);
+    WorkItem item = new WorkItem(context, target, task2, null, null);
     WorkItem inputItem = item.gatherInputs(taskManager, []);
     expect(inputItem, isNotNull);
   }
 
   test_gatherInputs_invalid() {
     AnalysisTarget target = new TestSource();
     ResultDescriptor inputResult = new ResultDescriptor('input', null);
     TaskDescriptor descriptor = new TaskDescriptor(
         'task',
         (context, target) => new TestAnalysisTask(context, target),
         (target) => {'one': inputResult.of(target)},
         [new ResultDescriptor('output', null)]);
-    WorkItem item = new WorkItem(context, target, descriptor, null);
+    WorkItem item = new WorkItem(context, target, descriptor, null, null);
     WorkItem result = item.gatherInputs(taskManager, []);
     expect(result, isNull);
     expect(item.exception, isNotNull);
   }
 }
 
 @reflectiveTest
 class WorkOrderTest extends EngineTestCase {
   test_create() {
     TaskManager manager = new TaskManager();
     TaskDescriptor descriptor = new TaskDescriptor(
         'task', null, (_) => {}, [new ResultDescriptor('result', null)]);
-    WorkOrder order =
-        new WorkOrder(manager, new WorkItem(null, null, descriptor, null));
+    WorkOrder order = new WorkOrder(
+        manager, new WorkItem(null, null, descriptor, null, null));
     expect(order, isNotNull);
     expect(order.currentItems, isNull);
     expect(order.current, isNull);
   }
 
   test_moveNext() {
     TaskManager manager = new TaskManager();
     TaskDescriptor descriptor = new TaskDescriptor(
         'task', null, (_) => {}, [new ResultDescriptor('result', null)]);
-    WorkItem workItem = new WorkItem(null, null, descriptor, null);
+    WorkItem workItem = new WorkItem(null, null, descriptor, null, null);
     WorkOrder order = new WorkOrder(manager, workItem);
     // "item" has no child items
     expect(order.moveNext(), isTrue);
     expect(order.current, workItem);
     // done
     expect(order.moveNext(), isFalse);
     expect(order.current, isNull);
   }
 }
 
@@ skipping 47 matching lines @@
         return dependency;
       }
     }
     return null;
   }
 }
 
 class _WorkManagerMock extends TypedMock implements WorkManager {
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }