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

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 216 matching lines @@
     expect(element.kind, equals(protocol.ElementKind.FIELD));
     expect(element.name, equals(name));
     expect(element.parameters, isNull);
     // The returnType represents the type of a field
     expect(element.returnType, type != null ? type : 'dynamic');
     assertHasNoParameterInfo(cs);
     return cs;
   }
 
   CompletionSuggestion assertSuggestFunction(String name, String returnType,
-      [bool isDeprecated = false, int relevance = DART_RELEVANCE_DEFAULT,
-      CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
+      {CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION,
+      bool deprecated: false, int relevance: DART_RELEVANCE_DEFAULT}) {
     CompletionSuggestion cs = assertSuggest(name,
-        csKind: kind, relevance: relevance, isDeprecated: isDeprecated);
+        csKind: kind, relevance: relevance, isDeprecated: deprecated);
     expect(cs.returnType, returnType != null ? returnType : 'dynamic');
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.FUNCTION));
     expect(element.name, equals(name));
-    expect(element.isDeprecated, equals(isDeprecated));
+    expect(element.isDeprecated, equals(deprecated));
     String param = element.parameters;
     expect(param, isNotNull);
     expect(param[0], equals('('));
     expect(param[param.length - 1], equals(')'));
     expect(element.returnType,
         equals(returnType != null ? returnType : 'dynamic'));
     assertHasParameterInfo(cs);
     return cs;
   }
 
@@ skipping 169 matching lines @@
     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);
     }
-
-    // Index SDK
-    for (Source librarySource in context.librarySources) {
-      CompilationUnit unit =
-          context.getResolvedCompilationUnit2(librarySource, librarySource);
-      if (unit != null) {
-        index.indexUnit(context, unit);
-      }
-    }
-
-    var result = context.performAnalysisTask();
-    bool resolved = false;
-    while (result.hasMoreWork) {
-
-      // Update the index
-      result.changeNotices.forEach((ChangeNotice notice) {
-        CompilationUnit unit = notice.resolvedDartUnit;
-        if (unit != null) {
-          index.indexUnit(context, unit);
-        }
-      });
-
-      // If the unit has been resolved, then finish the completion
-      List<Source> libSourceList = context.getLibrariesContaining(testSource);
-      if (libSourceList.length > 0) {
-        LibraryElement library = context.getLibraryElement(libSourceList[0]);
-        if (library != null) {
-          CompilationUnit unit =
-              context.getResolvedCompilationUnit(testSource, library);
-          if (unit != null) {
-            request.unit = unit;
-            request.node =
-                new NodeLocator.con1(completionOffset).searchWithin(unit);
-            resolved = true;
-            if (!fullAnalysis) {
-              break;
-            }
-          }
-        }
-      }
-
-      result = context.performAnalysisTask();
-    }
-    if (!resolved) {
-      fail('expected unit to be resolved');
-    }
+    resolve(fullAnalysis);
     return computer.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)
@@ skipping 32 matching lines @@
       if (cs == null) {
         cs = s;
       } else {
         failedCompletion('expected exactly one $cs',
             request.suggestions.where((s) => s.completion == completion));
       }
     });
     return cs;
   }
 
