Avoid analysis server crash when reanalyze invoked during analysis.

pkg/analysis_server/lib/src/analysis_server.dart

 // Copyright (c) 2014, 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 analysis.server;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/file_system/file_system.dart';
@@ skipping 162 matching lines @@
   final DartSdk defaultSdk;
 
   /**
    * A table mapping [Folder]s to the [AnalysisContext]s associated with them.
    */
   final Map<Folder, AnalysisContext> folderMap =
       new HashMap<Folder, AnalysisContext>();
 
   /**
    * A queue of the operations to perform in this server.
-   *
-   * Invariant: when this queue is non-empty, there is exactly one pending call
-   * to [performOperation] on the event queue.  When this list is empty, there are
-   * no calls to [performOperation] on the event queue.
    */
   ServerOperationQueue operationQueue;
 
   /**
+   * True if there is a pending future which will execute [performOperation].
+   */
+  bool performOperationPending = false;
+
+  /**
    * A set of the [ServerService]s to send notifications for.
    */
   Set<ServerService> serverServices = new HashSet<ServerService>();
 
   /**
    * A table mapping [AnalysisService]s to the file paths for which these
    * notifications should be sent.
    */
   Map<AnalysisService, Set<String>> analysisServices =
       new HashMap<AnalysisService, Set<String>>();
@@ skipping 60 matching lines @@
   void fileAnalyzed(ChangeNotice notice) {
     if (contextDirectoryManager.isInAnalysisRoot(notice.source.fullName)) {
       _onFileAnalyzedController.add(notice);
     }
   }
 
   /**
    * Schedules execution of the given [ServerOperation].
    */
   void scheduleOperation(ServerOperation operation) {
-    bool wasEmpty = operationQueue.isEmpty;
     addOperation(operation);
-    if (wasEmpty) {
+    if (!performOperationPending) {
       _schedulePerformOperation();
     }
   }
 
   /**
    * Schedules analysis of the given context.
    */
   void schedulePerformAnalysisOperation(AnalysisContext context) {
     _onAnalysisStartedController.add(context);
     scheduleOperation(new PerformAnalysisOperation(context, false));
@@ skipping 194 matching lines @@
    */
   bool isPriorityContext(AnalysisContext context) {
     // TODO(scheglov) implement support for priority sources/contexts
     return false;
   }
 
   /**
    * Perform the next available [ServerOperation].
    */
   void performOperation() {
+    assert(performOperationPending);
+    performOperationPending = false;
     if (!running) {
       // An error has occurred, or the connection to the client has been
       // closed, since this method was scheduled on the event queue.  So
       // don't do anything.  Instead clear the operation queue.
       operationQueue.clear();
       return;
     }
     // prepare next operation
     ServerOperation operation = operationQueue.take();
+    if (operation == null) {
+      // This can happen if the operation queue is cleared while the operation
+      // loop is in progress.  No problem; we just need to exit the operation
+      // loop and wait for the next operation to be added.
+      return;
+    }
     sendStatusNotification(operation);
     // perform the operation
     try {
       operation.perform(this);
     } catch (exception, stackTrace) {
       AnalysisEngine.instance.logger.logError("${exception}\n${stackTrace}");
       if (rethrowExceptions) {
         throw new AnalysisException(
             'Unexpected exception during analysis',
             new CaughtException(exception, stackTrace));
@@ skipping 397 matching lines @@
       index.stop();
     }
     // Defer closing the channel so that the shutdown response can be sent.
     new Future(channel.close);
   }
 
   /**
    * Schedules [performOperation] exection.
    */
   void _schedulePerformOperation() {
+    assert (!performOperationPending);
     new Future(performOperation);
+    performOperationPending = true;
   }
 
   /**
    * Sends a fatal `server.error` notification.
    */
   void _sendServerErrorNotification(exception, stackTrace) {
     // prepare exception.toString()
     String exceptionString;
     if (exception != null) {
       exceptionString = exception.toString();
@@ skipping 10 matching lines @@
     // send the notification
     channel.sendNotification(
         new ServerErrorParams(
             true,
             exceptionString,
             stackTraceString).toNotification());
   }
 }
 
 typedef void OptionUpdater(AnalysisOptionsImpl options);