Send any logError() information to the IDE.

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 'dart:core' hide Resource;
 import 'dart:math' show max;
 
-import 'package:analysis_server/plugin/analysis/analyzed_files.dart';
 import 'package:analysis_server/plugin/analysis/resolver_provider.dart';
 import 'package:analysis_server/plugin/protocol/protocol.dart' hide Element;
 import 'package:analysis_server/src/analysis_logger.dart';
 import 'package:analysis_server/src/channel/channel.dart';
 import 'package:analysis_server/src/context_manager.dart';
 import 'package:analysis_server/src/operation/operation.dart';
 import 'package:analysis_server/src/operation/operation_analysis.dart';
 import 'package:analysis_server/src/operation/operation_queue.dart';
 import 'package:analysis_server/src/plugin/server_plugin.dart';
 import 'package:analysis_server/src/services/correction/namespace.dart';
@@ skipping 288 matching lines @@
     ServerContextManagerCallbacks contextManagerCallbacks =
         new ServerContextManagerCallbacks(this, resourceProvider);
     contextManager.callbacks = contextManagerCallbacks;
     defaultContextOptions.incremental = true;
     defaultContextOptions.incrementalApi =
         options.enableIncrementalResolutionApi;
     defaultContextOptions.incrementalValidation =
         options.enableIncrementalResolutionValidation;
     defaultContextOptions.generateImplicitErrors = false;
     _noErrorNotification = options.noErrorNotification;
-    AnalysisEngine.instance.logger = new AnalysisLogger();
+    AnalysisEngine.instance.logger = new AnalysisLogger(this);
     _onAnalysisStartedController = new StreamController.broadcast();
     _onFileAnalyzedController = new StreamController.broadcast();
     _onPriorityChangeController =
         new StreamController<PriorityChangeEvent>.broadcast();
     running = true;
     onAnalysisStarted.first.then((_) {
       onAnalysisComplete.then((_) {
         performanceAfterStartup = new ServerPerformance();
         _performance = performanceAfterStartup;
       });
@@ skipping 374 matching lines @@
               error.stackTrace = stackTrace.toString();
             }
             Response response = new Response(request.id, error: error);
             channel.sendResponse(response);
             return;
           }
         }
         channel.sendResponse(new Response.unknownRequest(request));
       });
     }, onError: (exception, stackTrace) {
-      sendServerErrorNotification(exception, stackTrace, fatal: true);
+      sendServerErrorNotification(
+          'Failed to handle request: ${request.toJson()}',
+          exception,
+          stackTrace,
+          fatal: true);
     });
   }
 
   /**
    * Returns `true` if there is a subscription for the given [service] and
    * [file].
    */
   bool hasAnalysisSubscription(AnalysisService service, String file) {
     Set<String> files = analysisServices[service];
     return files != null && files.contains(file);
@@ skipping 60 matching lines @@
       // loop is in progress.  No problem; we just need to exit the operation
       // loop and wait for the next operation to be added.
       ServerPerformanceStatistics.idle.makeCurrent();
       return;
     }
     sendStatusNotification(operation);
     // perform the operation
     try {
       operation.perform(this);
     } catch (exception, stackTrace) {
-      AnalysisEngine.instance.logger.logError("${exception}\n${stackTrace}");
+      sendServerErrorNotification(
+          'Failed to perform operation: $operation', exception, stackTrace,
+          fatal: true);
       if (rethrowExceptions) {
         throw new AnalysisException('Unexpected exception during analysis',
             new CaughtException(exception, stackTrace));
       }
-      sendServerErrorNotification(exception, stackTrace, fatal: true);
       shutdown();
     } finally {
       if (_test_onOperationPerformedCompleter != null) {
         _test_onOperationPerformedCompleter.complete(operation);
         _test_onOperationPerformedCompleter = null;
       }
       if (!operationQueue.isEmpty) {
         ServerPerformanceStatistics.intertask.makeCurrent();
         _schedulePerformOperation();
       } else {
@@ skipping 69 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: false}) {
+  void sendServerErrorNotification(String msg, exception, stackTrace,
+      {bool fatal: false}) {
     // prepare exception.toString()
     String exceptionString;
     if (exception != null) {
       exceptionString = exception.toString();
     } else {
       exceptionString = 'null exception';
     }
+    // prepare message
+    String message = msg != null ? '$msg\n$exceptionString' : exceptionString;
     // prepare stackTrace.toString()
     String stackTraceString;
     if (stackTrace != null) {
       stackTraceString = stackTrace.toString();
     } else {
       try {
         throw 'ignored';
       } catch (ignored, stackTrace) {
         stackTraceString = stackTrace.toString();
       }
       if (stackTraceString == null) {
         // This code should be unreachable.
         stackTraceString = 'null stackTrace';
       }
     }
     // send the notification
     channel.sendNotification(
-        new ServerErrorParams(fatal, exceptionString, stackTraceString)
+        new ServerErrorParams(fatal, message, 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)) {
@@ skipping 705 matching lines @@
   /**
    * The [PerformanceTag] for time spent in server request handlers.
    */
   static PerformanceTag serverRequests = new PerformanceTag('serverRequests');
 
   /**
    * The [PerformanceTag] for time spent in split store microtasks.
    */
   static PerformanceTag splitStore = new PerformanceTag('splitStore');
 }