Fix error handling in analysis.getError.

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 45 matching lines @@
     AnalysisContext context = analysisServer.folderMap[contextFolder];
     if (context != null) {
       context.applyChanges(changeSet);
       analysisServer.schedulePerformAnalysisOperation(context);
     }
   }
 
   @override
   void removeContext(Folder folder) {
     AnalysisContext context = analysisServer.folderMap.remove(folder);
-    analysisServer.sendContextAnalysisCancelledNotifications(
+    analysisServer.sendContextAnalysisDoneNotifications(
         context,
-        'Context was removed');
+        AnalysisDoneReason.CONTEXT_REMOVED);
   }
 
   @override
   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)
     ];
     return new SourceFactory(resolvers);
   }
 }
 
+
+/**
+ * Enum representing reasons why analysis might be done for a given file.
+ */
+class AnalysisDoneReason {
+  /**
+   * Analysis of the file completed successfully.
+   */
+  static const AnalysisDoneReason COMPLETE =
+      const AnalysisDoneReason._('COMPLETE');
+
+  /**
+   * Analysis of the file was aborted because the context was removed.
+   */
+  static const AnalysisDoneReason CONTEXT_REMOVED =
+      const AnalysisDoneReason._('CONTEXT_REMOVED');
+
+  /**
+   * Textual description of this [AnalysisDoneReason].
+   */
+  final String text;
+
+  const AnalysisDoneReason._(this.text);
+}
+
+
 /**
  * Instances of the class [AnalysisServer] implement a server that listens on a
  * [CommunicationChannel] for analysis requests and process them.
  */
 class AnalysisServer {
   /**
    * The channel from which requests are received and to which responses should
    * be sent.
    */
   final ServerCommunicationChannel channel;
@@ skipping 67 matching lines @@
    * A table mapping [AnalysisService]s to the file paths for which these
    * notifications should be sent.
    */
   Map<AnalysisService, Set<String>> analysisServices =
       new HashMap<AnalysisService, Set<String>>();
 
   /**
    * A table mapping [AnalysisContext]s to the completers that should be
    * completed when analysis of this context is finished.
    */
-  Map<AnalysisContext, Completer> contextAnalysisDoneCompleters =
-      new HashMap<AnalysisContext, Completer>();
+  Map<AnalysisContext, Completer<AnalysisDoneReason>> contextAnalysisDoneCompleters =
+      new HashMap<AnalysisContext, Completer<AnalysisDoneReason>>();
 
   /**
    * 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].
@@ skipping 420 matching lines @@
       return null;
     }
     // if library has been already resolved, resolve unit
     return context.resolveCompilationUnit2(unitSource, librarySource);
   }
 
   /**
    * Return an analysis error info containing the array of all of the errors and
    * the line info associated with [file].
    *
-   * Returns `null` if [file] does not belong to any [AnalysisContext].
+   * Returns `null` if [file] does not belong to any [AnalysisContext], or the
+   * file does not exist.
    *
-   * The array of errors will be empty if [file] does not exist or if there are
-   * no errors in [file]. The errors contained in the array can be incomplete.
+   * The array of errors will be empty if there are no errors in [file]. The
+   * errors contained in the array can be incomplete.
    *
    * This method does not wait for all errors to be computed, and returns just
    * the current state.
    */
   AnalysisErrorInfo getErrors(String file) {
     // prepare AnalysisContext
     AnalysisContext context = getAnalysisContext(file);
     if (context == null) {
       return null;
     }
+    Source source = getSource(file);

[scheglov, 2014/09/03 21:24:29]

// prepare Source

...just for consistency.

[Paul Berry, 2014/09/04 14:34:07]

Done.

+    if (context.getKindOf(source) == SourceKind.UNKNOWN) {
+      return null;
+    }
     // get errors for the file
-    Source source = getSource(file);
     return context.getErrors(source);
   }
 
   /**
    * Returns resolved [CompilationUnit]s of the Dart file with the given [path].
    *
    * May be empty, but not `null`.
    */
   List<CompilationUnit> getResolvedCompilationUnits(String path) {
     List<CompilationUnit> units = <CompilationUnit>[];
@@ skipping 56 matching lines @@
       }
       if (element != null) {
         elements.add(element);
       }
     }
     return elements;
   }
 
   /**
    * Returns a [Future] completing when [file] has been completely analyzed, in
-   * particular, all its errors have been computed.
+   * particular, all its errors have been computed.  The future is completed
+   * with an [AnalysisDoneReason] indicating what caused the file's analysis to
+   * be considered complete.
+   *
+   * If the given file doesn't belong to any context, null is returned.
    *
    * TODO(scheglov) this method should be improved.
    *
    * 1. The analysis context should be told to analyze this particular file ASAP.
    *
    * 2. We should complete the future as soon as the file is analyzed (not wait
    *    until the context is completely finished)
    */
-  Future onFileAnalysisComplete(String file) {
+  Future<AnalysisDoneReason> onFileAnalysisComplete(String file) {
     // prepare AnalysisContext
     AnalysisContext context = getAnalysisContext(file);
     if (context == null) {
-      return new Future.value();
+      return null;
     }
     // schedule context analysis
     schedulePerformAnalysisOperation(context);
     // associate with the context completer
-    Completer completer = contextAnalysisDoneCompleters[context];
+    Completer<AnalysisDoneReason> completer =
+        contextAnalysisDoneCompleters[context];
     if (completer == null) {
-      completer = new Completer();
+      completer = new Completer<AnalysisDoneReason>();
       contextAnalysisDoneCompleters[context] = completer;
     }
     return completer.future;
   }
 
   /**
    * This method is called when analysis of the given [AnalysisContext] is
    * done.
    */
-  void sendContextAnalysisDoneNotifications(AnalysisContext context) {
-    Completer completer = contextAnalysisDoneCompleters.remove(context);
+  void sendContextAnalysisDoneNotifications(AnalysisContext context,
+                                            AnalysisDoneReason reason) {
+    Completer<AnalysisDoneReason> completer =
+        contextAnalysisDoneCompleters.remove(context);
     if (completer != null) {
-      completer.complete();
+      completer.complete(reason);
     }
   }
 
-  /**
-   * This method is called when analysis of the given [AnalysisContext] is
-   * cancelled.
-   */
-  void sendContextAnalysisCancelledNotifications(AnalysisContext context, String message) {
-    Completer completer = contextAnalysisDoneCompleters.remove(context);
-    if (completer != null) {
-      completer.completeError(message);
-    }
-  }
-
   void shutdown() {
     running = false;
     if (index != null) {
       index.clear();
       index.stop();
     }
     // Defer closing the channel so that the shutdown response can be sent.
     new Future(channel.close);
   }
 
@@ skipping 50 matching lines @@
       stackTraceString = 'null stackTrace';
     }
     // send the notification
     channel.sendNotification(new ServerErrorParams(true, exceptionString,
         stackTraceString).toNotification());
   }
 }
 
 
 typedef void OptionUpdater(AnalysisOptionsImpl options);