Compute TYPE_PROVIDER using BuildTypeProviderTask.

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 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/src/cancelable_future.dart';
@@ skipping 122 matching lines @@
     WorkOrder workOrder = driver.createNextWorkOrder();
     expect(workOrder, isNotNull);
     expect(workOrder.moveNext(), true);
     expect(workOrder.currentItem.target, priorityTarget);
   }
 
   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]);
+    context.getCacheEntry(target).setErrorState(
+        exception, <ResultDescriptor>[result]);
 
     expect(driver.createWorkOrderForResult(target, result), isNull);
   }
 
   test_createWorkOrderForResult_inProcess() {
     AnalysisTarget target = new TestSource();
     ResultDescriptor result = new ResultDescriptor('result', null);
     context.getCacheEntry(target).setState(result, CacheState.IN_PROCESS);
 
     expect(driver.createWorkOrderForResult(target, result), isNull);
@@ skipping 71 matching lines @@
   test_performAnalysisTask_inputsFirst() {
     AnalysisTarget target = new TestSource();
     ResultDescriptor resultA = new ResultDescriptor('resultA', -1);
     ResultDescriptor resultB = new ResultDescriptor('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
-    ]);
+        (context, target) => task2, (target) => {
+      'inputA': new SimpleTaskInput<int>(target, resultA)
+    }, [resultB]);
     task1 = new TestAnalysisTask(context, target,
         descriptor: descriptor1, results: [resultA], value: 10);
     task2 = new TestAnalysisTask(context, target,
         descriptor: descriptor2, value: 20);
     manager.addTaskDescriptor(descriptor1);
     manager.addTaskDescriptor(descriptor2);
     context.explicitTargets.add(target);
     manager.addGeneralResult(resultB);
     // prepare work order
     expect(driver.performAnalysisTask(), true);
@@ skipping 58 matching lines @@
     driver.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.inputFor(target)}, [
-      new ResultDescriptor('output', null)
-    ]);
+        (target) => {'one': inputResult.inputFor(target)},
+        [new ResultDescriptor('output', null)]);
     driver.currentWorkOrder =
         new WorkOrder(manager, new WorkItem(null, null, descriptor));
 
     driver.reset();
     expect(driver.currentWorkOrder, isNull);
   }
 
   /**
    * [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
@@ skipping 47 matching lines @@
         (target) => {}, [new ResultDescriptor('output', null)]);
     WorkItem item = new WorkItem(context, target, descriptor);
     AnalysisTask task = item.buildTask();
     expect(task, isNotNull);
   }
 
   test_buildTask_incomplete() {
     AnalysisContext context = new _TestContext();
     AnalysisTarget target = new TestSource();
     ResultDescriptor inputResult = new ResultDescriptor('input', null);
-    List<ResultDescriptor> outputResults = <ResultDescriptor>[
-      new ResultDescriptor('output', 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.inputFor(target)}, outputResults);
     WorkItem item = new WorkItem(context, target, descriptor);
     expect(() => item.buildTask(), throwsStateError);
   }
 
   test_create() {
     AnalysisContext context = new _TestContext();
     AnalysisTarget target = new TestSource();
@@ skipping 37 matching lines @@
     expect(item.gatherInputs(manager), isNotNull);
   }
 
   test_gatherInputs_invalid() {
     TaskManager manager = new TaskManager();
     AnalysisContext context = new _TestContext();
     AnalysisTarget target = new TestSource();
     ResultDescriptor inputResult = new ResultDescriptor('input', null);
     TaskDescriptor descriptor = new TaskDescriptor('task',
         (context, target) => new TestAnalysisTask(context, target),
-        (target) => {'one': inputResult.inputFor(target)}, [
-      new ResultDescriptor('output', null)
-    ]);
+        (target) => {'one': inputResult.inputFor(target)},
+        [new ResultDescriptor('output', null)]);
     WorkItem item = new WorkItem(context, target, descriptor);
     WorkItem result = item.gatherInputs(manager);
     expect(result, isNull);
     expect(item.exception, isNotNull);
   }
 }
 
 @reflectiveTest
 class WorkOrderTest extends EngineTestCase {
   test_create() {
@@ skipping 100 matching lines @@
   @override
   List<Source> get sources => baseContext.sources;
 
   @override
   AnalysisContextStatistics get statistics => baseContext.statistics;
 
   @override
   TypeProvider get typeProvider => baseContext.typeProvider;
 
   @override
+  void set typeProvider(TypeProvider typeProvider) {
+    baseContext.typeProvider = typeProvider;
+  }
+
+  @override
   TypeResolverVisitorFactory get typeResolverVisitorFactory =>
       baseContext.typeResolverVisitorFactory;
 
   @override
   void addListener(AnalysisListener listener) {
     baseContext.addListener(listener);
   }
 
   @override
   void addSourceInfo(Source source, SourceEntry info) {
@@ skipping 250 matching lines @@
   void setContents(Source source, String contents) {
     baseContext.setContents(source, contents);
   }
 
   @override
   void visitCacheItems(void callback(Source source, SourceEntry dartEntry,
       DataDescriptor rowDesc, CacheState state)) {
     baseContext.visitCacheItems(callback);
   }
 }