rename completion computer to contributor

pkg/analysis_server/test/services/completion/imported_computer_test.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.toplevel;
 
 import 'package:analysis_server/src/protocol.dart' as protocol
     show Element, ElementKind;
 import 'package:analysis_server/src/protocol.dart' hide Element, ElementKind;
 import 'package:analysis_server/src/services/completion/completion_manager.dart';
 import 'package:analysis_server/src/services/completion/dart_completion_cache.dart';
 import 'package:analysis_server/src/services/completion/dart_completion_manager.dart';
 import 'package:analysis_server/src/services/completion/imported_computer.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:unittest/unittest.dart';
 
 import '../../abstract_context.dart';
 import '../../reflective_tests.dart';
 import 'completion_test_util.dart';
 
 main() {
   groupSep = ' | ';
-  runReflectiveTests(ImportedComputerTest);
+  runReflectiveTests(ImportedReferenceContributorTest);
 }
 
 @reflectiveTest
-class ImportedComputerTest extends AbstractSelectorSuggestionTest {
+class ImportedReferenceContributorTest extends AbstractSelectorSuggestionTest {
   void assertCached(String completion) {
     DartCompletionCache cache = request.cache;
     if (!isCached(cache.importedTypeSuggestions, completion) &&
         !isCached(cache.importedVoidReturnSuggestions, completion) &&
         !isCached(cache.libraryPrefixSuggestions, completion) &&
         !isCached(cache.otherImportedSuggestions, completion)) {
       fail('expected $completion to be cached');
     }
   }
 
   /**
-   * 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.
    */
   @override
   assertCachedCompute(_) {
-    if (!(computer as ImportedComputer).shouldWaitForLowPrioritySuggestions) {
+    if (!(contributor as ImportedReferenceContributor).shouldWaitForLowPrioritySuggestions) {
       return null;
     }
     expect(request.unit.element, isNotNull);
     List<CompletionSuggestion> oldSuggestions = request.suggestions;
     /*
      * Simulate a source change to flush the cached compilation unit
      */
     ChangeSet changes = new ChangeSet();
     changes.addedSource(testSource);
     context.applyChanges(changes);
     /*
      * Calculate a new completion at the same location
      */
-    setUpComputer();
+    setUpContributor();
     int replacementOffset = request.replacementOffset;
     int replacementLength = request.replacementLength;
     request = new DartCompletionRequest(context, searchEngine, testSource,
         completionOffset, cache, new CompletionPerformance());
     request.replacementOffset = replacementOffset;
     request.replacementLength = replacementLength;
 
     void assertResultsFromCache(List<CompletionSuggestion> oldSuggestions) {
       List<CompletionSuggestion> newSuggestions = request.suggestions;
       if (newSuggestions.length == oldSuggestions.length) {
@@ skipping 19 matching lines @@
       fail(sb.toString());
     }
 
     if (computeFast()) {
       expect(request.unit.element, isNull);
       assertResultsFromCache(oldSuggestions);
     } else {
       // Results from cache might need to be adjusted
       // if target is a function argument in an argument list
       resolve(false);
-      return computer.computeFull(request).then((bool result) {
+      return contributor.computeFull(request).then((bool result) {
         expect(result, isTrue);
         expect(request.unit.element, isNotNull);
         assertResultsFromCache(oldSuggestions);
       });
     }
   }
 
   void assertNotCached(String completion) {
     DartCompletionCache cache = request.cache;
     if (isCached(cache.importedTypeSuggestions, completion) ||
@@ skipping 55 matching lines @@
     expect(element.parameters, isNull);
     expect(element.returnType, isNull);
     assertHasNoParameterInfo(cs);
     return cs;
   }
 
   bool isCached(List<CompletionSuggestion> suggestions, String completion) =>
       suggestions.any((CompletionSuggestion s) => s.completion == completion);
 
   @override
-  void setUpComputer() {
-    computer = new ImportedComputer(shouldWaitForLowPrioritySuggestions: true);
+  void setUpContributor() {
+    contributor = new ImportedReferenceContributor(shouldWaitForLowPrioritySuggestions: true);
   }
 
   @override
   test_ArgumentList() {
     return super.test_ArgumentList().then((_) {
       expect(request.cache.importKey, "import '/libA.dart';");
       ClassElement objClassElem1 = request.cache.importedClassMap['Object'];
       expect(objClassElem1, isNotNull);
       ClassElement objClassElem2 = request.cache.objectClassElement;
       expect(objClassElem1, same(objClassElem2));
@@ skipping 59 matching lines @@
     addTestSource('''
       import "/testAB.dart";
       import "/testCD.dart" hide D;
       import "/testEEF.dart" show EE;
       import "/testG.dart" as g;
       int T5;
       var _T6;
       Z D2() {int x;}
       class X {a() {var f; {var x;} ^ var r;} void b() { }}
       class Z { }''');
-    (computer as ImportedComputer).shouldWaitForLowPrioritySuggestions = false;
+    (contributor as ImportedReferenceContributor).shouldWaitForLowPrioritySuggestions = false;
     computeFast();
     return computeFull((bool result) {
       assertSuggestImportedClass('C');
-      // Assert computer does not wait for or include low priority results
+      // Assert contributor does not wait for or include low priority results
       // from non-imported libraries unless instructed to do so.
       assertNotSuggested('H');
     });
   }
 
   test_function_parameters_mixed_required_and_named() {
     addSource('/libA.dart', '''
 void m(x, {int y}) {}
 ''');
     addTestSource('''
@@ skipping 378 matching lines @@
       class ClassInLocalContext {int x;}''');
     testFile = '/context1/completionTest.dart';
     addTestSource('''
       import "/context1/libA.dart";
       import "/foo.dart";
       main() {C^}
       ''');
     computeFast();
     return computeFull((bool result) {
       assertSuggestImportedClass('ClassInLocalContext');
-      // Assert computer does not include results from 2nd context.
+      // Assert contributor does not include results from 2nd context.
       assertNotSuggested('ClassFromAnotherContext');
     });
   }
 
   test_no_parameters_field() {
     addSource('/libA.dart', '''
 class A {
   int x;
 }
 ''');
@@ skipping 53 matching lines @@
   }
 
   @override
   test_partFile_TypeName2() {
     return super.test_partFile_TypeName2().then((_) {
       expect(request.cache.importKey,
           'library libA;import "/testB.dart";part "/testA.dart";');
     });
   }
 }