update error handling to send response with stack trace

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 19 matching lines @@
 
 
 class ServerContextManager extends ContextManager {
   final AnalysisServer analysisServer;
 
   /**
    * The default options used to create new analysis contexts.
    */
   AnalysisOptionsImpl defaultOptions = new AnalysisOptionsImpl();
 
-  ServerContextManager(
-      this.analysisServer, ResourceProvider resourceProvider,
+  ServerContextManager(this.analysisServer, ResourceProvider resourceProvider,
       PackageMapProvider packageMapProvider)
       : super(resourceProvider, packageMapProvider);
 
   @override
   void addContext(Folder folder, Map<String, List<Folder>> packageMap) {
     AnalysisContext context = AnalysisEngine.instance.createAnalysisContext();
     analysisServer.folderMap[folder] = context;
     context.sourceFactory = _createSourceFactory(packageMap);
     context.analysisOptions = new AnalysisOptionsImpl.con1(defaultOptions);
     analysisServer.schedulePerformAnalysisOperation(context);
@@ skipping 13 matching lines @@
     AnalysisContext context = analysisServer.folderMap.remove(folder);
     if (analysisServer.index != null) {
       analysisServer.index.removeContext(context);
     }
     analysisServer.sendContextAnalysisDoneNotifications(
         context,
         AnalysisDoneReason.CONTEXT_REMOVED);
   }
 
   @override
-  void updateContextPackageMap(Folder contextFolder,
-                               Map<String, List<Folder>> packageMap) {
+  void updateContextPackageMap(Folder contextFolder, Map<String,
+      List<Folder>> packageMap) {
     AnalysisContext context = analysisServer.folderMap[contextFolder];
     context.sourceFactory = _createSourceFactory(packageMap);
     analysisServer.schedulePerformAnalysisOperation(context);
   }
 
   /**
    * Set up a [SourceFactory] that resolves packages using the given
    * [packageMap].
    */
   SourceFactory _createSourceFactory(Map<String, List<Folder>> packageMap) {
     List<UriResolver> resolvers = <UriResolver>[
         new DartUriResolver(analysisServer.defaultSdk),
         new ResourceUriResolver(resourceProvider),
-        new PackageMapUriResolver(resourceProvider, packageMap)
-    ];
+        new PackageMapUriResolver(resourceProvider, packageMap)];
     return new SourceFactory(resolvers);
   }
 }
 
 
 /**
  * Enum representing reasons why analysis might be done for a given file.
  */
 class AnalysisDoneReason {
   /**
@@ skipping 125 matching lines @@
    * 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, this.resourceProvider,
       PackageMapProvider packageMapProvider, this.index, this.defaultSdk,
       {this.rethrowExceptions: true}) {
     searchEngine = createSearchEngine(index);
     operationQueue = new ServerOperationQueue(this);
-    contextDirectoryManager = new ServerContextManager(
-        this, resourceProvider, packageMapProvider);
+    contextDirectoryManager =
+        new ServerContextManager(this, resourceProvider, packageMapProvider);
     AnalysisEngine.instance.logger = new AnalysisLogger();
     running = true;
     Notification notification = new ServerConnectedParams().toNotification();
     channel.sendNotification(notification);
     channel.listen(handleRequest, onDone: done, onError: error);
   }
 
   /**
    * Schedules execution of the given [ServerOperation].
    */
@@ skipping 42 matching lines @@
         if (sourceList == null) {
           sourceList = <Source>[];
           sourceMap[analysisContext] = sourceList;
         }
         sourceList.add(getSource(file));
       }
     });
     if (unanalyzed.isNotEmpty) {
       StringBuffer buffer = new StringBuffer();
       buffer.writeAll(unanalyzed, ', ');
-      throw new RequestFailure(new Response.unanalyzedPriorityFiles(request,
-          buffer.toString()));
+      throw new RequestFailure(
+          new Response.unanalyzedPriorityFiles(request, buffer.toString()));
     }
     folderMap.forEach((Folder folder, AnalysisContext context) {
       List<Source> sourceList = sourceMap[context];
       if (sourceList == null) {
         sourceList = Source.EMPTY_ARRAY;
       }
       context.analysisPriorityOrder = sourceList;
     });
   }
 
   /**
    * Use the given updaters to update the values of the options in every
    * existing analysis context.
    */
   void updateOptions(List<OptionUpdater> optionUpdaters) {
     //
     // Update existing contexts.
     //
     folderMap.forEach((Folder folder, AnalysisContext context) {
-      AnalysisOptionsImpl options = new AnalysisOptionsImpl.con1(context.analysisOptions);
+      AnalysisOptionsImpl options =
+          new AnalysisOptionsImpl.con1(context.analysisOptions);
       optionUpdaters.forEach((OptionUpdater optionUpdater) {
         optionUpdater(options);
       });
       context.analysisOptions = options;
     });
     //
     // Update the defaults used to create new contexts.
     //
     AnalysisOptionsImpl options = contextDirectoryManager.defaultOptions;
     optionUpdaters.forEach((OptionUpdater optionUpdater) {
@@ skipping 65 matching lines @@
             return;
           }
           if (response != null) {
             channel.sendResponse(response);
             return;
           }
         } on RequestFailure catch (exception) {
           channel.sendResponse(exception.response);
           return;
         } catch (exception, stackTrace) {
-          _sendServerErrorNotification(exception, stackTrace);
-          RequestError error =
-              new RequestError(RequestErrorCode.SERVER_ERROR, 'Server Error');
+          RequestError error = new RequestError(
+              RequestErrorCode.SERVER_ERROR,
+              exception);
+          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);
   }
 
   /**
@@ skipping 92 matching lines @@
     if (!serverServices.contains(ServerService.STATUS)) {
       return;
     }
     // Only send status when it changes
     bool isAnalyzing = operation != null;
     if (statusAnalyzing == isAnalyzing) {
       return;
     }
     statusAnalyzing = isAnalyzing;
     AnalysisStatus analysis = new AnalysisStatus(isAnalyzing);
-    channel.sendNotification(new ServerStatusParams(
-        analysis: analysis).toNotification());
+    channel.sendNotification(
+        new ServerStatusParams(analysis: analysis).toNotification());
   }
 
   /**
    * Implementation for `analysis.setAnalysisRoots`.
    *
    * TODO(scheglov) implement complete projects/contexts semantics.
    *
    * The current implementation is intentionally simplified and expected
    * that only folders are given each given folder corresponds to the exactly
    * one context.
    *
    * So, we can start working in parallel on adding services and improving
    * projects/contexts support.
    */
