make completion managers responsible for their own caches

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/src/protocol.dart';
 import 'package:analysis_server/src/services/completion/arglist_computer.dart';
@@ skipping 30 matching lines @@
    * in the given completion context are resolved.
    * Returns `true` if the receiver modified the list of suggestions.
    */
   Future<bool> computeFull(DartCompletionRequest request);
 }
 
 /**
  * Manages code completion for a given Dart file completion request.
  */
 class DartCompletionManager extends CompletionManager {
-  final DartCompletionRequest request;
-  final AnalysisContext context;
-  final Source source;
-  final int offset;
-  final CompletionPerformance performance;
+  final SearchEngine searchEngine;
   final DartCompletionCache cache;
   List<DartCompletionComputer> computers;
 
-  DartCompletionManager(this.request, this.context, this.source, this.offset,
-      this.cache, this.performance)
-      : computers = [
+  DartCompletionManager(AnalysisContext context, this.searchEngine,
+      Source source, this.cache)
+      : super(context, source),
+        computers = [
           new KeywordComputer(),
           new LocalComputer(),
           new ArgListComputer(),
           new CombinatorComputer(),
           new ImportedComputer(),
           new InvocationComputer()];
 
   /**
    * Create a new initialized Dart source completion manager
    */
   factory DartCompletionManager.create(AnalysisContext context,
-      SearchEngine searchEngine, Source source, int offset, CompletionCache oldCache,
-      CompletionPerformance performance) {
+      SearchEngine searchEngine, Source source, CompletionCache oldCache) {
     DartCompletionCache newCache;
     if (oldCache is DartCompletionCache) {
       if (oldCache.context == context && oldCache.source == source) {
         newCache = oldCache;
       }
     }
     if (newCache == null) {
       newCache = new DartCompletionCache(context, source);
     }
-    return new DartCompletionManager(
-        new DartCompletionRequest(context, searchEngine, source, offset, newCache),
-        context,
-        source,
-        offset,
-        newCache,
-        performance);
+    return new DartCompletionManager(context, searchEngine, source, newCache);
   }
 
   @override
-  CompletionCache get completionCache => cache;
-
-  @override
-  void compute() {
-    performance.logElapseTime('compute', () {
-      computeFast();
+  void compute(CompletionRequest completionRequest) {
+    DartCompletionRequest request = new DartCompletionRequest(
+        context,
+        searchEngine,
+        source,
+        completionRequest.offset,
+        cache,
+        completionRequest.performance);
+    request.performance.logElapseTime('compute', () {
+      computeFast(request);
       if (!computers.isEmpty) {
-        computeFull();
+        computeFull(request);
       }
     });
   }
 
   /**
    * Compute suggestions based upon cached information only
    * then send an initial response to the client.
    */
-  void computeFast() {
-    performance.logElapseTime('computeFast', () {
+  void computeFast(DartCompletionRequest request) {
+    request.performance.logElapseTime('computeFast', () {
       CompilationUnit unit = context.parseCompilationUnit(source);
       request.unit = unit;
-      request.node = new NodeLocator.con1(offset).searchWithin(unit);
+      request.node = new NodeLocator.con1(request.offset).searchWithin(unit);
       request.node.accept(new _ReplacementOffsetBuilder(request));
       computers.removeWhere((DartCompletionComputer c) {
-        return performance.logElapseTime('computeFast ${c.runtimeType}', () {
+        return request.performance.logElapseTime(
+            'computeFast ${c.runtimeType}',
+            () {
           return c.computeFast(request);
         });
       });
-      sendResults(computers.isEmpty);
+      sendResults(request, computers.isEmpty);
     });
   }
 
   /**
    * If there is remaining work to be done, then wait for the unit to be
    * resolved and request that each remaining computer finish their work.
    */
-  void computeFull() {
-    performance.logStartTime('waitForAnalysis');
+  void computeFull(DartCompletionRequest request) {
+    request.performance.logStartTime('waitForAnalysis');
     waitForAnalysis().then((CompilationUnit unit) {
-      performance.logElapseTime('waitForAnalysis');
+      request.performance.logElapseTime('waitForAnalysis');
       if (unit == null) {
-        sendResults(true);
+        sendResults(request, true);
         return;
       }
-      performance.logElapseTime('computeFull', () {
+      request.performance.logElapseTime('computeFull', () {
         request.unit = unit;
-        request.node = new NodeLocator.con1(offset).searchWithin(unit);
+        request.node = new NodeLocator.con1(request.offset).searchWithin(unit);
         int count = computers.length;
         computers.forEach((DartCompletionComputer c) {
           String name = c.runtimeType.toString();
           String completeTag = 'computeFull $name complete';
-          performance.logStartTime(completeTag);
-          performance.logElapseTime('computeFull $name', () {
+          request.performance.logStartTime(completeTag);
+          request.performance.logElapseTime('computeFull $name', () {
             c.computeFull(request).then((bool changed) {
-              performance.logElapseTime(completeTag);
+              request.performance.logElapseTime(completeTag);
               bool last = --count == 0;
               if (changed || last) {
-                sendResults(last);
+                sendResults(request, last);
               }
             });
           });
         });
       });
     });
   }
 
   /**
    * Send the current list of suggestions to the client.
    */
-  void sendResults(bool last) {
+  void sendResults(DartCompletionRequest request, bool last) {
     controller.add(
         new CompletionResult(
             request.replacementOffset,
             request.replacementLength,
             request.suggestions,
             last));
     if (last) {
       controller.close();
     }
   }
@@ skipping 12 matching lines @@
       }
     }
     //TODO (danrubel) Determine if analysis is complete but unit not resolved
     return new Future(waitForAnalysis);
   }
 }
 
 /**
  * The context in which the completion is requested.
  */
-class DartCompletionRequest {
+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;
 
   /**
-   * The offset within the source at which the completion is requested.
-   */
-  final int offset;
-
-  /**
    * 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 [DartCompletionComputer.computeFast]
    * is called but is resolved when [DartCompletionComputer.computeFull].
    */
   CompilationUnit unit;
@@ skipping 20 matching lines @@
    * (that is, the number of characters in the existing identifier).
    */
   int replacementLength;
 
   /**
    * The list of suggestions to be sent to the client.
    */
   final List<CompletionSuggestion> suggestions = <CompletionSuggestion>[];
 
   DartCompletionRequest(this.context, this.searchEngine, this.source,
-      this.offset, this.cache);
+      int offset, this.cache, CompletionPerformance performance)
+      : super(offset, performance);
 }
 
 /**
  * Visitor used to determine the replacement offset and length
  * based upon the cursor location.
  */
 class _ReplacementOffsetBuilder extends SimpleAstVisitor {
   final DartCompletionRequest request;
 
   _ReplacementOffsetBuilder(this.request) {
     request.replacementOffset = request.offset;
     request.replacementLength = 0;
   }
 
   visitSimpleIdentifier(SimpleIdentifier node) {
     request.replacementOffset = node.offset;
     request.replacementLength = node.length;
   }
 }