Implement 'analysis.getErrors' for the new driver.

pkg/analysis_server/lib/src/domain_analysis.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 domain.analysis;
 
 import 'dart:async';
 import 'dart:core';
 
 import 'package:analysis_server/plugin/analysis/analysis_domain.dart';
 import 'package:analysis_server/src/analysis_server.dart';
 import 'package:analysis_server/src/computer/computer_hover.dart';
 import 'package:analysis_server/src/constants.dart';
 import 'package:analysis_server/src/context_manager.dart';
 import 'package:analysis_server/src/domains/analysis/navigation.dart';
 import 'package:analysis_server/src/operation/operation_analysis.dart'
     show NavigationOperation, OccurrencesOperation;
 import 'package:analysis_server/src/protocol/protocol_internal.dart';
 import 'package:analysis_server/src/protocol_server.dart';
 import 'package:analysis_server/src/services/dependencies/library_dependencies.dart';
 import 'package:analysis_server/src/services/dependencies/reachable_source_collector.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/error/error.dart' as engine;
 import 'package:analyzer/exception/exception.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/src/dart/analysis/driver.dart';
 import 'package:analyzer/src/generated/engine.dart' as engine;
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/task/model.dart' show ResultDescriptor;
 
 /**
  * Instances of the class [AnalysisDomainHandler] implement a [RequestHandler]
  * that handles requests in the `analysis` domain.
  */
 class AnalysisDomainHandler implements RequestHandler {
   /**
    * The analysis server that is using this handler to process requests.
    */
   final AnalysisServer server;
 
   /**
    * Initialize a newly created handler to handle requests for the given [server].
    */
   AnalysisDomainHandler(this.server) {
     _callAnalysisDomainReceivers();
   }
 
   /**
    * Implement the `analysis.getErrors` request.
    */
-  Response getErrors(Request request) {
+  Future<Null> getErrors(Request request) async {
     String file = new AnalysisGetErrorsParams.fromRequest(request).file;
+
+    void send(engine.AnalysisOptions analysisOptions, LineInfo lineInfo,
+        List<engine.AnalysisError> errors) {
+      if (lineInfo == null) {
+        server.sendResponse(new Response.getErrorsInvalidFile(request));
+      } else {
+        List<AnalysisError> protocolErrors =
+            doAnalysisError_listFromEngine(analysisOptions, lineInfo, errors);
+        server.sendResponse(
+            new AnalysisGetErrorsResult(protocolErrors).toResponse(request.id));
+      }
+    }
+
+    if (server.options.enableNewAnalysisDriver) {
+      var result = await server.getAnalysisResult(file);
+      send(result?.driver?.analysisOptions, result?.lineInfo, result?.errors);
+      return;
+    }
+
     Future<AnalysisDoneReason> completionFuture =
         server.onFileAnalysisComplete(file);
     if (completionFuture == null) {
-      return new Response.getErrorsInvalidFile(request);
+      server.sendResponse(new Response.getErrorsInvalidFile(request));
     }
-    completionFuture.then((AnalysisDoneReason reason) {
+    completionFuture.then((AnalysisDoneReason reason) async {
       switch (reason) {
         case AnalysisDoneReason.COMPLETE:
           engine.AnalysisErrorInfo errorInfo = server.getErrors(file);
-          List<AnalysisError> errors;
           if (errorInfo == null) {
             server.sendResponse(new Response.getErrorsInvalidFile(request));
           } else {
             engine.AnalysisContext context = server.getAnalysisContext(file);
-            errors = doAnalysisError_listFromEngine(
-                context, errorInfo.lineInfo, errorInfo.errors);
-            server.sendResponse(
-                new AnalysisGetErrorsResult(errors).toResponse(request.id));
+            send(context.analysisOptions, errorInfo.lineInfo, errorInfo.errors);
           }
           break;
         case AnalysisDoneReason.CONTEXT_REMOVED:
           // The active contexts have changed, so try again.
-          Response response = getErrors(request);
-          if (response != Response.DELAYED_RESPONSE) {
-            server.sendResponse(response);
-          }
+          await getErrors(request);
           break;
       }
     });
-    // delay response
-    return Response.DELAYED_RESPONSE;
   }
 
   /**
    * Implement the `analysis.getHover` request.
    */
   Future<Null> getHover(Request request) async {
     var params = new AnalysisGetHoverParams.fromRequest(request);
 
     // Prepare the resolved units.
     CompilationUnit unit;
@@ skipping 97 matching lines @@
             .collectSources();
     return new AnalysisGetReachableSourcesResult(sources)
         .toResponse(request.id);
   }
 
   @override
   Response handleRequest(Request request) {
     try {
       String requestName = request.method;
       if (requestName == ANALYSIS_GET_ERRORS) {
-        return getErrors(request);
+        getErrors(request);
+        return Response.DELAYED_RESPONSE;
       } else if (requestName == ANALYSIS_GET_HOVER) {
         getHover(request);
         return Response.DELAYED_RESPONSE;
       } else if (requestName == ANALYSIS_GET_LIBRARY_DEPENDENCIES) {
         return getLibraryDependencies(request);
       } else if (requestName == ANALYSIS_GET_NAVIGATION) {
         return getNavigation(request);
       } else if (requestName == ANALYSIS_GET_REACHABLE_SOURCES) {
         return getReachableSources(request);
       } else if (requestName == ANALYSIS_REANALYZE) {
@@ skipping 201 matching lines @@
       context.onResultChanged(descriptor).listen((result) {
         StreamController<engine.ResultChangedEvent> controller =
             controllers[result.descriptor];
         if (controller != null) {
           controller.add(result);
         }
       });
     }
   }
 }