first cut argument list completion suggestions

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 37 matching lines @@
     expect(completionOffset, isNot(equals(-1)), reason: 'missing ^');
     int nextOffset = content.indexOf('^', completionOffset + 1);
     expect(nextOffset, equals(-1), reason: 'too many ^');
     content = content.substring(0, completionOffset) +
         content.substring(completionOffset + 1);
     testSource = addSource(testFile, content);
     request =
         new DartCompletionRequest(context, searchEngine, testSource, completionOffset);
   }
 
-  void assertNoSuggestions() {
-    if (request.suggestions.length > 0) {
-      _failedCompletion('Expected no suggestions', request.suggestions);
+  void assertNoSuggestions({CompletionSuggestionKind kind: null}) {
+    if (kind == null) {
+      if (request.suggestions.length > 0) {
+        failedCompletion('Expected no suggestions', request.suggestions);
+      }
+      return;
+    }
+    CompletionSuggestion suggestion = request.suggestions.firstWhere(
+        (CompletionSuggestion cs) => cs.kind == kind,
+        orElse: () => null);
+    if (suggestion != null) {
+      failedCompletion('did not expect completion: $completion\n  $suggestion');
     }
   }
 
   CompletionSuggestion assertNotSuggested(String completion) {
     CompletionSuggestion suggestion = request.suggestions.firstWhere(
-        (cs) => cs.completion == completion,
+        (CompletionSuggestion cs) => cs.completion == completion,
         orElse: () => null);
     if (suggestion != null) {
-      _failedCompletion(
-          'did not expect completion: $completion\n  $suggestion');
+      failedCompletion('did not expect completion: $completion\n  $suggestion');
     }
     return null;
   }
 
   CompletionSuggestion assertSuggest(String completion,
       {CompletionSuggestionKind csKind: CompletionSuggestionKind.INVOCATION,
       CompletionRelevance relevance: CompletionRelevance.DEFAULT,
       protocol.ElementKind elemKind: null, bool isDeprecated: false, bool isPotential:
       false}) {
-    CompletionSuggestion cs;
-    request.suggestions.forEach((s) {
-      if (s.completion == completion && s.kind == csKind) {
-        protocol.Element element = s.element;
-        if (elemKind == null || (element != null && elemKind == element.kind)) {
-          if (cs == null) {
-            cs = s;
-          } else {
-            _failedCompletion(
-                'expected exactly one $completion',
-                request.suggestions.where((s) => s.completion == completion));
-          }
-        }
-      }
-    });
+    CompletionSuggestion cs =
+        getSuggest(completion: completion, csKind: csKind, elemKind: elemKind);
     if (cs == null) {
-      _failedCompletion('expected $completion $csKind', request.suggestions);
+      failedCompletion('expected $completion $csKind', request.suggestions);
     }
     expect(cs.kind, equals(csKind));
     if (isDeprecated) {
       expect(cs.relevance, equals(CompletionRelevance.LOW));
     } else {
       expect(cs.relevance, equals(relevance));
     }
     expect(cs.selectionOffset, equals(completion.length));
     expect(cs.selectionLength, equals(0));
     expect(cs.isDeprecated, equals(isDeprecated));
     expect(cs.isPotential, equals(isPotential));
     return cs;
   }
 
+  void assertSuggestArgumentList(List<String> paramNames, List<String> paramTypes) {
+    CompletionSuggestionKind csKind = CompletionSuggestionKind.ARGUMENT_LIST;
+    CompletionSuggestion cs = getSuggest(csKind: csKind);
+    if (cs == null) {
+      failedCompletion('expected completion $csKind', request.suggestions);
+    }
+    assertSuggestArgumentList_params(
+        paramNames,
+        paramTypes,
+        cs.parameterNames,
+        cs.parameterTypes);
+    expect(cs.relevance, CompletionRelevance.HIGH);
+  }
+
+  void assertSuggestArgumentList_params(List<String> expectedNames,
+      List<String> expectedTypes, List<String> actualNames,
+      List<String> actualTypes) {
+    if (actualNames != null &&
+        actualNames.length == expectedNames.length &&
+        actualTypes != null &&
+        actualTypes.length == expectedTypes.length) {
+      int index = 0;
+      while (index < expectedNames.length) {
+        if (actualNames[index] != expectedNames[index] ||
+            actualTypes[index] != expectedTypes[index]) {
+          break;
+        }
+        ++index;
+      }
+      if (index == expectedNames.length) {
+        return;
+      }
+    }
+    StringBuffer msg = new StringBuffer();
+    msg.writeln('Argument list not the same');
+    msg.writeln('  Expected names: $expectedNames');
+    msg.writeln('           found: $actualNames');
+    msg.writeln('  Expected types: $expectedTypes');
+    msg.writeln('           found: $actualTypes');
+    fail(msg.toString());
+  }
+
   CompletionSuggestion assertSuggestClass(String name,
       [CompletionRelevance relevance = CompletionRelevance.DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     CompletionSuggestion cs =
         assertSuggest(name, csKind: kind, relevance: relevance);
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.CLASS));
     expect(element.name, equals(name));
     expect(element.parameters, isNull);
@@ skipping 293 matching lines @@
       }
 
       result = context.performAnalysisTask();
     }
     if (!resolved) {
       fail('expected unit to be resolved');
     }
     return computer.computeFull(request);
   }
 
