Removed fixed dependencies

packages/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;
+library analyzer.test.src.task.driver_test;
 
+import 'package:analyzer/exception/exception.dart';
 import 'package:analyzer/src/context/cache.dart';
-import 'package:analyzer/src/generated/engine.dart'
-    hide
-        AnalysisCache,
-        AnalysisContextImpl,
-        AnalysisTask,
-        UniversalCachePartition,
-        WorkManager;
-import 'package:analyzer/src/generated/java_engine.dart';
+import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/task/driver.dart';
 import 'package:analyzer/src/task/inputs.dart';
 import 'package:analyzer/src/task/manager.dart';
 import 'package:analyzer/task/model.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
 import 'package:typed_mock/typed_mock.dart';
 import 'package:unittest/unittest.dart';
 
 import '../../generated/test_support.dart';
-import '../../reflective_tests.dart';
 import '../../utils.dart';
 import 'test_support.dart';
 
 main() {
   initializeTestEnvironment();
-  runReflectiveTests(AnalysisDriverTest);
-  runReflectiveTests(CycleAwareDependencyWalkerTest);
-  runReflectiveTests(WorkItemTest);
-  runReflectiveTests(WorkOrderTest);
+  defineReflectiveTests(AnalysisDriverTest);
+  defineReflectiveTests(CycleAwareDependencyWalkerTest);
+  defineReflectiveTests(WorkItemTest);
+  defineReflectiveTests(WorkOrderTest);
 }
 
 class AbstractDriverTest {
   TaskManager taskManager = new TaskManager();
   List<WorkManager> workManagers = <WorkManager>[];
   InternalAnalysisContext context = new _InternalAnalysisContextMock();
   AnalysisDriver analysisDriver;
 
   void setUp() {
     context = new _InternalAnalysisContextMock();
     analysisDriver = new AnalysisDriver(taskManager, workManagers, context);
+    when(context.aboutToComputeResult(anyObject, anyObject)).thenReturn(false);
   }
 }
 
 @reflectiveTest
 class AnalysisDriverTest extends AbstractDriverTest {
   WorkManager workManager1 = new _WorkManagerMock();
   WorkManager workManager2 = new _WorkManagerMock();
 
   AnalysisTarget target1 = new TestSource('/1.dart');
   AnalysisTarget target2 = new TestSource('/2.dart');
@@ skipping 67 matching lines @@
 
   test_createNextWorkOrder_none() {
     _configureDescriptors12();
     when(workManager1.getNextResultPriority())
         .thenReturn(WorkOrderPriority.NONE);
     when(workManager2.getNextResultPriority())
         .thenReturn(WorkOrderPriority.NONE);
     expect(analysisDriver.createNextWorkOrder(), isNull);
   }
 
+  test_createWorkOrderForResult_aboutToComputeResult() {
+    AnalysisTarget target = new TestSource();
+    ResultDescriptor result = new ResultDescriptor('result', null);
+    TaskDescriptor descriptor = new TaskDescriptor(
+        'task',
+        (context, target) => new TestAnalysisTask(context, target),
+        (target) => {},
+        [result]);
+    taskManager.addTaskDescriptor(descriptor);
+    context.getCacheEntry(target).setState(result, CacheState.INVALID);
+    // has result
+    {
+      when(context.aboutToComputeResult(anyObject, result)).thenReturn(true);
+      WorkOrder workOrder =
+          analysisDriver.createWorkOrderForResult(target, result);
+      expect(workOrder, isNull);
+    }
+    // no result
+    {
+      when(context.aboutToComputeResult(anyObject, result)).thenReturn(false);
+      WorkOrder workOrder =
+          analysisDriver.createWorkOrderForResult(target, result);
+      expect(workOrder, isNotNull);
+    }
+  }
+
   test_createWorkOrderForResult_error() {
     AnalysisTarget target = new TestSource();
     ResultDescriptor result = new ResultDescriptor('result', null);
     CaughtException exception = new CaughtException(null, null);
     context
         .getCacheEntry(target)
         .setErrorState(exception, <ResultDescriptor>[result]);
 
     expect(analysisDriver.createWorkOrderForResult(target, result), isNull);
   }
@@ skipping 17 matching lines @@
     taskManager.addTaskDescriptor(descriptor);
     context.getCacheEntry(target).setState(result, CacheState.INVALID);
 
     WorkOrder workOrder =
         analysisDriver.createWorkOrderForResult(target, result);
     expect(workOrder, isNotNull);
   }
 
   test_createWorkOrderForResult_valid() {
     AnalysisTarget target = new TestSource();
-    ResultDescriptor result = new ResultDescriptor('result', null);
+    ResultDescriptor<String> result =
+        new ResultDescriptor<String>('result', null);
     context
         .getCacheEntry(target)
         .setValue(result, '', TargetedResult.EMPTY_LIST);
 
     expect(analysisDriver.createWorkOrderForResult(target, result), isNull);
   }
 
   test_createWorkOrderForTarget_complete_generalTarget_generalResult() {
     _createWorkOrderForTarget(true, false, false);
   }
