Make FixContributor asynchronous.

pkg/analysis_server/lib/src/edit/edit_domain.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 edit.domain;
 
 import 'dart:async';
 
 import 'package:analysis_server/plugin/edit/assist/assist_core.dart';
 import 'package:analysis_server/plugin/edit/fix/fix_core.dart';
@@ skipping 130 matching lines @@
           server.serverPlugin, context, source, params.offset, params.length);
       assists.forEach((Assist assist) {
         changes.add(assist.change);
       });
     }
     Response response =
         new EditGetAssistsResult(changes).toResponse(request.id);
     server.sendResponse(response);
   }
 
-  Response getFixes(Request request) {
+  getFixes(Request request) async {
     var params = new EditGetFixesParams.fromRequest(request);
     String file = params.file;
     int offset = params.offset;
     // add fixes
     List<AnalysisErrorFixes> errorFixesList = <AnalysisErrorFixes>[];
     List<CompilationUnit> units = server.getResolvedCompilationUnits(file);
     for (CompilationUnit unit in units) {
       engine.AnalysisErrorInfo errorInfo = server.getErrors(file);
       if (errorInfo != null) {
         LineInfo lineInfo = errorInfo.lineInfo;
         int requestLine = lineInfo.getLocation(offset).lineNumber;
         for (engine.AnalysisError error in errorInfo.errors) {
           int errorLine = lineInfo.getLocation(error.offset).lineNumber;
           if (errorLine == requestLine) {
-            List<Fix> fixes = computeFixes(server.serverPlugin,
+            List<Fix> fixes = await computeFixes(server.serverPlugin,
                 server.resourceProvider, unit.element.context, error);
             if (fixes.isNotEmpty) {
               AnalysisError serverError =
                   newAnalysisError_fromEngine(lineInfo, error);
               AnalysisErrorFixes errorFixes =
                   new AnalysisErrorFixes(serverError);
               errorFixesList.add(errorFixes);
               fixes.forEach((fix) {
                 errorFixes.fixes.add(fix.change);
               });
             }
           }
         }
       }
     }
     // respond
-    return new EditGetFixesResult(errorFixesList).toResponse(request.id);
+    return server.sendResponse(
+        new EditGetFixesResult(errorFixesList).toResponse(request.id));
   }
 
   @override
   Response handleRequest(Request request) {
     try {
       String requestName = request.method;
       if (requestName == EDIT_FORMAT) {
         return format(request);
       } else if (requestName == EDIT_GET_ASSISTS) {
         getAssists(request);
         return Response.DELAYED_RESPONSE;
       } else if (requestName == EDIT_GET_AVAILABLE_REFACTORINGS) {
         return _getAvailableRefactorings(request);
       } else if (requestName == EDIT_GET_FIXES) {
-        return getFixes(request);
+        getFixes(request);
+        return Response.DELAYED_RESPONSE;
       } else if (requestName == EDIT_GET_REFACTORING) {
         return _getRefactoring(request);
       } else if (requestName == EDIT_ORGANIZE_DIRECTIVES) {
         return organizeDirectives(request);
       } else if (requestName == EDIT_SORT_MEMBERS) {
         return sortMembers(request);
       }
     } on RequestFailure catch (exception) {
       return exception.response;
     }
@@ skipping 530 matching lines @@
     }
     return new RefactoringStatus();
   }
 }
 
 /**
  * [_RefactoringManager] throws instances of this class internally to stop
  * processing in a manager that was reset.
  */
 class _ResetError {}