-  @override
-  void setUp() {
-    super.setUp();
-    index = createLocalMemoryIndex();
-    searchEngine = new SearchEngineImpl(index);
-  }
-
-  void _failedCompletion(String message,
+  void failedCompletion(String message,
       [Iterable<CompletionSuggestion> completions]) {
     StringBuffer sb = new StringBuffer(message);
     if (completions != null) {
       sb.write('\n  found');
       completions.toList()
           ..sort((CompletionSuggestion s1, CompletionSuggestion s2) {
             String c1 = s1.completion.toLowerCase();
             String c2 = s2.completion.toLowerCase();
             return c1.compareTo(c2);
           })
           ..forEach((CompletionSuggestion suggestion) {
             sb.write('\n    ${suggestion.completion} -> $suggestion');
           });
     }
     if (completionNode != null) {
       sb.write('\n  in');
       AstNode node = completionNode;
       while (node != null) {
         sb.write('\n    ${node.runtimeType}');
         node = node.parent;
       }
     }
     fail(sb.toString());
   }
+
+  CompletionSuggestion getSuggest({String completion: null,
+      CompletionSuggestionKind csKind: null, protocol.ElementKind elemKind: null}) {
+    CompletionSuggestion cs;
+    request.suggestions.forEach((CompletionSuggestion s) {
+      if (completion != null && completion != s.completion) {
+        return;
+      }
+      if (csKind != null && csKind != s.kind) {
+        return;
+      }
+      if (elemKind != null) {
+        protocol.Element element = s.element;
+        if (element == null || elemKind != element.kind) {
+          return;
+        }
+      }
+      if (cs == null) {
+        cs = s;
+      } else {
+        failedCompletion(
+            'expected exactly one $cs',
+            request.suggestions.where((s) => s.completion == completion));
+      }
+    });
+    return cs;
+  }
+
+  @override
+  void setUp() {
+    super.setUp();
+    index = createLocalMemoryIndex();
+    searchEngine = new SearchEngineImpl(index);
+  }
 }
 
 /**
  * Common tests for `ImportedTypeComputerTest`, `InvocationComputerTest`,
  * and `LocalComputerTest`.
  */
 class AbstractSelectorSuggestionTest extends AbstractCompletionTest {
 
   CompletionSuggestion assertLocalSuggestMethod(String name,
       String declaringType, String returnType, [CompletionRelevance relevance =
@@ skipping 206 matching lines @@
       library A;
       bool hasLength(int expected) { }
       void baz() { }''');
     addTestSource('''
       import '/libA.dart'
       class B { }
       String bar() => true;
       void main() {expect(^)}''');
     computeFast();
     return computeFull(true).then((_) {
+      assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
       assertSuggestLocalFunction('bar', 'String');
       assertSuggestImportedFunction('hasLength', 'bool');
       assertSuggestImportedFunction('identical', 'bool');
+      assertSuggestLocalClass('B');
+      assertSuggestImportedClass('Object');
+      assertNotSuggested('main');
+      assertNotSuggested('baz');
+      assertNotSuggested('print');
+    });
+  }
+
+  test_ArgumentList_imported_function() {
+    // ArgumentList  MethodInvocation  ExpressionStatement  Block
+    addSource('/libA.dart', '''
+      library A;
+      bool hasLength(int expected) { }
+      expect(arg) { }
+      void baz() { }''');
+    addTestSource('''
+      import '/libA.dart'
+      class B { }
+      String bar() => true;
+      void main() {expect(^)}''');
+    computeFast();
+    return computeFull(true).then((_) {
+      assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
+      assertSuggestLocalFunction('bar', 'String');
+      assertSuggestImportedFunction('hasLength', 'bool');
+      assertSuggestImportedFunction('identical', 'bool');
+      assertSuggestLocalClass('B');
+      assertSuggestImportedClass('Object');
+      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 { }
+      String bar() => true;
+      void main() {expect(^)}''');
+    computeFast();
+    return computeFull(true).then((_) {
+      assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
+      assertSuggestLocalFunction('bar', 'String');
+      assertSuggestImportedFunction('hasLength', 'bool');
+      assertSuggestImportedFunction('identical', 'bool');
+      assertSuggestLocalClass('B');
+      assertSuggestImportedClass('Object');
+      assertNotSuggested('main');
+      assertNotSuggested('baz');
+      assertNotSuggested('print');
+    });
+  }
+
+  test_ArgumentList_local_method() {
+    // ArgumentList  MethodInvocation  ExpressionStatement  Block
+    addSource('/libA.dart', '''
+      library A;
+      bool hasLength(int expected) { }
+      void baz() { }''');
+    addTestSource('''
+      import '/libA.dart'
+      class B {
+        expect(arg) { }
+        void foo() {expect(^)}}
+      String bar() => true;''');
+    computeFast();
+    return computeFull(true).then((_) {
+      assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
+      assertSuggestLocalFunction('bar', 'String');
+      assertSuggestImportedFunction('hasLength', 'bool');
+      assertSuggestImportedFunction('identical', 'bool');
       assertSuggestLocalClass('B');
       assertSuggestImportedClass('Object');
       assertNotSuggested('main');
       assertNotSuggested('baz');
       assertNotSuggested('print');
     });
   }
 
   test_ArgumentList_namedParam() {
     // SimpleIdentifier  NamedExpression  ArgumentList  MethodInvocation
@@ skipping 1190 matching lines @@
       assertNotSuggested('bar2');
       assertNotSuggested('_B');
       assertSuggestLocalClass('Y');
       assertSuggestLocalClass('C');
       assertSuggestLocalVariable('f', null);
       assertNotSuggested('x');
       assertNotSuggested('e');
     });
   }
 }