restructure internal request to implement CompletionRequest API,

pkg/analysis_server/lib/src/services/completion/dart_completion_manager.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 services.completion.dart;
 
 import 'dart:async';
 
+import 'package:analysis_server/completion/completion_core.dart'
+    show CompletionRequest;
+import 'package:analysis_server/src/analysis_server.dart';
 import 'package:analysis_server/src/protocol.dart';
 import 'package:analysis_server/src/services/completion/arglist_contributor.dart';
 import 'package:analysis_server/src/services/completion/combinator_contributor.dart';
 import 'package:analysis_server/src/services/completion/common_usage_computer.dart';
 import 'package:analysis_server/src/services/completion/completion_manager.dart';
 import 'package:analysis_server/src/services/completion/completion_target.dart';
 import 'package:analysis_server/src/services/completion/dart_completion_cache.dart';
 import 'package:analysis_server/src/services/completion/import_uri_contributor.dart';
 import 'package:analysis_server/src/services/completion/imported_reference_contributor.dart';
 import 'package:analysis_server/src/services/completion/keyword_contributor.dart';
@@ skipping 95 matching lines @@
         return new Future.value(false);
       }
     });
   }
 
   /**
    * Compute suggestions based upon cached information only
    * then send an initial response to the client.
    * Return a list of contributors for which [computeFull] should be called
    */
