rename completion computer to contributor

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 23 matching lines @@
 const int DART_RELEVANCE_LOCAL_ACCESSOR = 1057;
 const int DART_RELEVANCE_LOCAL_FIELD = 1058;
 const int DART_RELEVANCE_LOCAL_FUNCTION = 1056;
 const int DART_RELEVANCE_LOCAL_METHOD = 1057;
 const int DART_RELEVANCE_LOCAL_TOP_LEVEL_VARIABLE = 1056;
 const int DART_RELEVANCE_LOCAL_VARIABLE = 1059;
 const int DART_RELEVANCE_LOW = 500;
 const int DART_RELEVANCE_PARAMETER = 1059;
 
 /**
- * The base class for computing code completion suggestions.
+ * The base class for contributing code completion suggestions.
  */
-abstract class DartCompletionComputer {
+abstract class DartCompletionContributor {
   /**
    * Computes the initial set of [CompletionSuggestion]s based on
    * the given completion context. The compilation unit and completion node
    * in the given completion context may not be resolved.
    * This method should execute quickly and not block waiting for any analysis.
-   * Returns `true` if the computer's work is complete
+   * Returns `true` if the contributor's work is complete
    * or `false` if [computeFull] should be called to complete the work.
    */
   bool computeFast(DartCompletionRequest request);
 
   /**
    * Computes the complete set of [CompletionSuggestion]s based on
    * the given completion context.  The compilation unit and completion node
    * 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 SearchEngine searchEngine;
   final DartCompletionCache cache;
-  List<DartCompletionComputer> computers;
+  List<DartCompletionContributor> contributors;
   CommonUsageComputer commonUsageComputer;
 
   DartCompletionManager(
       AnalysisContext context, this.searchEngine, Source source, this.cache,
-      [this.computers, this.commonUsageComputer])
+      [this.contributors, this.commonUsageComputer])
       : super(context, source) {
-    if (computers == null) {
-      computers = [
-        // LocalComputer before ImportedComputer
+    if (contributors == null) {
+      contributors = [
+        // LocalReferenceContributor before ImportedReferenceContributor
         // because local suggestions take precedence
-        new LocalComputer(),
-        new ImportedComputer(),
-        new KeywordComputer(),
-        new ArgListComputer(),
-        new CombinatorComputer(),
-        new InvocationComputer()
+        // and can hide other suggestions with the same name
+        new LocalReferenceContributor(),
+        new ImportedReferenceContributor(),
+        new KeywordContributor(),
+        new ArgListContributor(),
+        new CombinatorContributor(),
+        new PrefixedElementContributor()
       ];
     }
     if (commonUsageComputer == null) {
       commonUsageComputer = new CommonUsageComputer();
     }
   }
 
   /**
    * Create a new initialized Dart source completion manager
    */
@@ skipping 10 matching lines @@
         return cache.computeImportInfo(unit, searchEngine, true);
       } else {
         return new Future.value(false);
       }
     });
   }
 
   /**
    * Compute suggestions based upon cached information only
    * then send an initial response to the client.
-   * Return a list of computers for which [computeFull] should be called
+   * Return a list of contributors for which [computeFull] should be called
    */
-  List<DartCompletionComputer> computeFast(DartCompletionRequest request) {
+  List<DartCompletionContributor> computeFast(DartCompletionRequest request) {
     return request.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<DartCompletionComputer> todo = new List.from(computers);
-      todo.removeWhere((DartCompletionComputer c) {
+      List<DartCompletionContributor> todo = new List.from(contributors);
+      todo.removeWhere((DartCompletionContributor c) {
         return request.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 computer finish their work.
+   * 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<DartCompletionComputer> todo) {
+      DartCompletionRequest request, List<DartCompletionContributor> todo) {
     request.performance.logStartTime('waitForAnalysis');
     return waitForAnalysis().then((CompilationUnit unit) {
       if (controller.isClosed) {
         return;
       }
       request.performance.logElapseTime('waitForAnalysis');
       if (unit == null) {
         sendResults(request, true);
         return;
       }
       request.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((DartCompletionComputer c) {
+        todo.forEach((DartCompletionContributor c) {
           String name = c.runtimeType.toString();
           String completeTag = 'computeFull $name complete';
           request.performance.logStartTime(completeTag);
           request.performance.logElapseTime('computeFull $name', () {
             c.computeFull(request).then((bool changed) {
               request.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<DartCompletionComputer> todo = computeFast(request);
+      List<DartCompletionContributor> todo = computeFast(request);
       if (!todo.isEmpty) {
         computeFull(request, todo);
       }
     });
   }
 
   /**
    * Send the current list of suggestions to the client.
    */
   void sendResults(DartCompletionRequest request, bool last) {
@@ skipping 49 matching lines @@
    */
   final Source source;
 
   /**
    * 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].
+   * may or may not be resolved when [DartCompletionContributor.computeFast]
+   * is called but is resolved when [DartCompletionContributor.computeFull].
    */
   CompilationUnit unit;
 
   /**
    * The completion target.  This determines what part of the parse tree
    * will receive the newly inserted text.
    */
   CompletionTarget target;
 
   /**
@@ skipping 86 matching lines @@
             parameterNames: suggestion.parameterNames,
             parameterTypes: suggestion.parameterTypes,
             requiredParameterCount: suggestion.requiredParameterCount,
             hasNamedParameters: suggestion.hasNamedParameters,
             returnType: suggestion.returnType,
             element: suggestion.element);
       }
     }
   }
 }