Implementation of the 'analysis.getErrors' API.

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 148 matching lines @@
   Set<ServerService> serverServices = new HashSet<ServerService>();
 
   /**
    * 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>();
+
+  /**
    * 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
@@ skipping 34 matching lines @@
   }
 
   /**
    * Send the given [notification] to the client.
    */
   void sendNotification(Notification notification) {
     channel.sendNotification(notification);
   }
 
   /**
+   * Send the given [response] to the client.
+   */
+  void sendResponse(Response response) {
+    channel.sendResponse(response);
+  }
+
+  /**
    * Set the priority files to the given [files].
    */
   void setPriorityFiles(Request request, List<String> files) {
     Map<AnalysisContext, List<Source>> sourceMap =
         new HashMap<AnalysisContext, List<Source>>();
     List<String> unanalyzed = new List<String>();
     files.forEach((file) {
       AnalysisContext analysisContext = getAnalysisContext(file);
       if (analysisContext == null) {
         unanalyzed.add(file);
@@ skipping 87 matching lines @@
 //  }
 
   /**
    * Handle a [request] that was read from the communication channel.
    */
   void handleRequest(Request request) {
     int count = handlers.length;
     for (int i = 0; i < count; i++) {
       try {
         Response response = handlers[i].handleRequest(request);
+        if (response == Response.DELAYED_RESPONSE) {
+          return;
+        }
         if (response != null) {
           channel.sendResponse(response);
           return;
         }
       } on RequestFailure catch (exception) {
         channel.sendResponse(exception.response);
         return;
       }
     }
     channel.sendResponse(new Response.unknownRequest(request));
@@ skipping 270 matching lines @@
       AstNode node = new NodeLocator.con1(offset).searchWithin(unit);
       Element element = ElementLocator.locateWithOffset(node, offset);
       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.
+   */
+  Future onFileAnalysisComplete(String file) {
+    // prepare AnalysisContext

[Paul Berry, 2014/07/22 21:10:24]

I can see three areas where we might want to improve this function in future
CL's.  Can we add TODO comments for them?

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.

[scheglov, 2014/07/22 21:23:24]

  Unfortunately, there is no mechanism in the analysis engine to guaranty that
the file's analysis is finished.
  It is the same problem IntelliJ plug-in has - we don't want to wait for any
specific phase to be done.
  Hm... Or may be it is OK in the server, because we control both Engine and
Server implementations.

  It's still tricky for HTML files, which may be Angular templates.
  Or with analysis plug-ins in the general case.

  I will add TODO, we can decide later how to solve it.
  OK

+    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];
+    if (completer != null) {
+      completer.complete();
+    }
+  }
+
+  /**
    * 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);
 }