Use AnalysisServer.running only to track whether server has been shut down.

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 'package:analysis_server/src/analysis_logger.dart';
 import 'package:analysis_server/src/channel.dart';
@@ skipping 25 matching lines @@
    */
   static const String CONNECTED_NOTIFICATION = 'server.connected';
 
   /**
    * The channel from which requests are received and to which responses should
    * be sent.
    */
   final ServerCommunicationChannel channel;
 
   /**
-   * A flag indicating whether the server is running.
+   * A flag indicating whether the server is running.  When false, contexts
+   * will no longer be added to [contextWorkQueue], and [performTask] will
+   * discard any tasks it finds on [contextWorkQueue].
    */
   bool running;
 
   /**
    * A list of the request handlers used to handle the requests sent to this
    * server.
    */
   List<RequestHandler> handlers;
 
   /**
    * A table mapping context id's to the analysis contexts associated with them.
    */
   final Map<String, AnalysisContext> contextMap = new Map<String, AnalysisContext>();
 
   /**
    * A list of the analysis contexts for which analysis work needs to be
    * performed.
+   *
+   * Invariant: when this list is non-empty, there is exactly one pending call
+   * to [performTask] on the event queue.  When this list is empty, there are
+   * no calls to [performTask] on the event queue.
    */
   final List<AnalysisContext> contextWorkQueue = new List<AnalysisContext>();
 
   /**
    * Initialize a newly created server to receive requests from and send
    * responses to the given [channel].
    */
   AnalysisServer(this.channel) {
     AnalysisEngine.instance.logger = new AnalysisLogger();
     running = true;
     Notification notification = new Notification(CONNECTED_NOTIFICATION);
     channel.sendNotification(notification);
     channel.listen(handleRequest, onDone: done, onError: error);
   }
 
   /**
-   * Add the given [context] to the list of analysis contexts for which analysis
-   * work needs to be performed. Ensure that the work will be performed.
+   * If [running] is true, add the given [context] to the list of analysis
+   * contexts for which analysis work needs to be performed, and ensure that
+   * the work will be performed.
    */
   void addContextToWorkQueue(AnalysisContext context) {
+    if (!running) {
+      return;
+    }
     if (!contextWorkQueue.contains(context)) {
       contextWorkQueue.add(context);
-      run();
+      if (contextWorkQueue.length == 1) {
+        // Work queue was previously empty, so schedule analysis.
+        _scheduleTask();
+      }
     }
   }
 
   /**
    * The socket from which requests are being read has been closed.
    */
   void done() {
     running = false;
   }
 
@@ skipping 24 matching lines @@
     }
     channel.sendResponse(new Response.unknownRequest(request));
   }
 
   /**
    * Perform the next available task. If a request was received that has not yet
    * been performed, perform it next. Otherwise, look for some analysis that
    * needs to be done and do that. Otherwise, do nothing.
    */
   void performTask() {
+    if (!running) {
+      // An error has occurred, or the connection to the client has been
+      // closed, since performTask() was scheduled on the event queue.  So
+      // don't do any analysis.  Instead clear the work queue.
+      contextWorkQueue.clear();
+    }
+    if (contextWorkQueue.isEmpty) {
+      // Nothing to do.
+      return;
+    }
     //
     // Look for a context that has work to be done and then perform one task.
     //
-    if (!contextWorkQueue.isEmpty) {
+    List<ChangeNotice> notices = null;
+    try {
       AnalysisContext context = contextWorkQueue[0];
       AnalysisResult result = context.performAnalysisTask();
-      List<ChangeNotice> notices = result.changeNotices;
+      notices = result.changeNotices;
+    } finally {
       if (notices == null) {
+        // Either we have no more work to do for this context, or there was an
+        // unhandled exception trying to perform the analysis.  In either case,
+        // remove the context form the work queue so we won't try to do more
+        // analysis on it.
         contextWorkQueue.removeAt(0);
-      } else { //if (context.analysisOptions.provideErrors) {
-        sendNotices(notices);
+      }
+      //
+      // Schedule this method to be run again if there is any more work to be
+      // done.
+      //
+      if (!contextWorkQueue.isEmpty) {
+        _scheduleTask();
       }
     }
-    //
-    // Schedule this method to be run again if there is any more work to be done.
-    //
-    if (contextWorkQueue.isEmpty) {
-      running = false;
-    } else {
-      new Future(performTask).catchError((ex, st) {
-        AnalysisEngine.instance.logger.logError("${ex}\n${st}");
-      });
+    if (notices != null) {
+      sendNotices(notices);
     }
   }
 
   /**
    * Send the information in the given list of notices back to the client.
    */
   void sendNotices(List<ChangeNotice> notices) {
     for (int i = 0; i < notices.length; i++) {
       ChangeNotice notice = notices[i];
       Notification notification = new Notification(ERROR_NOTIFICATION_NAME);
       notification.setParameter(SOURCE_PARAM, notice.source.encoding);
       notification.setParameter(ERRORS_PARAM, notice.errors);
       sendNotification(notification);
     }
   }
 
   /**
-   * Perform the tasks that are waiting for execution until the server is shut
-   * down.
-   */
-  void run() {
-    if (!running) {
-      running = true;
-      new Future(performTask).catchError((exception, stackTrace) {
-        AnalysisEngine.instance.logger.logError(exception);
-      });
-    }
-  }
-
-  /**
    * Send the given [notification] to the client.
    */
   void sendNotification(Notification notification) {
     channel.sendNotification(notification);
   }
+
+  void _scheduleTask() {
+    new Future(performTask).catchError((ex, st) {
+      AnalysisEngine.instance.logger.logError("${ex}\n${st}");
+    });
+  }
 }