@@ skipping 33 matching lines @@
     when(workManager1.getNextResult())
         .thenReturn(new TargetedResult(target1, result1));
 
     expect(analysisDriver.performAnalysisTask(), true);
     expect(analysisDriver.performAnalysisTask(), true);
     expect(analysisDriver.performAnalysisTask(), false);
   }
 
   test_performAnalysisTask_infiniteLoop_handled() {
     AnalysisTarget target = new TestSource();
-    ResultDescriptor resultA = new ResultDescriptor('resultA', -1);
-    ResultDescriptor resultB = new ResultDescriptor('resultB', -2);
+    ResultDescriptor<int> resultA = new ResultDescriptor<int>('resultA', -1);
+    ResultDescriptor<int> resultB = new ResultDescriptor<int>('resultB', -2);
     // configure tasks
     TestAnalysisTask task1;
     TestAnalysisTask task2;
     TaskDescriptor descriptor1 = new TaskDescriptor(
         'task1',
         (context, target) => task1,
         (target) => {'inputB': new SimpleTaskInput<int>(target, resultB)},
         [resultA]);
     TaskDescriptor descriptor2 = new TaskDescriptor(
         'task2',
@@ skipping 27 matching lines @@
     expect(task2.dependencyCycle.map((workItem) => workItem.descriptor).toSet(),
         expectedCycle);
     CaughtException exception = context.getCacheEntry(target).exception;
     expect(exception, isNull);
     expect(context.getCacheEntry(target).getValue(resultA), 10);
     expect(context.getCacheEntry(target).getValue(resultB), 20);
   }
 
   test_performAnalysisTask_infiniteLoop_unhandled() {
     AnalysisTarget target = new TestSource();
-    ResultDescriptor resultA = new ResultDescriptor('resultA', -1);
-    ResultDescriptor resultB = new ResultDescriptor('resultB', -2);
+    ResultDescriptor<int> resultA = new ResultDescriptor<int>('resultA', -1);
+    ResultDescriptor<int> resultB = new ResultDescriptor<int>('resultB', -2);
     // configure tasks
     TestAnalysisTask task1;
     TestAnalysisTask task2;
     TaskDescriptor descriptor1 = new TaskDescriptor(
         'task1',
         (context, target) => task1,
         (target) => {'inputB': new SimpleTaskInput<int>(target, resultB)},
         [resultA]);
     TaskDescriptor descriptor2 = new TaskDescriptor(
         'task2',
@@ skipping 12 matching lines @@
     // prepare work order
     expect(analysisDriver.performAnalysisTask(), true);
     expect(analysisDriver.performAnalysisTask(), true);
     CaughtException exception = context.getCacheEntry(target).exception;
     expect(exception, isNotNull);
     expect(exception.exception, new isInstanceOf<InfiniteTaskLoopException>());
   }
 
   test_performAnalysisTask_inputsFirst() {
     AnalysisTarget target = new TestSource();
-    ResultDescriptor resultA = new ResultDescriptor('resultA', -1);
-    ResultDescriptor resultB = new ResultDescriptor('resultB', -2);
+    ResultDescriptor<int> resultA = new ResultDescriptor<int>('resultA', -1);
+    ResultDescriptor<int> resultB = new ResultDescriptor<int>('resultB', -2);
     // configure tasks
     TestAnalysisTask task1;
     TestAnalysisTask task2;
     TaskDescriptor descriptor1 = new TaskDescriptor(
         'task1', (context, target) => task1, (target) => {}, [resultA]);
     TaskDescriptor descriptor2 = new TaskDescriptor(
         'task2',
         (context, target) => task2,
         (target) => {'inputA': new SimpleTaskInput<int>(target, resultA)},
         [resultB]);
@@ skipping 25 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, 0, 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, 0, 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, 0, 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, 0, 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, 0, null));
 
     analysisDriver.reset();
     expect(analysisDriver.currentWorkOrder, isNull);
   }
 
   void _configureDescriptors12() {
     descriptor1 = new TaskDescriptor(
         'task1',
         (context, target) =>
             new TestAnalysisTask(context, target, descriptor: descriptor1),
@@ skipping 13 matching lines @@
   /**
    * [complete] is `true` if the value of the result has already been computed.
    * [priorityTarget] is `true` if the target is in the list of priority
    * targets.
    * [priorityResult] is `true` if the result should only be computed for
    * priority targets.
    */
   _createWorkOrderForTarget(
       bool complete, bool priorityTarget, bool priorityResult) {
     AnalysisTarget target = new TestSource();
-    ResultDescriptor result = new ResultDescriptor('result', null);
+    ResultDescriptor<String> result =
+        new ResultDescriptor<String>('result', null);
     TaskDescriptor descriptor = new TaskDescriptor(
         'task',
         (context, target) => new TestAnalysisTask(context, target),
         (target) => {},
         [result]);
     if (priorityResult) {
       taskManager.addPriorityResult(result);
     } else {
       taskManager.addGeneralResult(result);
     }
@@ skipping 143 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, 0, 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, 0, 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, 0, null);
     expect(item, isNotNull);
     expect(item.context, context);
     expect(item.descriptor, descriptor);
     expect(item.target, target);
   }
 
+  test_gatherInputs_aboutToComputeResult_hasResult() {
+    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);
+    // configure mocks
+    when(context.aboutToComputeResult(anyObject, resultA)).thenReturn(true);
+    // gather inputs
+    WorkItem item = new WorkItem(context, target, task2, null, 0, null);
+    WorkItem inputItem = item.gatherInputs(taskManager, []);
+    expect(inputItem, isNull);
+  }
+
+  test_gatherInputs_aboutToComputeResult_noResult() {
+    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);
+    // configure ResultProvider
+    // configure mocks
+    when(context.aboutToComputeResult(anyObject, resultA)).thenReturn(false);
+    // gather inputs
+    WorkItem item = new WorkItem(context, target, task2, null, 0, null);
+    WorkItem inputItem = item.gatherInputs(taskManager, []);
+    expect(inputItem, isNotNull);
+    expect(inputItem.target, target);
+    expect(inputItem.descriptor, task1);
+  }
+
   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, 0, 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, 0, 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, 0, 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, 0, 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, 0, 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);
   }
 }
 
 /**
  * A dummy [InternalAnalysisContext] that does not use [AnalysisDriver] itself,
  * but provides enough implementation for it to function.
  */
 class _InternalAnalysisContextMock extends TypedMock
     implements InternalAnalysisContext {
   AnalysisCache analysisCache;
 
   @override
+  final AnalysisOptionsImpl analysisOptions = new AnalysisOptionsImpl();
+
+  @override
   List<AnalysisTarget> explicitTargets = <AnalysisTarget>[];
 
   @override
   List<AnalysisTarget> priorityTargets = <AnalysisTarget>[];
 
   _InternalAnalysisContextMock() {
     analysisCache = new AnalysisCache([new UniversalCachePartition(this)]);
   }
 
   @override
   CacheEntry getCacheEntry(AnalysisTarget target) {
     CacheEntry entry = analysisCache.get(target);
     if (entry == null) {
       entry = new CacheEntry(target);
       analysisCache.put(entry);
     }
     return entry;
   }
-
-  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 /**
  * Concrete class for testing [CycleAwareDependencyWalker] behavior.
  */
 class _TestCycleAwareDependencyWalker extends CycleAwareDependencyWalker<int> {
   final Map<int, List<int>> graph;
 
   Set<int> evaluatedNodes = new Set<int>();
 
   _TestCycleAwareDependencyWalker(this.graph, int startingNode)
       : super(startingNode);
 
   @override
   int getNextInput(int node, List<int> skipInputs) {
     for (int dependency in graph[node]) {
       if (!skipInputs.contains(dependency) &&
           !evaluatedNodes.contains(dependency)) {
         return dependency;
       }
     }
     return null;
   }
 }
 
-class _WorkManagerMock extends TypedMock implements WorkManager {
-  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
-}
+class _WorkManagerMock extends TypedMock implements WorkManager {}