-  void setAnalysisRoots(String requestId,
-                        List<String> includedPaths,
-                        List<String> excludedPaths) {
+  void setAnalysisRoots(String requestId, List<String> includedPaths,
+      List<String> excludedPaths) {
     try {
       contextDirectoryManager.setRoots(includedPaths, excludedPaths);
     } on UnimplementedError catch (e) {
       throw new RequestFailure(
-                  new Response.unsupportedFeature(
-                      requestId, e.message));
+          new Response.unsupportedFeature(requestId, e.message));
     }
   }
 
   /**
    * Implementation for `analysis.updateContent`.
    */
   void updateContent(String id, Map<String, dynamic> changes) {
     changes.forEach((file, change) {
       AnalysisContext analysisContext = getAnalysisContext(file);
       // TODO(paulberry): handle the case where a file is referred to by more
       // than one context (e.g package A depends on package B using a local
       // path, user has both packages open for editing in separate contexts,
       // and user modifies a file in package B).
       if (analysisContext != null) {
         Source source = getSource(file);
         if (change is AddContentOverlay) {
           analysisContext.setContents(source, change.content);
         } else if (change is ChangeContentOverlay) {
           // TODO(paulberry): an error should be generated if source is not
           // currently in the content cache.
-          TimestampedData<String> oldContents = analysisContext.getContents(
-              source);
+          TimestampedData<String> oldContents =
+              analysisContext.getContents(source);
           String newContents;
           try {
-            newContents = SourceEdit.applySequence(oldContents.data,
-                change.edits);
+            newContents =
+                SourceEdit.applySequence(oldContents.data, change.edits);
           } on RangeError {
-            throw new RequestFailure(new Response(id, error: new RequestError(
-                RequestErrorCode.INVALID_OVERLAY_CHANGE,
-                'Invalid overlay change')));
+            throw new RequestFailure(
+                new Response(
+                    id,
+                    error: new RequestError(
+                        RequestErrorCode.INVALID_OVERLAY_CHANGE,
+                        'Invalid overlay change')));
           }
           // TODO(paulberry): to aid in incremental processing it would be
           // better to use setChangedContents.
           analysisContext.setContents(source, newContents);
         } else if (change is RemoveContentOverlay) {
           analysisContext.setContents(source, null);
         } else {
           // Protocol parsing should have ensured that we never get here.
           throw new AnalysisException('Illegal change type');
         }
         schedulePerformAnalysisOperation(analysisContext);
       }
     });
   }
 
   /**
    * Implementation for `analysis.setSubscriptions`.
    */
