rename completion computer to contributor

pkg/analysis_server/test/services/completion/completion_test_util.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 test.services.completion.util;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/protocol.dart' as protocol
     show Element, ElementKind;
@@ skipping 18 matching lines @@
 
 int suggestionComparator(CompletionSuggestion s1, CompletionSuggestion s2) {
   String c1 = s1.completion.toLowerCase();
   String c2 = s2.completion.toLowerCase();
   return c1.compareTo(c2);
 }
 
 abstract class AbstractCompletionTest extends AbstractContextTest {
   Index index;
   SearchEngineImpl searchEngine;
-  DartCompletionComputer computer;
+  DartCompletionContributor contributor;
   String testFile = '/completionTest.dart';
   Source testSource;
   CompilationUnit testUnit;
   int completionOffset;
   AstNode completionNode;
   bool _computeFastCalled = false;
   DartCompletionRequest request;
   DartCompletionCache cache;
   DartCompletionManager _completionManager;
 
@@ skipping 264 matching lines @@
     expect(element.name, equals(name));
     expect(element.parameters, isNull);
     expect(element.returnType, isNull);
     assertHasNoParameterInfo(cs);
     return cs;
   }
 
   CompletionSuggestion assertSuggestLibraryPrefix(String prefix,
       [int relevance = DART_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
-    // Library prefix should only be suggested by ImportedComputer
+    // Library prefix should only be suggested by ImportedReferenceContributor
     return assertNotSuggested(prefix);
   }
 
   CompletionSuggestion assertSuggestMethod(
       String name, String declaringType, String returnType,
       {int relevance: DART_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION,
       bool isDeprecated: false}) {
     CompletionSuggestion cs = assertSuggest(name,
         csKind: kind, relevance: relevance, isDeprecated: isDeprecated);
     expect(cs.declaringType, equals(declaringType));
     expect(cs.returnType, returnType != null ? returnType : 'dynamic');
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.METHOD));
     expect(element.name, equals(name));
     String param = element.parameters;
     expect(param, isNotNull);
     expect(param[0], equals('('));
     expect(param[param.length - 1], equals(')'));
     expect(element.returnType, returnType != null ? returnType : 'dynamic');
     assertHasParameterInfo(cs);
     return cs;
   }
 
   CompletionSuggestion assertSuggestNamedConstructor(
       String name, String returnType, [int relevance = DART_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
-    if (computer is InvocationComputer) {
+    if (contributor is PrefixedElementContributor) {
       CompletionSuggestion cs =
           assertSuggest(name, csKind: kind, relevance: relevance);
       protocol.Element element = cs.element;
       expect(element, isNotNull);
       expect(element.kind, equals(protocol.ElementKind.CONSTRUCTOR));
       expect(element.name, equals(name));
       String param = element.parameters;
       expect(param, isNotNull);
       expect(param[0], equals('('));
       expect(param[param.length - 1], equals(')'));
@@ skipping 42 matching lines @@
     expect(element.kind, equals(protocol.ElementKind.TOP_LEVEL_VARIABLE));
     expect(element.name, equals(name));
     expect(element.parameters, isNull);
     expect(element.returnType, returnType != null ? returnType : 'dynamic');
     assertHasNoParameterInfo(cs);
     return cs;
   }
 
   void assertSuggestTopLevelVarGetterSetter(String name, String returnType,
       [int relevance = DART_RELEVANCE_DEFAULT]) {
-    if (computer is ImportedComputer) {
+    if (contributor is ImportedReferenceContributor) {
       assertSuggestGetter(name, returnType);
       assertSuggestSetter(name);
     } else {
       assertNotSuggested(name);
     }
   }
 
   bool computeFast() {
     _computeFastCalled = true;
     _completionManager = new DartCompletionManager(context, searchEngine,
-        testSource, cache, [computer], new CommonUsageComputer({}));
+        testSource, cache, [contributor], new CommonUsageComputer({}));
     var result = _completionManager.computeFast(request);
     expect(request.replacementOffset, isNotNull);
     expect(request.replacementLength, isNotNull);
     return result.isEmpty;
   }
 
   Future computeFull(assertFunction(bool result), {bool fullAnalysis: true}) {
     if (!_computeFastCalled) {
       expect(computeFast(), isFalse);
     }
     resolve(fullAnalysis);
-    return computer.computeFull(request).then(assertFunction);
+    return contributor.computeFull(request).then(assertFunction);
   }
 
   void failedCompletion(String message,
       [Iterable<CompletionSuggestion> completions]) {
     StringBuffer sb = new StringBuffer(message);
     if (completions != null) {
       sb.write('\n  found');
       completions.toList()
         ..sort(suggestionComparator)
         ..forEach((CompletionSuggestion suggestion) {
@@ skipping 85 matching lines @@
     if (!resolved) {
       fail('expected unit to be resolved');
     }
   }
 
   @override
   void setUp() {
     super.setUp();
     index = createLocalMemoryIndex();
     searchEngine = new SearchEngineImpl(index);
-    setUpComputer();
+    setUpContributor();
   }
 
-  void setUpComputer();
+  void setUpContributor();
 }
 
 /**
- * Common tests for `ImportedTypeComputerTest`, `InvocationComputerTest`,
- * and `LocalComputerTest`.
+ * Common tests for `ImportedTypeContributorTest`, `InvocationContributorTest`,
+ * and `LocalContributorTest`.
  */
 abstract class AbstractSelectorSuggestionTest extends AbstractCompletionTest {
 
   /**
-   * Assert that the ImportedComputer uses cached results to produce identical
-   * suggestions to the original set of suggestions.
+   * Assert that the ImportedReferenceContributor uses cached results
+   * to produce identical suggestions to the original set of suggestions.
    */
   void assertCachedCompute(_) {
     // Subclasses override
   }
 
   CompletionSuggestion assertSuggestImportedClass(String name,
       {CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION,
       int relevance: DART_RELEVANCE_DEFAULT}) {
-    if (computer is ImportedComputer) {
+    if (contributor is ImportedReferenceContributor) {
       return assertSuggestClass(name, relevance: relevance, kind: kind);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestImportedConstructor(String name,
       {int relevance: DART_RELEVANCE_DEFAULT}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestImportedField(String name, String type,
       {int relevance: DART_RELEVANCE_INHERITED_FIELD}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestImportedFunction(
       String name, String returnType,
       {CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION,
       bool deprecated: false, int relevance: DART_RELEVANCE_DEFAULT}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestImportedFunctionTypeAlias(
       String name, String returnType, [bool isDeprecated = false,
       int relevance = DART_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
-    if (computer is ImportedComputer) {
+    if (contributor is ImportedReferenceContributor) {
       return assertSuggestFunctionTypeAlias(
           name, returnType, isDeprecated, relevance, kind);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestImportedGetter(
       String name, String returnType,
       {int relevance: DART_RELEVANCE_INHERITED_ACCESSOR}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestImportedMethod(
       String name, String declaringType, String returnType,
       {int relevance: DART_RELEVANCE_INHERITED_METHOD}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestImportedSetter(String name,
       {int relevance: DART_RELEVANCE_INHERITED_ACCESSOR}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestImportedTopLevelVar(
       String name, String returnType, [int relevance = DART_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
-    if (computer is ImportedComputer) {
+    if (contributor is ImportedReferenceContributor) {
       return assertSuggestTopLevelVar(name, returnType, relevance, kind);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestInvocationClass(String name,
       [int relevance = DART_RELEVANCE_DEFAULT]) {
-    if (computer is InvocationComputer) {
+    if (contributor is PrefixedElementContributor) {
       return assertSuggestClass(name, relevance: relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestInvocationField(String name, String type,
       {int relevance: DART_RELEVANCE_DEFAULT, bool isDeprecated: false}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestInvocationGetter(
       String name, String returnType,
       {int relevance: DART_RELEVANCE_DEFAULT, bool isDeprecated: false}) {
-    if (computer is InvocationComputer) {
+    if (contributor is PrefixedElementContributor) {
       return assertSuggestGetter(name, returnType,
           relevance: relevance, isDeprecated: isDeprecated);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestInvocationMethod(
       String name, String declaringType, String returnType,
       [int relevance = DART_RELEVANCE_DEFAULT]) {
-    if (computer is InvocationComputer) {
+    if (contributor is PrefixedElementContributor) {
       return assertSuggestMethod(name, declaringType, returnType,
           relevance: relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestInvocationSetter(String name,
       [int relevance = DART_RELEVANCE_DEFAULT]) {
-    if (computer is InvocationComputer) {
+    if (contributor is PrefixedElementContributor) {
       return assertSuggestSetter(name);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestInvocationTopLevelVar(
       String name, String returnType,
       [int relevance = DART_RELEVANCE_DEFAULT]) {
-    if (computer is InvocationComputer) {
+    if (contributor is PrefixedElementContributor) {
       return assertSuggestTopLevelVar(name, returnType, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestLocalClass(String name,
       {CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION,
       int relevance: DART_RELEVANCE_DEFAULT, bool isDeprecated: false}) {
     return assertNotSuggested(name);
@@ skipping 586 matching lines @@
       assertSuggestLibraryPrefix('g');
       assertNotSuggested('G');
       //assertSuggestImportedClass('H', COMPLETION_RELEVANCE_LOW);
       assertSuggestImportedClass('Object');
       assertSuggestImportedFunction('min', 'num');
       //assertSuggestImportedFunction(
       //    'max',
       //    'num',
       //    false,
       //    COMPLETION_RELEVANCE_LOW);
-      if (computer is ImportedComputer) {
+      if (contributor is ImportedReferenceContributor) {
         // TODO(danrubel) should be top level var suggestion
         assertSuggestGetter('T1', 'String');
       }
       assertNotSuggested('_T2');
       //assertSuggestImportedTopLevelVar('T3', 'int', COMPLETION_RELEVANCE_LOW);
       assertNotSuggested('_T4');
       assertSuggestLocalTopLevelVar('T5', 'int');
       assertSuggestLocalTopLevelVar('_T6', null);
       assertNotSuggested('==');
       assertSuggestLocalGetter('T7', 'String');
@@ skipping 1156 matching lines @@
       F2() { }
       typedef D2();
       class C2 { }
       main() {String name; print("hello \$^");}''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       assertNotSuggested('Object');
       // TODO(danrubel) should return top level var rather than getter
-      if (computer is ImportedComputer) {
+      if (contributor is ImportedReferenceContributor) {
         //assertSuggestImportedTopLevelVar('T1', 'int');
         assertSuggestGetter('T1', 'int');
       }
       assertSuggestImportedFunction('F1', null);
       assertNotSuggested('D1');
       assertNotSuggested('C1');
       assertSuggestLocalTopLevelVar('T2', 'int');
       assertSuggestLocalFunction('F2', null);
       assertNotSuggested('D2');
       assertNotSuggested('C2');
@@ skipping 14 matching lines @@
       F2() { }
       typedef D2();
       class C2 { }
       main() {String name; print("hello \${^}");}''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       assertSuggestImportedClass('Object');
       // TODO(danrubel) should return top level var rather than getter
-      if (computer is ImportedComputer) {
+      if (contributor is ImportedReferenceContributor) {
         //assertSuggestImportedTopLevelVar('T1', 'int');
         assertSuggestGetter('T1', 'int');
       }
       assertSuggestImportedFunction('F1', null);
       assertSuggestImportedFunctionTypeAlias('D1', null);
       assertSuggestImportedClass('C1');
       assertSuggestLocalTopLevelVar('T2', 'int');
       assertSuggestLocalFunction('F2', null);
       assertSuggestLocalFunctionTypeAlias('D2', null);
       assertSuggestLocalClass('C2');
@@ skipping 136 matching lines @@
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset - 3);
       expect(request.replacementLength, 3);
       assertNotSuggested('c');
       assertNotSuggested('_d');
       // Imported suggestion are filtered by 1st character
       assertSuggestImportedFunction('nowIsIt', null);
       assertNotSuggested('T1');
       // TODO (danrubel) this really should be TopLevelVar not getter/setter
-      if (computer is ImportedComputer) {
+      if (contributor is ImportedReferenceContributor) {
         assertSuggestGetter('newT1', 'int');
       }
       assertNotSuggested('z');
       assertSuggestLocalTopLevelVar('m', 'dynamic');
       assertSuggestLocalFunction('newer', 'String');
     });
   }
 
   test_Literal_list() {
     // ']'  ListLiteral  ArgumentList  MethodInvocation
@@ skipping 37 matching lines @@
       F2() { }
       typedef D2();
       class C2 { }
       foo = {^''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       assertSuggestImportedClass('Object');
       // TODO(danrubel) Should be top level variable
-      if (computer is ImportedComputer) {
+      if (contributor is ImportedReferenceContributor) {
         assertSuggestGetter('T1', 'int');
         // assertSuggestImportedTopLevelVar('T1', 'int');
       }
       assertSuggestImportedFunction('F1', null);
       assertSuggestImportedFunctionTypeAlias('D1', null);
       assertSuggestImportedClass('C1');
       assertSuggestLocalTopLevelVar('T2', 'int');
       assertSuggestLocalFunction('F2', null);
       assertSuggestLocalFunctionTypeAlias('D2', null);
       assertSuggestLocalClass('C2');
@@ skipping 12 matching lines @@
       int T2;
       F2() { }
       typedef D2();
       class C2 { }
       foo = {T^''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset - 1);
       expect(request.replacementLength, 1);
       // TODO(danrubel) Should be top level variable
-      if (computer is ImportedComputer) {
+      if (contributor is ImportedReferenceContributor) {
         assertSuggestGetter('T1', 'int');
         // assertSuggestImportedTopLevelVar('T1', 'int');
       }
       assertSuggestLocalTopLevelVar('T2', 'int');
     });
   }
 
   test_MapLiteralEntry2() {
     // SimpleIdentifier  MapLiteralEntry  MapLiteral  VariableDeclaration
     addSource('/testA.dart', '''
       int T1;
       F1() { }
       typedef D1();
       class C1 {C1(this.x) { } int x;}''');
     addTestSource('''
       import "/testA.dart";
       int T2;
       F2() { }
       typedef D2();
       class C2 { }
       foo = {7:T^};''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset - 1);
       expect(request.replacementLength, 1);
       // TODO(danrubel) Should be top level variable
-      if (computer is ImportedComputer) {
+      if (contributor is ImportedReferenceContributor) {
         assertSuggestGetter('T1', 'int');
         // assertSuggestImportedTopLevelVar('T1', 'int');
       }
       assertSuggestLocalTopLevelVar('T2', 'int');
     });
   }
 
   test_MethodDeclaration_body_getters() {
     // Block  BlockFunctionBody  MethodDeclaration
     addTestSource('class A {@deprecated X get f => 0; Z a() {^} get _g => 1;}');
@@ skipping 973 matching lines @@
       assertNotSuggested('bar2');
       assertNotSuggested('_B');
       assertSuggestLocalClass('Y');
       assertSuggestLocalClass('C');
       assertSuggestLocalVariable('f', null);
       assertNotSuggested('x');
       assertNotSuggested('e');
     });
   }
 }