-  List<DartCompletionContributor> computeFast(DartCompletionRequest request) {
-    return request.performance.logElapseTime('computeFast', () {
+  List<DartCompletionContributor> computeFast(
+      DartCompletionRequest request, CompletionPerformance performance) {
+    return performance.logElapseTime('computeFast', () {
       CompilationUnit unit = context.parseCompilationUnit(source);
       request.unit = unit;
       request.target = new CompletionTarget.forOffset(unit, request.offset);
       request.replacementOffset = request.offset;
       request.replacementLength = 0;
       if (request.offset < 0 || request.offset > unit.end) {
         sendResults(request, true);
         return [];
       }
 
       var entity = request.target.entity;
       Token token = entity is AstNode ? entity.beginToken : entity;
       if (token != null &&
           token.offset <= request.offset &&
           (token.type == TokenType.KEYWORD ||
               token.type == TokenType.IDENTIFIER)) {
         request.replacementOffset = token.offset;
         request.replacementLength = token.length;
       }
 
       List<DartCompletionContributor> todo = new List.from(contributors);
       todo.removeWhere((DartCompletionContributor c) {
-        return request.performance.logElapseTime('computeFast ${c.runtimeType}',
-            () {
+        return performance.logElapseTime('computeFast ${c.runtimeType}', () {
           return c.computeFast(request);
         });
       });
       commonUsageComputer.computeFast(request);
       sendResults(request, todo.isEmpty);
       return todo;
     });
   }
 
   /**
    * If there is remaining work to be done, then wait for the unit to be
    * resolved and request that each remaining contributor finish their work.
    * Return a [Future] that completes when the last notification has been sent.
    */
-  Future computeFull(
-      DartCompletionRequest request, List<DartCompletionContributor> todo) {
-    request.performance.logStartTime('waitForAnalysis');
+  Future computeFull(DartCompletionRequest request,
+      CompletionPerformance performance, List<DartCompletionContributor> todo) {
+    performance.logStartTime('waitForAnalysis');
     return waitForAnalysis().then((CompilationUnit unit) {
       if (controller.isClosed) {
         return;
       }
-      request.performance.logElapseTime('waitForAnalysis');
+      performance.logElapseTime('waitForAnalysis');
       if (unit == null) {
         sendResults(request, true);
         return;
       }
-      request.performance.logElapseTime('computeFull', () {
+      performance.logElapseTime('computeFull', () {
         request.unit = unit;
         // TODO(paulberry): Do we need to invoke _ReplacementOffsetBuilder
         // again?
         request.target = new CompletionTarget.forOffset(unit, request.offset);
         int count = todo.length;
         todo.forEach((DartCompletionContributor c) {
           String name = c.runtimeType.toString();
           String completeTag = 'computeFull $name complete';
-          request.performance.logStartTime(completeTag);
-          request.performance.logElapseTime('computeFull $name', () {
+          performance.logStartTime(completeTag);
+          performance.logElapseTime('computeFull $name', () {
             c.computeFull(request).then((bool changed) {
-              request.performance.logElapseTime(completeTag);
+              performance.logElapseTime(completeTag);
               bool last = --count == 0;
               if (changed || last) {
                 commonUsageComputer.computeFull(request);
                 sendResults(request, last);
               }
             });
           });
         });
       });
     });
   }
 
   @override
   void computeSuggestions(CompletionRequest completionRequest) {
-    DartCompletionRequest request = new DartCompletionRequest(context,
-        searchEngine, source, completionRequest.offset, cache,
-        completionRequest.performance);
-    request.performance.logElapseTime('compute', () {
-      List<DartCompletionContributor> todo = computeFast(request);
+    DartCompletionRequest request =
+        new DartCompletionRequest.from(completionRequest, cache);
+    CompletionPerformance performance = new CompletionPerformance();
+    performance.logElapseTime('compute', () {
+      List<DartCompletionContributor> todo = computeFast(request, performance);
       if (!todo.isEmpty) {
-        computeFull(request, todo);
+        computeFull(request, performance, todo);
       }
     });
   }
 
   /**
    * Send the current list of suggestions to the client.
    */
   void sendResults(DartCompletionRequest request, bool last) {
     if (controller == null || controller.isClosed) {
       return;
@@ skipping 24 matching lines @@
       // This source file is not scheduled for analysis, so a resolved
       // compilation unit is never going to get computed.
       return null;
     }, test: (e) => e is AnalysisNotScheduledError);
   }
 }
 
 /**
  * The context in which the completion is requested.
  */
-class DartCompletionRequest extends CompletionRequest {
-  /**
-   * The analysis context in which the completion is requested.
-   */
-  final AnalysisContext context;
-
-  /**
-   * The search engine for use when building suggestions.
-   */
-  final SearchEngine searchEngine;
-
-  /**
-   * The source in which the completion is requested.
-   */
-  final Source source;
-
+class DartCompletionRequest extends CompletionRequestImpl {
   /**
    * Cached information from a prior code completion operation.
    */
   final DartCompletionCache cache;
 
   /**
    * The compilation unit in which the completion was requested. This unit
    * may or may not be resolved when [DartCompletionContributor.computeFast]
    * is called but is resolved when [DartCompletionContributor.computeFull].
    */
@@ skipping 29 matching lines @@
   /**
    * The list of suggestions to be sent to the client.
    */
   final List<CompletionSuggestion> _suggestions = <CompletionSuggestion>[];
 
   /**
    * The set of completions used to prevent duplicates
    */
   final Set<String> _completions = new Set<String>();
 
-  DartCompletionRequest(this.context, this.searchEngine, this.source,
-      int offset, this.cache, CompletionPerformance performance)
-      : super(offset, performance);
+  DartCompletionRequest(AnalysisServer server, AnalysisContext context,
+      Source source, int offset, this.cache)
+      : super(server, context, source, offset);
+
+  factory DartCompletionRequest.from(CompletionRequestImpl request,
+      DartCompletionCache cache) => new DartCompletionRequest(
+      request.server, request.context, request.source, request.offset, cache);
 
   /**
    * Return the original text from the [replacementOffset] to the [offset]
    * that can be used to filter the suggestions on the server side.
    */
   String get filterText {
     return context.getContents(source).data.substring(
         replacementOffset, offset);
   }
 
   /**
    * Information about the types of suggestions that should be included.
    * The [target] must be set first.
    */
   OpType get optype {
     if (_optype == null) {
       _optype = new OpType.forCompletion(target, offset);
     }
     return _optype;
   }
 
   /**
+   * The search engine for use when building suggestions.
+   */
+  SearchEngine get searchEngine => server.searchEngine;
+
+  /**
    * The list of suggestions to be sent to the client.
    */
   Iterable<CompletionSuggestion> get suggestions => _suggestions;
 
   /**
    * Add the given suggestion to the list that is returned to the client as long
    * as a suggestion with an identical completion has not already been added.
    */
   void addSuggestion(CompletionSuggestion suggestion) {
     if (_completions.add(suggestion.completion)) {
@@ skipping 21 matching lines @@
             parameterNames: suggestion.parameterNames,
             parameterTypes: suggestion.parameterTypes,
             requiredParameterCount: suggestion.requiredParameterCount,
             hasNamedParameters: suggestion.hasNamedParameters,
             returnType: suggestion.returnType,
             element: suggestion.element);
       }
     }
   }
 }