When target requires a function, propose a function reference, not an invocation

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';
@@ skipping 25 matching lines @@
         !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.
    */
   @override
-  void assertCachedCompute(_) {
+  assertCachedCompute(_) {
     if (!(computer as ImportedComputer).shouldWaitForLowPrioritySuggestions) {
-      return;
+      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();
     int replacementOffset = request.replacementOffset;
     int replacementLength = request.replacementLength;
     request = new DartCompletionRequest(context, searchEngine, testSource,
         completionOffset, cache, new CompletionPerformance());
     request.replacementOffset = replacementOffset;
     request.replacementLength = replacementLength;
-    expect(computeFast(), isTrue);
-    expect(request.unit.element, isNull);
-    List<CompletionSuggestion> newSuggestions = request.suggestions;
-    if (newSuggestions.length == oldSuggestions.length) {
-      if (!oldSuggestions
-          .any((CompletionSuggestion s) => !newSuggestions.contains(s))) {
-        return;
+
+    void assertResultsFromCache(List<CompletionSuggestion> oldSuggestions) {
+      List<CompletionSuggestion> newSuggestions = request.suggestions;
+      if (newSuggestions.length == oldSuggestions.length) {
+        if (!oldSuggestions
+            .any((CompletionSuggestion s) => !newSuggestions.contains(s))) {
+          return;
+        }
       }
+      StringBuffer sb = new StringBuffer(
+          'suggestions based upon cached results do not match expectations');
+      sb.write('\n  Expected:');
+      oldSuggestions.toList()
+        ..sort(suggestionComparator)
+        ..forEach((CompletionSuggestion suggestion) {
+          sb.write('\n    ${suggestion.completion} -> $suggestion');
+        });
+      sb.write('\n  Actual:');
+      newSuggestions.toList()
+        ..sort(suggestionComparator)
+        ..forEach((CompletionSuggestion suggestion) {
+          sb.write('\n    ${suggestion.completion} -> $suggestion');
+        });
+      fail(sb.toString());
     }
-    StringBuffer sb = new StringBuffer(
-        'suggestions based upon cached results do not match expectations');
-    sb.write('\n  Expected:');
-    oldSuggestions.toList()
-      ..sort(suggestionComparator)
-      ..forEach((CompletionSuggestion suggestion) {
-        sb.write('\n    ${suggestion.completion} -> $suggestion');
+
+    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) {
+        expect(result, isTrue);
+        expect(request.unit.element, isNotNull);
+        assertResultsFromCache(oldSuggestions);
       });
-    sb.write('\n  Actual:');
-    newSuggestions.toList()
-      ..sort(suggestionComparator)
-      ..forEach((CompletionSuggestion suggestion) {
-        sb.write('\n    ${suggestion.completion} -> $suggestion');
-      });
-    fail(sb.toString());
+    }
   }
 
   void assertNotCached(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 NOT to be cached');
     }
   }
 
   @override
   CompletionSuggestion assertSuggestImportedConstructor(String name) {
     return assertSuggestConstructor(name);
   }
 
   @override
   CompletionSuggestion assertSuggestImportedField(String name, String type,
       {int relevance: DART_RELEVANCE_INHERITED_FIELD}) {
     return assertSuggestField(name, type, relevance: relevance);
   }
 
+  @override
+  CompletionSuggestion assertSuggestImportedFunction(
+      String name, String returnType,
+      {CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION,
+      bool deprecated: false, int relevance: DART_RELEVANCE_DEFAULT}) {
+    return assertSuggestFunction(name, returnType,
+        kind: kind, deprecated: deprecated, relevance: relevance);
+  }
+
   CompletionSuggestion assertSuggestImportedGetter(
       String name, String returnType,
       {int relevance: DART_RELEVANCE_INHERITED_ACCESSOR}) {
     return assertSuggestGetter(name, returnType, relevance: relevance);
   }
 
   CompletionSuggestion assertSuggestImportedMethod(
       String name, String declaringType, String returnType,
       {int relevance: DART_RELEVANCE_INHERITED_METHOD}) {
     return assertSuggestMethod(name, declaringType, returnType,
@@ skipping 577 matching lines @@
   }
 
   @override
   test_partFile_TypeName2() {
     return super.test_partFile_TypeName2().then((_) {
       expect(request.cache.importKey,
           'library libA;import "/testB.dart";part "/testA.dart";');
     });
   }
 }