Send responses for any pending 'analysis.getErrors' requests during context removal.

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 38 matching lines @@
     AnalysisContext context = AnalysisEngine.instance.createAnalysisContext();
     analysisServer.folderMap[folder] = context;
     context.sourceFactory = _createSourceFactory(packageMap);
     context.analysisOptions = new AnalysisOptionsImpl.con1(defaultOptions);
     analysisServer.schedulePerformAnalysisOperation(context);
   }
 
   @override
   void applyChangesToContext(Folder contextFolder, ChangeSet changeSet) {
     AnalysisContext context = analysisServer.folderMap[contextFolder];
-    context.applyChanges(changeSet);
-    analysisServer.schedulePerformAnalysisOperation(context);
+    if (context != null) {

[Paul Berry, 2014/07/23 15:06:51]

This check shouldn't be necessary.  The caller will only call
applyChangesToContext() on folders that have an associated context.

[scheglov, 2014/07/24 16:54:04]

We need this in case if "folder removed" watch event happens before some "file
changed" event.
I trigger this situation in the test, because I remove the context before events
for "addFile" are handled.

[Paul Berry, 2014/07/24 17:32:04]

I believe this won't ever happen in production code, and is unnecessary to unit
test for.  If you look at ContextDirectoryManager._destroyContext(), it cancels
the subscription that is watching for "file changed" events before calling
removeContext().  

But I guess I'm ok with leaving this check in as defensive coding.

+      context.applyChanges(changeSet);
+      analysisServer.schedulePerformAnalysisOperation(context);
+    }
   }
 
   @override
   void removeContext(Folder folder) {
-    analysisServer.folderMap.remove(folder);
+    AnalysisContext context = analysisServer.folderMap.remove(folder);
+    if (context != null) {

[Paul Berry, 2014/07/23 15:06:51]

Similar situation with this check.

[scheglov, 2014/07/24 16:54:03]

OK

I think we can trust watcher that it won't tell us about removing the same
folder twice unless if it was recreated, so that there is also a corresponding
AnalysisContext.

+      analysisServer.sendContextAnalysisCancelledNotifications(
+          context,
+          'Context was removed');
+    }
   }
 
   @override
   void updateContextPackageMap(Folder contextFolder,
                                Map<String, List<Folder>> packageMap) {
     AnalysisContext context = analysisServer.folderMap[contextFolder];
     context.sourceFactory = _createSourceFactory(packageMap);
     analysisServer.schedulePerformAnalysisOperation(context);
   }
 
@@ skipping 489 matching lines @@
     // if library has not been resolved yet, the unit will be resolved later
     Source librarySource = librarySources[0];
     if (context.getLibraryElement(librarySource) == null) {
       return null;
     }
     // if library has been already resolved, resolve unit
     return context.resolveCompilationUnit2(unitSource, librarySource);
   }
 
   /**
-   * Returns all the [AnalysisErrorInfo] for [file].
-   * It does not wait for all errors to be computed, and returns just the
-   * current state.
+   * Return an analysis error info containing the array of all of the errors and
+   * the line info associated with [file].
    *
-   * May return `null`.
+   * Returns `null` if [file] does not belong to any [AnalysisContext].
+   *
+   * 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.
+   *
+   * 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;
     }
     // get errors for the file
     Source source = getSource(file);
     return context.getErrors(source);
@@ skipping 46 matching lines @@
   /**
    * Returns a [Future] completing when [file] has been completely analyzed, in
    * particular, all its errors have been computed.
    *
    * 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)
-   *
-   * 3. Since contexts can be created and deleted asynchronously as a result of
-   *    changes to the filesystem, there's a danger that the future might never
-   *    get completed. We should add a mechanism to make sure that we return an
-   *    error for any getErrors request that is unsatisfiable due to its context
-   *    being deleted.
    */
   Future onFileAnalysisComplete(String file) {
     // prepare AnalysisContext
     AnalysisContext context = getAnalysisContext(file);
     if (context == null) {
       return new Future.value();
     }
     // schedule context analysis
     schedulePerformAnalysisOperation(context);
     // associate with the context completer
     Completer completer = contextAnalysisDoneCompleters[context];
     if (completer == null) {
       completer = new Completer();
       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[context];
+    Completer completer = contextAnalysisDoneCompleters.remove(context);
     if (completer != null) {
       completer.complete();
     }
   }
 
   /**
+   * 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);
+    }
+  }
+
+  /**
    * Return the [CompilationUnit] of the Dart file with the given [path].
    * Return `null` if the file is not a part of any context.
    */
   CompilationUnit test_getResolvedCompilationUnit(String path) {
     // prepare AnalysisContext
     AnalysisContext context = getAnalysisContext(path);
     if (context == null) {
       return null;
     }
     // prepare sources
@@ skipping 45 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);
 }