Add completion support for plugins.

pkg/analysis_server/lib/src/domain_completion.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.completion;
 
 import 'dart:async';
 
 import 'package:analysis_server/plugin/protocol/protocol.dart';
 import 'package:analysis_server/src/analysis_server.dart';
 import 'package:analysis_server/src/constants.dart';
+import 'package:analysis_server/src/domain_abstract.dart';
+import 'package:analysis_server/src/plugin/plugin_manager.dart';
+import 'package:analysis_server/src/plugin/result_converter.dart';
 import 'package:analysis_server/src/provisional/completion/completion_core.dart';
 import 'package:analysis_server/src/services/completion/completion_core.dart';
 import 'package:analysis_server/src/services/completion/completion_performance.dart';
 import 'package:analyzer/src/dart/analysis/driver.dart';
 import 'package:analyzer/src/generated/engine.dart' hide AnalysisResult;
+import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/source/source_resource.dart';
-import 'package:analyzer/src/generated/source.dart';
+import 'package:analyzer_plugin/protocol/protocol.dart' as plugin;
+import 'package:analyzer_plugin/protocol/protocol_constants.dart' as plugin;
+import 'package:analyzer_plugin/protocol/protocol_generated.dart' as plugin;
 
 /**
  * Instances of the class [CompletionDomainHandler] implement a [RequestHandler]
  * that handles requests in the completion domain.
  */
-class CompletionDomainHandler implements RequestHandler {
+class CompletionDomainHandler extends AbstractRequestHandler {
   /**
    * The maximum number of performance measurements to keep.
    */
   static const int performanceListMaxLength = 50;
 
   /**
-   * The analysis server that is using this handler to process requests.
-   */
-  final AnalysisServer server;
-
-  /**
    * The next completion response id.
    */
   int _nextCompletionId = 0;
 
   /**
    * Code completion performance for the last completion operation.
    */
   CompletionPerformance performance;
 
   /**
    * A list of code completion performance measurements for the latest
    * completion operation up to [performanceListMaxLength] measurements.
    */
   final List<CompletionPerformance> performanceList =
       new List<CompletionPerformance>();
 
   /**
    * Performance for the last priority change event.
    */
   CompletionPerformance computeCachePerformance;
 
   /**
    * The current request being processed or `null` if none.
    */
   CompletionRequestImpl _currentRequest;
 
   /**
    * Initialize a new request handler for the given [server].
    */
-  CompletionDomainHandler(this.server);
+  CompletionDomainHandler(AnalysisServer server) : super(server);
 
   /**
    * Compute completion results for the given request and append them to the stream.
    * Clients should not call this method directly as it is automatically called
    * when a client listens to the stream returned by [results].
    * Subclasses should override this method, append at least one result
    * to the [controller], and close the controller stream once complete.
    */
-  Future<CompletionResult> computeSuggestions(
-      CompletionRequestImpl request) async {
+  Future<CompletionResult> computeSuggestions(CompletionRequestImpl request,
+      CompletionGetSuggestionsParams params) async {
+    //
+    // Allow plugins to start computing fixes.
+    //
+    Map<PluginInfo, Future<plugin.Response>> pluginFutures;
+    plugin.CompletionGetSuggestionsParams requestParams;
+    if (server.options.enableNewAnalysisDriver) {
+      String file = params.file;
+      int offset = params.offset;
+      AnalysisDriver driver = server.getAnalysisDriver(file);
+      requestParams = new plugin.CompletionGetSuggestionsParams(file, offset);
+      pluginFutures = server.pluginManager
+          .broadcastRequest(requestParams, contextRoot: driver.contextRoot);
+    }
+    //
+    // Compute completions generated by server.
+    //
     Iterable<CompletionContributor> newContributors =
         server.serverPlugin.completionContributors;
     List<CompletionSuggestion> suggestions = <CompletionSuggestion>[];
 
     const COMPUTE_SUGGESTIONS_TAG = 'computeSuggestions';
     performance.logStartTime(COMPUTE_SUGGESTIONS_TAG);
 
     for (CompletionContributor contributor in newContributors) {
       String contributorTag = 'computeSuggestions - ${contributor.runtimeType}';
       performance.logStartTime(contributorTag);
       try {
         suggestions.addAll(await contributor.computeSuggestions(request));
       } on AbortCompletion {
         suggestions.clear();
         break;
       }
       performance.logElapseTime(contributorTag);
     }
 
     performance.logElapseTime(COMPUTE_SUGGESTIONS_TAG);
 
-    // TODO (danrubel) if request is obsolete
-    // (processAnalysisRequest returns false)
-    // then send empty results
+    // TODO (danrubel) if request is obsolete (processAnalysisRequest returns
+    // false) then send empty results
 
+    //
+    // Add the fixes produced by plugins to the server-generated fixes.
+    //
+    if (pluginFutures != null) {
+      List<plugin.Response> responses = await waitForResponses(pluginFutures,
+          requestParameters: requestParams);
+      ResultConverter converter = new ResultConverter();
+      for (plugin.Response response in responses) {
+        plugin.CompletionGetSuggestionsResult result =
+            new plugin.CompletionGetSuggestionsResult.fromResponse(response);
+        suggestions
+            .addAll(result.results.map(converter.convertCompletionSuggestion));
+      }
+    }
+    //
+    // Return the result.
+    //
     return new CompletionResult(
         request.replacementOffset, request.replacementLength, suggestions);
   }
 
   @override
   Response handleRequest(Request request) {
     if (server.searchEngine == null) {
       return new Response.noIndexGenerated(request);
     }
     return runZoned(() {
@@ skipping 79 matching lines @@
     String completionId = (_nextCompletionId++).toString();
 
     _abortCurrentRequest();
     _currentRequest = completionRequest;
 
     // initial response without results
     server.sendResponse(new CompletionGetSuggestionsResult(completionId)
         .toResponse(request.id));
 
     // Compute suggestions in the background
-    computeSuggestions(completionRequest).then((CompletionResult result) {
+    computeSuggestions(completionRequest, params)
+        .then((CompletionResult result) {
       const SEND_NOTIFICATION_TAG = 'send notification';
       performance.logStartTime(SEND_NOTIFICATION_TAG);
       sendCompletionNotification(completionId, result.replacementOffset,
           result.replacementLength, result.suggestions);
       performance.logElapseTime(SEND_NOTIFICATION_TAG);
 
       performance.notificationCount = 1;
       performance.logFirstNotificationComplete('notification 1 complete');
       performance.suggestionCountFirst = result.suggestions.length;
       performance.suggestionCountLast = result.suggestions.length;
@@ skipping 67 matching lines @@
   final int replacementOffset;
 
   /**
    * The suggested completions.
    */
   final List<CompletionSuggestion> suggestions;
 
   CompletionResult(
       this.replacementOffset, this.replacementLength, this.suggestions);
 }