Catch and report exceptions in computers.

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:analysis_server/src/analysis_logger.dart';
@@ skipping 494 matching lines @@
               new RequestError(RequestErrorCode.SERVER_ERROR, exception.toString());
           if (stackTrace != null) {
             error.stackTrace = stackTrace.toString();
           }
           Response response = new Response(request.id, error: error);
           channel.sendResponse(response);
           return;
         }
       }
       channel.sendResponse(new Response.unknownRequest(request));
-    }, onError: _sendServerErrorNotification);
+    }, onError: sendServerErrorNotification);
   }
 
   /**
    * Returns `true` if there is a subscription for the given [server] and [file].
    */
   bool hasAnalysisSubscription(AnalysisService service, String file) {
     Set<String> files = analysisServices[service];
     return files != null && files.contains(file);
   }
 
@@ skipping 70 matching lines @@
     // 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));
       }
-      _sendServerErrorNotification(exception, stackTrace);
+      sendServerErrorNotification(exception, stackTrace);
       shutdown();
     } finally {
       if (!operationQueue.isEmpty) {
         _schedulePerformOperation();
       } else {
         sendStatusNotification(null);
         _onAnalysisCompleteController.add(null);
       }
     }
   }
 
   /**
    * Trigger reanalysis of all files from disk.
    */
   void reanalyze() {
     // Clear any operations that are pending.
     operationQueue.clear();
     // Instruct the contextDirectoryManager to rebuild all contexts from
     // scratch.
     contextDirectoryManager.refresh();
   }
 
   /**
-   * Report to the client that the given [exception] was caught with the
-   * associated [stackTrace].
-   */
-  void reportException(dynamic exception, StackTrace stackTrace) {
-    _sendServerErrorNotification(exception, stackTrace);
-  }
-
-  /**
    * Schedules execution of the given [ServerOperation].
    */
   void scheduleOperation(ServerOperation operation) {
     addOperation(operation);
     if (!performOperationPending) {
       _schedulePerformOperation();
     }
   }
 
   /**
@@ skipping 25 matching lines @@
   }
 
   /**
    * Send the given [response] to the client.
    */
   void sendResponse(Response response) {
     channel.sendResponse(response);
   }
 
   /**
+   * Sends a `server.error` notification.
+   */
+  void sendServerErrorNotification(exception, stackTrace, {bool fatal: true}) {

[Brian Wilkerson, 2015/01/13 20:57:37]

It looks like "false" is more common than "true". Given that this controls the
value passed in the notification rather than whether server will shut down, it
might be better to reverse the default.

[scheglov, 2015/01/13 21:13:51]

Done.

+    // prepare exception.toString()
+    String exceptionString;
+    if (exception != null) {
+      exceptionString = exception.toString();
+    } else {
+      exceptionString = 'null exception';
+    }
+    // prepare stackTrace.toString()
+    String stackTraceString;
+    if (stackTrace != null) {
+      stackTraceString = stackTrace.toString();
+    } else {
+      stackTraceString = 'null stackTrace';
+    }
+    // send the notification
+    channel.sendNotification(
+        new ServerErrorParams(
+            fatal,
+            exceptionString,
+            stackTraceString).toNotification());
+  }
+
+  /**
    * Send status notification to the client. The `operation` is the operation
    * being performed or `null` if analysis is complete.
    */
   void sendStatusNotification(ServerOperation operation) {
     // Only send status when subscribed.
     if (!serverServices.contains(ServerService.STATUS)) {
       return;
     }
     // Only send status when it changes
     bool isAnalyzing = operation != null;
@@ skipping 215 matching lines @@
   }
 
   /**
    * 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();
-    } else {
-      exceptionString = 'null exception';
-    }
-    // prepare stackTrace.toString()
-    String stackTraceString;
-    if (stackTrace != null) {
-      stackTraceString = stackTrace.toString();
-    } else {
-      stackTraceString = 'null stackTrace';
-    }
-    // send the notification
-    channel.sendNotification(
-        new ServerErrorParams(
-            true,
-            exceptionString,
-            stackTraceString).toNotification());
-  }
 }
 
 
 class AnalysisServerOptions {
   bool enableIncrementalResolutionApi = false;
   bool enableIncrementalResolutionValidation = false;
 }
 
 /**
  * A [ContextsChangedEvent] indicate what contexts were added or removed.
@@ skipping 125 matching lines @@
    * [packageUriResolver].
    */
   SourceFactory _createSourceFactory(UriResolver packageUriResolver) {
     List<UriResolver> resolvers = <UriResolver>[
         new DartUriResolver(analysisServer.defaultSdk),
         new ResourceUriResolver(resourceProvider),
         packageUriResolver];
     return new SourceFactory(resolvers);
   }
 }