Schedule unknown priority source analysis.

pkg/analyzer/lib/src/task/dart_work_manager.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.dart_work_manager;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/generated/engine.dart'
@@ skipping 140 matching lines @@
     for (TargetedResult result in priorityResultQueue) {
       if (result.result == LIBRARY_ERRORS_READY) {
         resultsToUnschedule.add(result);
       }
     }
     priorityResultQueue.removeAll(resultsToUnschedule);
     // Schedule new targets.
     for (AnalysisTarget target in targets) {
       if (_isDartSource(target)) {
         SourceKind sourceKind = analysisCache.getValue(target, SOURCE_KIND);
-        if (sourceKind == SourceKind.LIBRARY) {
-          addPriorityResult(target, LIBRARY_ERRORS_READY);
+        if (sourceKind == SourceKind.UNKNOWN) {
+          addPriorityResult(target, SOURCE_KIND);
+        } else if (sourceKind == SourceKind.LIBRARY) {
+          _schedulePriorityLibrarySourceAnalysis(target);
         } else if (sourceKind == SourceKind.PART) {
           List<Source> libraries = context.getLibrariesContaining(target);
           for (Source library in libraries) {
             addPriorityResult(library, LIBRARY_ERRORS_READY);
           }
         }
       }
     }
   }
 
@@ skipping 89 matching lines @@
    */
   void onSourceFactoryChanged() {
     _invalidateAllLocalResolutionInformation(true);
   }
 
   @override
   void resultsComputed(
       AnalysisTarget target, Map<ResultDescriptor, dynamic> outputs) {
     // Organize sources.
     if (_isDartSource(target)) {
+      Source source = target;
       SourceKind kind = outputs[SOURCE_KIND];
       if (kind != null) {
-        unknownSourceQueue.remove(target);
-        if (kind == SourceKind.LIBRARY &&
-            context.shouldErrorsBeAnalyzed(target, null)) {
-          librarySourceQueue.add(target);
+        unknownSourceQueue.remove(source);
+        if (kind == SourceKind.LIBRARY) {
+          if (context.prioritySources.contains(source)) {
+            _schedulePriorityLibrarySourceAnalysis(source);
+          } else {
+            bool needErrors = _shouldErrorsBeComputed(source);
+            if (needErrors) {
+              librarySourceQueue.add(target);
+            }
+          }
         }
       }
     }
     // Update parts in libraries.
     if (_isDartSource(target)) {
       Source library = target;
       List<Source> includedParts = outputs[INCLUDED_PARTS];
       if (includedParts != null) {
         libraryPartsMap[library] = includedParts;
         for (Source part in includedParts) {
@@ skipping 119 matching lines @@
         List<Source> libraries = partLibrariesMap[part];
         if (libraries != null) {
           libraries.remove(library);
           _invalidateContainingLibraries(part);
         }
       }
     }
     _invalidateContainingLibraries(library);
   }
 
+  /**
+   * Schedule computing [RESOLVED_UNIT] for the given [librarySource].
+   * If errors should be computed, then schedule [LIBRARY_ERRORS_READY] instead,
+   * it also computes [RESOLVED_UNIT] in process.
+   */
+  void _schedulePriorityLibrarySourceAnalysis(Source librarySource) {
+    bool needErrors = _shouldErrorsBeComputed(librarySource);
+    if (needErrors) {
+      addPriorityResult(librarySource, LIBRARY_ERRORS_READY);
+    } else {
+      var target = new LibrarySpecificUnit(librarySource, librarySource);
+      addPriorityResult(target, RESOLVED_UNIT);
+    }
+  }
+
+  bool _shouldErrorsBeComputed(Source source) =>
+      context.shouldErrorsBeAnalyzed(source, null);
+
   static bool _isDartSource(AnalysisTarget target) {
     return target is Source && AnalysisEngine.isDartFileName(target.fullName);
   }
 }