-  void setAnalysisSubscriptions(Map<AnalysisService, Set<String>> subscriptions) {
+  void setAnalysisSubscriptions(Map<AnalysisService,
+      Set<String>> subscriptions) {
     // send notifications for already analyzed sources
     subscriptions.forEach((service, Set<String> newFiles) {
       Set<String> oldFiles = analysisServices[service];
-      Set<String> todoFiles = oldFiles != null ? newFiles.difference(oldFiles) : newFiles;
+      Set<String> todoFiles =
+          oldFiles != null ? newFiles.difference(oldFiles) : newFiles;
       for (String file in todoFiles) {
         Source source = getSource(file);
         // prepare context
         AnalysisContext context = getAnalysisContext(file);
         if (context == null) {
           continue;
         }
         // Dart unit notifications.
         if (AnalysisEngine.isDartFileName(file)) {
-          CompilationUnit dartUnit = getResolvedCompilationUnitToResendNotification(file);
+          CompilationUnit dartUnit =
+              getResolvedCompilationUnitToResendNotification(file);
           if (dartUnit != null) {
             switch (service) {
               case AnalysisService.HIGHLIGHTS:
                 sendAnalysisNotificationHighlights(this, file, dartUnit);
                 break;
               case AnalysisService.NAVIGATION:
                 // TODO(scheglov) consider support for one unit in 2+ libraries
                 sendAnalysisNotificationNavigation(this, file, dartUnit);
                 break;
               case AnalysisService.OCCURRENCES:
                 sendAnalysisNotificationOccurrences(this, file, dartUnit);
                 break;
               case AnalysisService.OUTLINE:
-                sendAnalysisNotificationOutline(this, context, source, dartUnit);
+                sendAnalysisNotificationOutline(
+                    this,
+                    context,
+                    source,
+                    dartUnit);
                 break;
               case AnalysisService.OVERRIDES:
                 sendAnalysisNotificationOverrides(this, file, dartUnit);
                 break;
             }
           }
         }
       }
     });
     // remember new subscriptions
@@ skipping 111 matching lines @@
     List<CompilationUnit> units = <CompilationUnit>[];
     // prepare AnalysisContext
     AnalysisContext context = getAnalysisContext(path);
     if (context == null) {
       return units;
     }
     // add a unit for each unit/library combination
     Source unitSource = getSource(path);
     List<Source> librarySources = context.getLibrariesContaining(unitSource);
     for (Source librarySource in librarySources) {
-      CompilationUnit unit = context.getResolvedCompilationUnit2(unitSource, librarySource);
+      CompilationUnit unit =
+          context.getResolvedCompilationUnit2(unitSource, librarySource);
       if (unit != null) {
         units.add(unit);
       }
     }
     // done
     return units;
   }
 
   /**
    * Returns [AstNode]s at the given [offset] of the given [file].
@@ skipping 72 matching lines @@
       contextAnalysisDoneCompleters[context] = completer;
     }
     return completer.future;
   }
 
   /**
    * This method is called when analysis of the given [AnalysisContext] is
    * done.
    */
   void sendContextAnalysisDoneNotifications(AnalysisContext context,
-                                            AnalysisDoneReason reason) {
+      AnalysisDoneReason reason) {
     Completer<AnalysisDoneReason> completer =
         contextAnalysisDoneCompleters.remove(context);
     if (completer != null) {
       completer.complete(reason);
     }
   }
 
   void shutdown() {
     running = false;
     if (index != null) {
@@ skipping 59 matching lines @@
       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());
+    channel.sendNotification(
+        new ServerErrorParams(
+            true,
+            exceptionString,
+            stackTraceString).toNotification());
   }
 }
 
 /**
  * An object that is listening for lifecycle events from an analysis server.
  */
 abstract class AnalysisServerListener {
   /**
    * Analysis is complete.
    */
   void analysisComplete();
 }
 
 typedef void OptionUpdater(AnalysisOptionsImpl options);