Add a boolean which causes AnalysisServer to rethrow exceptions.

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';
 import 'package:analysis_server/src/constants.dart';
 import 'package:analysis_server/src/context_directory_manager.dart';
 import 'package:analysis_server/src/domain_analysis.dart';
 import 'package:analysis_server/src/protocol.dart';
 import 'package:analysis_server/src/resource.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/sdk_io.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analysis_server/src/computers.dart';
+import 'package:analyzer/src/generated/java_engine.dart';
 
 
 /**
  * An instance of [DirectoryBasedDartSdk] that is shared between
  * [AnalysisServer] instances to improve performance.
  */
 final DirectoryBasedDartSdk SHARED_SDK = DirectoryBasedDartSdk.defaultSdk;
 
 class AnalysisServerContextDirectoryManager extends ContextDirectoryManager {
   final AnalysisServer analysisServer;
@@ skipping 84 matching lines @@
    */
   Set<ServerService> serverServices = new Set<ServerService>();
 
   /**
    * A table mapping [AnalysisService]s to the file paths for which these
    * notifications should be sent.
    */
   Map<AnalysisService, Set<String>> analysisServices = <AnalysisService, Set<String>>{};
 
   /**
+   * True if any exceptions thrown by analysis should be propagated up the call
+   * stack.
+   */
+  bool rethrowExceptions;
+
+  /**
    * Initialize a newly created server to receive requests from and send
    * responses to the given [channel].
+   *
+   * If [rethrowExceptions] is true, then any exceptions thrown by analysis are
+   * propagated up the call stack.  The default is true to allow analysis
+   * exceptions to show up in unit tests, but it should be set to false when
+   * running a full analysis server.
    */
-  AnalysisServer(this.channel, ResourceProvider resourceProvider) {
+  AnalysisServer(this.channel, ResourceProvider resourceProvider,
+      {this.rethrowExceptions: true}) {
     contextDirectoryManager = new AnalysisServerContextDirectoryManager(this, resourceProvider);
     AnalysisEngine.instance.logger = new AnalysisLogger();
     running = true;
     Notification notification = new Notification(NOTIFICATION_CONNECTED);
     channel.sendNotification(notification);
     channel.listen(handleRequest, onDone: done, onError: error);
   }
 
   /**
    * If [running] is true, add the given [context] to the list of analysis
@@ skipping 75 matching lines @@
       // performAnalysisTask that will be called when the task has been computed
       // but before it is performed and send notification in the function:
       //
       // AnalysisResult result = context.performAnalysisTask((taskDescription) {
       //   sendStatusNotification(context.toString(), taskDescription);
       // });
       //
       sendStatusNotification(context.toString());
       AnalysisResult result = context.performAnalysisTask();
       notices = result.changeNotices;
+    } catch (exception, stackTrace) {
+      AnalysisEngine.instance.logger.logError("${exception}\n${stackTrace}");
+      if (rethrowExceptions) {
+        throw new AnalysisException(
+            'Unexpected exception during analysis',
+            new CaughtException(exception, stackTrace));
+      }
     } 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 {
         sendNotices(notices);
       }
@@ skipping 206 matching lines @@
   }
 
   /**
    * 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}");
-    });
+    new Future(performTask);
   }
 }
 
 
 /**
  * An enumeration of the services provided by the analysis domain.
  */
 class AnalysisService extends Enum2<AnalysisService> {
   static const AnalysisService ERRORS = const AnalysisService('ERRORS', 0);
   static const AnalysisService HIGHLIGHTS = const AnalysisService('HIGHLIGHTS', 1);
@@ skipping 54 matching lines @@
 /**
  * An enumeration of the services provided by the server domain.
  */
 class ServerService extends Enum2<ServerService> {
   static const ServerService STATUS = const ServerService('STATUS', 0);
 
   static const List<ServerService> VALUES = const [STATUS];
 
   const ServerService(String name, int ordinal) : super(name, ordinal);
 }