Use WorkManager(s) in AnalysisDriver.

pkg/analyzer/lib/src/context/context.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.context.context;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/src/cancelable_future.dart';
 import 'package:analyzer/src/context/cache.dart' as cache;
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element.dart';
-import 'package:analyzer/src/generated/engine.dart';
+import 'package:analyzer/src/generated/engine.dart' hide WorkManager;
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/html.dart' as ht;
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/sdk.dart' show DartSdk;
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/utilities_collection.dart';
 import 'package:analyzer/src/task/dart.dart';
+import 'package:analyzer/src/task/dart_work_manager.dart';
 import 'package:analyzer/src/task/driver.dart';
 import 'package:analyzer/src/task/manager.dart';
 import 'package:analyzer/task/dart.dart';
 import 'package:analyzer/task/general.dart';
 import 'package:analyzer/task/model.dart';
 
 /**
  * Type of callback functions used by PendingFuture. Functions of this type
  * should perform a computation based on the data in [entry] and return it. If
  * the computation can't be performed yet because more analysis is needed,
@@ skipping 55 matching lines @@
    * are stored.
    */
   cache.AnalysisCache _cache;
 
   /**
    * The task manager used to manage the tasks used to analyze code.
    */
   TaskManager _taskManager;
 
   /**
+   * The [DartWorkManager] instance that performs Dart specific scheduling.
+   */
+  DartWorkManager dartWorkManager;
+
+  /**
    * The analysis driver used to perform analysis.
    */
-  AnalysisDriver _driver;
+  AnalysisDriver driver;
 
   /**
    * A list containing sources for which data should not be flushed.
    */
   List<Source> _priorityOrder = <Source>[];
 
   /**
    * A map from all sources for which there are futures pending to a list of
    * the corresponding PendingFuture objects.  These sources will be analyzed
    * in the same way as priority sources, except with higher priority.
@@ skipping 63 matching lines @@
    */
   LibraryResolverFactory libraryResolverFactory;
 
   /**
    * Initialize a newly created analysis context.
    */
   AnalysisContextImpl() {
     _privatePartition = new cache.UniversalCachePartition(this);
     _cache = createCacheFromSourceFactory(null);
     _taskManager = AnalysisEngine.instance.taskManager;
-    _driver = new AnalysisDriver(_taskManager, this);
+    // TODO(scheglov) Get WorkManager(Factory)(s) from plugins.
+    dartWorkManager = new DartWorkManager(this);
+    driver =
+        new AnalysisDriver(_taskManager, <WorkManager>[dartWorkManager], this);
     _onSourcesChangedController =
         new StreamController<SourcesChangedEvent>.broadcast();
   }
 
   @override
   cache.AnalysisCache get analysisCache => _cache;
 
   @override
   AnalysisOptions get analysisOptions => _options;
 
@@ skipping 290 matching lines @@
         .forEach((Source source, ChangeSet_ContentChange change) {
       _contentRangeChanged(source, change.contents, change.offset,
           change.oldLength, change.newLength);
     });
     for (Source source in changeSet.deletedSources) {
       _sourceDeleted(source);
     }
     for (Source source in removedSources) {
       _sourceRemoved(source);
     }
+    dartWorkManager.applyChange(
+        changeSet.addedSources, changeSet.changedSources, removedSources);
     _onSourcesChangedController.add(new SourcesChangedEvent(changeSet));
   }
 
   @override
   String computeDocumentationComment(Element element) {
     if (element == null) {
       return null;
     }
     Source source = element.source;
     if (source == null) {
@@ skipping 549 matching lines @@
     if (!AnalysisEngine.isHtmlFileName(source.shortName)) {
       return null;
     }
     // TODO(brianwilkerson) Implement HTML analysis.
     return null; //_computeResult(source, null);
   }
 
   @override
   AnalysisResult performAnalysisTask() {
     return PerformanceStatistics.performAnaysis.makeCurrentWhile(() {
-      bool done = !_driver.performAnalysisTask();
+      bool done = !driver.performAnalysisTask();
       if (done) {
         done = !_validateCacheConsistency();
       }
       List<ChangeNotice> notices = _getChangeNotices(done);
       if (notices != null) {
         int noticeCount = notices.length;
         for (int i = 0; i < noticeCount; i++) {
           ChangeNotice notice = notices[i];
           _notifyErrors(notice.source, notice.errors, notice.lineInfo);
         }
@@ skipping 100 matching lines @@
       int oldLength, int newLength) {
     if (_contentRangeChanged(source, contents, offset, oldLength, newLength)) {
       _onSourcesChangedController.add(new SourcesChangedEvent.changedRange(
           source, contents, offset, oldLength, newLength));
     }
   }
 
   @override
   void setContents(Source source, String contents) {
     _contentsChanged(source, contents, true);
+    dartWorkManager.applyChange(
+        Source.EMPTY_LIST, <Source>[source], Source.EMPTY_LIST);
   }
 
   @override
   void visitCacheItems(void callback(Source source, SourceEntry dartEntry,
       DataDescriptor rowDesc, CacheState state)) {
     // TODO(brianwilkerson) Figure out where this is used and adjust the call
     // sites to use CacheEntry's.
 //    bool hintsEnabled = _options.hint;
 //    bool lintsEnabled = _options.lint;
 //    MapIterator<AnalysisTarget, cache.CacheEntry> iterator = _cache.iterator();
@@ skipping 103 matching lines @@
       return SourcePriority.NORMAL_PART;
     }
     return SourcePriority.UNKNOWN;
   }
 
   Object /*V*/ _computeResult(
       AnalysisTarget target, ResultDescriptor /*<V>*/ descriptor) {
     cache.CacheEntry entry = getCacheEntry(target);
     CacheState state = entry.getState(descriptor);
     if (state == CacheState.FLUSHED || state == CacheState.INVALID) {
-      _driver.computeResult(target, descriptor);
+      driver.computeResult(target, descriptor);
     }
     state = entry.getState(descriptor);
     if (state == CacheState.ERROR) {
       throw new AnalysisException(
           'Cannot compute $descriptor for $target', entry.exception);
     }
     return entry.getValue(descriptor);
   }
 
   /**
@@ skipping 749 matching lines @@
     PendingFuture pendingFuture =
         new PendingFuture<T>(_context, target, computeValue);
     if (!pendingFuture.evaluate(entry)) {
       _context._pendingFutureTargets
           .putIfAbsent(target, () => <PendingFuture>[])
           .add(pendingFuture);
     }
     return pendingFuture.future;
   }
 }