+  void resolve(bool fullAnalysis) {
+
+    // Index SDK
+    for (Source librarySource in context.librarySources) {
+      CompilationUnit unit =
+          context.getResolvedCompilationUnit2(librarySource, librarySource);
+      if (unit != null) {
+        index.indexUnit(context, unit);
+      }
+    }
+
+    var result = context.performAnalysisTask();
+    bool resolved = false;
+    while (result.hasMoreWork) {
+
+      // Update the index
+      result.changeNotices.forEach((ChangeNotice notice) {
+        CompilationUnit unit = notice.resolvedDartUnit;
+        if (unit != null) {
+          index.indexUnit(context, unit);
+        }
+      });
+
+      // If the unit has been resolved, then finish the completion
+      List<Source> libSourceList = context.getLibrariesContaining(testSource);
+      if (libSourceList.length > 0) {
+        LibraryElement library = context.getLibraryElement(libSourceList[0]);
+        if (library != null) {
+          CompilationUnit unit =
+              context.getResolvedCompilationUnit(testSource, library);
+          if (unit != null) {
+            request.unit = unit;
+            request.node =
+                new NodeLocator.con1(completionOffset).searchWithin(unit);
+            resolved = true;
+            if (!fullAnalysis) {
+              break;
+            }
+          }
+        }
+      }
+
+      result = context.performAnalysisTask();
+    }
+    if (!resolved) {
+      fail('expected unit to be resolved');
+    }
+  }
+
   @override
   void setUp() {
     super.setUp();
     index = createLocalMemoryIndex();
     searchEngine = new SearchEngineImpl(index);
     setUpComputer();
   }
 
   void setUpComputer();
 }
 
 /**
  * Common tests for `ImportedTypeComputerTest`, `InvocationComputerTest`,
  * and `LocalComputerTest`.
  */
 abstract class AbstractSelectorSuggestionTest extends AbstractCompletionTest {
 
   /**
    * Assert that the ImportedComputer uses cached results to produce identical
    * suggestions to the original set of suggestions.
    */
   void assertCachedCompute(_) {
     // Subclasses override
   }
 
   CompletionSuggestion assertSuggestImportedClass(String name,
-      [int relevance = DART_RELEVANCE_DEFAULT,
-      CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
+      {CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION,
+      int relevance: DART_RELEVANCE_DEFAULT}) {
     if (computer is ImportedComputer) {
       return assertSuggestClass(name, relevance: relevance, kind: kind);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestImportedConstructor(String name) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestImportedField(String name, String type,
       {int relevance: DART_RELEVANCE_INHERITED_FIELD}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestImportedFunction(
-      String name, String returnType, [bool isDeprecated = false,
-      int relevance = DART_RELEVANCE_DEFAULT,
-      CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
-    if (computer is ImportedComputer) {
-      return assertSuggestFunction(
-          name, returnType, isDeprecated, relevance, kind);
-    } else {
-      return assertNotSuggested(name);
-    }
+      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) {
       return assertSuggestFunctionTypeAlias(
           name, returnType, isDeprecated, relevance, kind);
     } else {
@@ skipping 77 matching lines @@
       String name, String returnType,
       [int relevance = DART_RELEVANCE_DEFAULT]) {
     if (computer is InvocationComputer) {
       return assertSuggestTopLevelVar(name, returnType, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestLocalClass(String name,
-      {int relevance: DART_RELEVANCE_DEFAULT, bool isDeprecated: false}) {
+      {CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION,
+      int relevance: DART_RELEVANCE_DEFAULT, bool isDeprecated: false}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestLocalClassTypeAlias(String name,
       {int relevance: DART_RELEVANCE_DEFAULT}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestLocalConstructor(String name) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestLocalField(String name, String type,
       {int relevance: DART_RELEVANCE_LOCAL_FIELD, bool deprecated: false}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestLocalFunction(
-      String name, String returnType,
-      {bool deprecated: false, int relevance: DART_RELEVANCE_LOCAL_FUNCTION}) {
+      String name, String returnType, {bool deprecated: false,
+      int relevance: DART_RELEVANCE_LOCAL_FUNCTION,
+      CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestLocalFunctionTypeAlias(
       String name, String returnType,
       {bool deprecated: false, int relevance: DART_RELEVANCE_DEFAULT}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestLocalGetter(String name, String returnType,
@@ skipping 20 matching lines @@
 
   CompletionSuggestion assertSuggestLocalVariable(
       String name, String returnType,
       {int relevance: DART_RELEVANCE_LOCAL_VARIABLE}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestNonLocalClass(String name,
       [int relevance = DART_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
-    return assertSuggestImportedClass(name, relevance, kind);
+    return assertSuggestImportedClass(name, relevance: relevance, kind: kind);
   }
 
   Future computeFull(assertFunction(bool result), {bool fullAnalysis: true}) {
     return super
         .computeFull(assertFunction, fullAnalysis: fullAnalysis)
         .then(assertCachedCompute);
   }
 
   test_ArgumentList() {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
@@ skipping 43 matching lines @@
       assertSuggestImportedFunction('hasLength', 'bool');
       assertSuggestImportedFunction('identical', 'bool');
       assertSuggestLocalClass('B');
       assertSuggestImportedClass('Object');
       assertNotSuggested('main');
       assertNotSuggested('baz');
       assertNotSuggested('print');
     });
   }
 
+  test_ArgumentList_InstanceCreationExpression_functionalArg() {
+    // ArgumentList  InstanceCreationExpression  ExpressionStatement  Block
+    addSource('/libA.dart', '''
+      library A;
+      class A { A(f()) { } }
+      bool hasLength(int expected) { }
+      void baz() { }''');
+    addTestSource('''
+      import 'dart:async';
+      import '/libA.dart';
+      class B { }
+      String bar() => true;
+      void main() {new A(^)}''');
+    computeFast();
+    return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
+      assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
+      assertSuggestLocalFunction(
+          'bar', 'String', kind: CompletionSuggestionKind.IDENTIFIER);
+      assertSuggestImportedFunction('hasLength', 'bool',
+          kind: CompletionSuggestionKind.IDENTIFIER);
+      assertSuggestImportedFunction('identical', 'bool',
+          kind: CompletionSuggestionKind.IDENTIFIER);
+      assertSuggestLocalClass('B', kind: CompletionSuggestionKind.IDENTIFIER);
+      assertSuggestImportedClass('A',
+          kind: CompletionSuggestionKind.IDENTIFIER);
+      assertSuggestImportedClass('Object',
+          kind: CompletionSuggestionKind.IDENTIFIER);
+      assertNotSuggested('main');
+      assertNotSuggested('baz');
+      assertNotSuggested('print');
+    });
+  }
+
+  test_ArgumentList_InstanceCreationExpression_typedefArg() {
+    // ArgumentList  InstanceCreationExpression  ExpressionStatement  Block
+    addSource('/libA.dart', '''
+      library A;
+      typedef Funct();
+      class A { A(Funct f) { } }
+      bool hasLength(int expected) { }
+      void baz() { }''');
+    addTestSource('''
+      import 'dart:async';
+      import '/libA.dart';
+      class B { }
+      String bar() => true;
+      void main() {new A(^)}''');
+    computeFast();
+    return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
+      assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
+      assertSuggestLocalFunction(
+          'bar', 'String', kind: CompletionSuggestionKind.IDENTIFIER);
+      assertSuggestImportedFunction('hasLength', 'bool',
+          kind: CompletionSuggestionKind.IDENTIFIER);
+      assertSuggestImportedFunction('identical', 'bool',
+          kind: CompletionSuggestionKind.IDENTIFIER);
+      assertSuggestLocalClass('B', kind: CompletionSuggestionKind.IDENTIFIER);
+      assertSuggestImportedClass('A',
+          kind: CompletionSuggestionKind.IDENTIFIER);
+      assertSuggestImportedClass('Object',
+          kind: CompletionSuggestionKind.IDENTIFIER);
+      assertNotSuggested('main');
+      assertNotSuggested('baz');
+      assertNotSuggested('print');
+    });
+  }
+
   test_ArgumentList_local_function() {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
     addSource('/libA.dart', '''
       library A;
       bool hasLength(int expected) { }
       void baz() { }''');
     addTestSource('''
       import '/libA.dart'
       expect(arg) { }
       class B { }
@@ skipping 36 matching lines @@
       assertSuggestImportedFunction('hasLength', 'bool');
       assertSuggestImportedFunction('identical', 'bool');
       assertSuggestLocalClass('B');
       assertSuggestImportedClass('Object');
       assertNotSuggested('main');
       assertNotSuggested('baz');
       assertNotSuggested('print');
     });
   }
 
+  test_ArgumentList_MethodInvocation_functionalArg() {
+    // ArgumentList  MethodInvocation  ExpressionStatement  Block
+    addSource('/libA.dart', '''
+      library A;
+      class A { A(f()) { } }
+      bool hasLength(int expected) { }
+      void baz() { }''');
+    addTestSource('''
+      import 'dart:async';
+      import '/libA.dart';
+      class B { }
+      String bar(f()) => true;
+      void main() {bar(^);}''');
+    computeFast();
+    return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
+      assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
+      assertSuggestLocalFunction(
+          'bar', 'String', kind: CompletionSuggestionKind.IDENTIFIER);
+      assertSuggestImportedFunction('hasLength', 'bool',
+          kind: CompletionSuggestionKind.IDENTIFIER);
+      assertSuggestImportedFunction('identical', 'bool',
+          kind: CompletionSuggestionKind.IDENTIFIER);
+      assertSuggestLocalClass('B', kind: CompletionSuggestionKind.IDENTIFIER);
+      assertSuggestImportedClass('A',
+          kind: CompletionSuggestionKind.IDENTIFIER);
+      assertSuggestImportedClass('Object',
+          kind: CompletionSuggestionKind.IDENTIFIER);
+      assertNotSuggested('main');
+      assertNotSuggested('baz');
+      assertNotSuggested('print');
+    });
+  }
+
+  test_ArgumentList_MethodInvocation_methodArg() {
+    // ArgumentList  MethodInvocation  ExpressionStatement  Block
+    addSource('/libA.dart', '''
+      library A;
+      class A { A(f()) { } }
+      bool hasLength(int expected) { }
+      void baz() { }''');
+    addTestSource('''
+      import 'dart:async';
+      import '/libA.dart';
+      class B { String bar(f()) => true; }
+      void main() {new B().bar(^);}''');
+    computeFast();
+    return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
+      assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
+      assertSuggestImportedFunction(
+          'hasLength', 'bool', kind: CompletionSuggestionKind.IDENTIFIER);
+      assertSuggestImportedFunction('identical', 'bool',
+          kind: CompletionSuggestionKind.IDENTIFIER);
+      assertSuggestLocalClass('B', kind: CompletionSuggestionKind.IDENTIFIER);
+      assertSuggestImportedClass('A',
+          kind: CompletionSuggestionKind.IDENTIFIER);
+      assertSuggestImportedClass('Object',
+          kind: CompletionSuggestionKind.IDENTIFIER);
+      assertNotSuggested('main');
+      assertNotSuggested('baz');
+      assertNotSuggested('print');
+    });
+  }
+
   test_ArgumentList_namedParam() {
     // SimpleIdentifier  NamedExpression  ArgumentList  MethodInvocation
     // ExpressionStatement
     addSource('/libA.dart', '''
       library A;
       bool hasLength(int expected) { }''');
     addTestSource('''
       import '/libA.dart'
       String bar() => true;
       void main() {expect(foo: ^)}''');
@@ skipping 252 matching lines @@
       //assertSuggestImportedFunction(
       //    'D1', null, true, COMPLETION_RELEVANCE_LOW);
       assertSuggestLocalFunction('D2', 'Z');
       assertSuggestImportedClass('EE');
       // hidden element suggested as low relevance
       //assertSuggestImportedClass('F', COMPLETION_RELEVANCE_LOW);
       assertSuggestLibraryPrefix('g');
       assertNotSuggested('G');
       //assertSuggestImportedClass('H', COMPLETION_RELEVANCE_LOW);
       assertSuggestImportedClass('Object');
-      assertSuggestImportedFunction('min', 'num', false);
+      assertSuggestImportedFunction('min', 'num');
       //assertSuggestImportedFunction(
       //    'max',
       //    'num',
       //    false,
       //    COMPLETION_RELEVANCE_LOW);
       assertSuggestTopLevelVarGetterSetter('T1', 'String');
       assertNotSuggested('_T2');
       //assertSuggestImportedTopLevelVar('T3', 'int', COMPLETION_RELEVANCE_LOW);
       assertNotSuggested('_T4');
       assertSuggestLocalTopLevelVar('T5', 'int');
@@ skipping 49 matching lines @@
       assertSuggestLocalVariable('f', null);
       // Don't suggest locals out of scope
       assertNotSuggested('r');
       assertNotSuggested('x');
 
       // imported elements are portially filtered
       //assertSuggestImportedClass('A');
       assertNotSuggested('_B');
       //assertSuggestImportedClass('C');
       // hidden element suggested as low relevance
-      assertSuggestImportedClass('D', DART_RELEVANCE_LOW);
-      assertSuggestImportedFunction('D1', null, true, DART_RELEVANCE_LOW);
+      assertSuggestImportedClass('D', relevance: DART_RELEVANCE_LOW);
+      assertSuggestImportedFunction(
+          'D1', null, deprecated: true, relevance: DART_RELEVANCE_LOW);
       assertSuggestLocalFunction('D2', 'Z');
       //assertSuggestImportedClass('EE');
       // hidden element suggested as low relevance
       //assertSuggestImportedClass('F', COMPLETION_RELEVANCE_LOW);
       //assertSuggestLibraryPrefix('g');
       assertNotSuggested('G');
       //assertSuggestImportedClass('H', COMPLETION_RELEVANCE_LOW);
       //assertSuggestImportedClass('Object');
       //assertSuggestImportedFunction('min', 'num', false);
       //assertSuggestImportedFunction(
@@ skipping 535 matching lines @@
     addTestSource('''
       import "/testA.dart";
       typedef int F2(int blat);
       class Clz = Object with Object;
       class C {foo(){^} void bar() {}}''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       assertSuggestImportedClass('A');
-      assertSuggestImportedFunction('F1', '_B', false);
+      assertSuggestImportedFunction('F1', '_B');
       assertSuggestLocalClass('C');
       assertSuggestLocalMethod('foo', 'C', null);
       assertSuggestLocalMethod('bar', 'C', 'void');
       assertSuggestLocalFunctionTypeAlias('F2', 'int');
       assertSuggestLocalClassTypeAlias('Clz');
       assertSuggestLocalClass('C');
       assertNotSuggested('x');
       assertNotSuggested('_B');
     });
   }
@@ skipping 1280 matching lines @@
       assertNotSuggested('bar2');
       assertNotSuggested('_B');
       assertSuggestLocalClass('Y');
       assertSuggestLocalClass('C');
       assertSuggestLocalVariable('f', null);
       assertNotSuggested('x');
       assertNotSuggested('e');
     });
   }
 }