Analyze priority files first.

pkg/analyzer/lib/src/dart/analysis/driver.dart

 // Copyright (c) 2016, 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.
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 90 matching lines @@
    */
   final AnalysisOptions _analysisOptions;
 
   /**
    * The combined unlinked and linked package for the SDK, extracted from
    * the given [_sourceFactory].
    */
   PackageBundle _sdkBundle;
 
   /**
+   * The set of explicitly analyzed files.
+   */
+  final _explicitFiles = new LinkedHashSet<String>();
+
+  /**
+   * The set of priority files, that should be analyzed sooner.
+   */
+  final _priorityFiles = new LinkedHashSet<String>();
+
+  /**
    * The mapping from the files for which analysis was requested using
    * [getResult] to the [Completer]s to report the result.
    */
   final _requestedFiles = <String, List<Completer<AnalysisResult>>>{};
 
   /**
-   * The set of explicitly analyzed files.
-   */
-  final _explicitFiles = new LinkedHashSet<String>();
-
-  /**
    * The set of files were reported as changed through [changeFile] and not
    * checked for actual changes yet.
    */
   final _changedFiles = new LinkedHashSet<String>();
 
   /**
    * The set of files that are currently scheduled for analysis.
    */
   final _filesToAnalyze = new LinkedHashSet<String>();
 
@@ skipping 37 matching lines @@
   /**
    * Set the list of files that the driver should try to analyze sooner.
    *
    * Every path in the list must be absolute and normalized.
    *
    * The driver will produce the results through the [results] stream. The
    * exact order in which results are produced is not defined, neither
    * between priority files, nor between priority and non-priority files.
    */
   void set priorityFiles(List<String> priorityPaths) {
-    // TODO(scheglov) implement
+    _priorityFiles.clear();
+    _priorityFiles.addAll(priorityPaths);
+    _hasWork.notify();
   }
 
   /**
    * Return the [Stream] that produces [AnalysisResult]s for added files.
    *
    * Analysis starts when the client starts listening to the stream, and stops
    * when the client cancels the subscription.
    *
    * When the client starts listening, the analysis state transitions to
    * "analyzing" and an analysis result is produced for every added file prior
@@ skipping 23 matching lines @@
 
         // Verify all changed files one at a time.
         if (_changedFiles.isNotEmpty) {
           String path = _removeFirst(_changedFiles);
           _verifyApiSignatureOfChangedFile(path);
           // Repeat the processing loop.
           _hasWork.notify();
           continue;
         }
 
-        // Analyze the first file in the general queue.
+        // TODO(scheglov) analyze requested files
+
+        // Analyze a priority file.
+        if (_priorityFiles.isNotEmpty) {
+          bool analyzed = false;
+          for (String path in _priorityFiles) {
+            if (_filesToAnalyze.remove(path)) {
+              _File file = _fileForPath(path);
+              AnalysisResult result = _computeAnalysisResult(file);
+              yield result;
+              break;

[Paul Berry, 2016/10/31 16:51:40]

Do need to set `analyzed = true` here?  Otherwise it looks like the code below
(lines 245 and 246) will be unreachable.

[scheglov, 2016/10/31 17:38:52]

Yes, you are right, we need to set `analyzed = true`.
I noticed and fixed this later in one of the CLs.

+            }
+          }
+          // Repeat the processing loop.
+          if (analyzed) {
+            _hasWork.notify();
+            continue;
+          }
+        }
+
+        // Analyze a general file.
         if (_filesToAnalyze.isNotEmpty) {
           String path = _removeFirst(_filesToAnalyze);
           _File file = _fileForPath(path);
           AnalysisResult result = _computeAnalysisResult(file);
           yield result;
           // Repeat the processing loop.
           _hasWork.notify();
           continue;
         }
 
         // There is nothing to do.
         analysisSection.exit();
         analysisSection = null;
       }
-      // TODO(scheglov) implement
     } finally {
       print('The stream was cancelled.');
     }
   }
 
   /**
    * Add the file with the given [path] to the set of files to analyze.
    *
    * The [path] must be absolute and normalized.
    *
@@ skipping 743 matching lines @@
       }
     }
     for (UnlinkedExportPublic export in unit.publicNamespace.exports) {
       referenced.exported.add(export.uri);
     }
     return referenced;
   }
 
   _ReferencedUris._();
 }