improve element parameter string returned by local suggestion computer

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 89 matching lines @@
   }
 
   CompletionSuggestion assertSuggestClass(String name,
       [CompletionRelevance relevance = CompletionRelevance.DEFAULT]) {
     CompletionSuggestion cs =
         assertSuggest(CompletionSuggestionKind.CLASS, name, 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);
     expect(element.returnType, isNull);
     return cs;
   }
 
   CompletionSuggestion assertSuggestFunction(String name, String returnType,
       bool isDeprecated, [CompletionRelevance relevance =
       CompletionRelevance.DEFAULT]) {
     CompletionSuggestion cs = assertSuggest(
         CompletionSuggestionKind.FUNCTION,
         name,
         relevance,
         isDeprecated);
     expect(cs.returnType, equals(returnType));
     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));
+    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'));
     return cs;
   }
 
   CompletionSuggestion assertSuggestGetter(String name, String returnType,
       [CompletionRelevance relevance = CompletionRelevance.DEFAULT]) {
     CompletionSuggestion cs =
         assertSuggest(CompletionSuggestionKind.GETTER, name, relevance);
     expect(cs.returnType, equals(returnType));
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.GETTER));
     expect(element.name, equals(name));
+    //TODO (danrubel) getter should have parameters
+    // but not used in code completion
+    //expect(element.parameters, '()');
     expect(
         element.returnType,
         equals(returnType != null ? returnType : 'dynamic'));
     return cs;
   }
 
   CompletionSuggestion assertSuggestLibraryPrefix(String prefix,
       [CompletionRelevance relevance = CompletionRelevance.DEFAULT]) {
     // Library prefix should only be suggested by ImportedComputer
     if (computer is ImportedComputer) {
       CompletionSuggestion cs =
           assertSuggest(CompletionSuggestionKind.LIBRARY_PREFIX, prefix, relevance);
       protocol.Element element = cs.element;
       expect(element, isNotNull);
       expect(element.kind, equals(protocol.ElementKind.LIBRARY));
+      expect(element.parameters, isNull);
       expect(element.returnType, isNull);
       return cs;
     } else {
       return assertNotSuggested(prefix);
     }
   }
 
   CompletionSuggestion assertSuggestLocalVariable(String name,
       String returnType, [CompletionRelevance relevance =
       CompletionRelevance.DEFAULT]) {
     // Local variables should only be suggested by LocalComputer
     if (computer is LocalComputer) {
       CompletionSuggestion cs =
           assertSuggest(CompletionSuggestionKind.LOCAL_VARIABLE, name, relevance);
       expect(cs.returnType, equals(returnType));
       protocol.Element element = cs.element;
       expect(element, isNotNull);
       expect(element.kind, equals(protocol.ElementKind.LOCAL_VARIABLE));
       expect(element.name, equals(name));
+      expect(element.parameters, isNull);
       expect(
           element.returnType,
           equals(returnType != null ? returnType : 'dynamic'));
       return cs;
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestMethod(String name, String declaringType,
       String returnType, [CompletionRelevance relevance =
       CompletionRelevance.DEFAULT]) {
     CompletionSuggestion cs =
         assertSuggest(CompletionSuggestionKind.METHOD, name, relevance);
     expect(cs.declaringType, equals(declaringType));
     expect(cs.returnType, equals(returnType));
     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,
         equals(returnType != null ? returnType : 'dynamic'));
     return cs;
   }
 
   CompletionSuggestion assertSuggestNamedConstructor(String name,
       String returnType, [CompletionRelevance relevance =
       CompletionRelevance.DEFAULT]) {
     if (computer is InvocationComputer) {
       CompletionSuggestion cs =
           assertSuggest(CompletionSuggestionKind.CONSTRUCTOR, name, 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(')'));
       expect(element.returnType, equals(returnType));
       return cs;
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestParameter(String name, String returnType,
       [CompletionRelevance relevance = CompletionRelevance.DEFAULT]) {
     // Parameters should only be suggested by LocalComputer
     if (computer is LocalComputer) {
       CompletionSuggestion cs =
           assertSuggest(CompletionSuggestionKind.PARAMETER, name, relevance);
       expect(cs.returnType, equals(returnType));
       protocol.Element element = cs.element;
       expect(element, isNotNull);
       expect(element.kind, equals(protocol.ElementKind.PARAMETER));
       expect(element.name, equals(name));
+      expect(element.parameters, isNull);
       expect(
           element.returnType,
           equals(returnType != null ? returnType : 'dynamic'));
       return cs;
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestSetter(String name,
       [CompletionRelevance relevance = CompletionRelevance.DEFAULT]) {
     CompletionSuggestion cs =
         assertSuggest(CompletionSuggestionKind.SETTER, name, relevance);
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.SETTER));
     expect(element.name, equals(name));
+    // TODO (danrubel) assert setter param
+    //expect(element.parameters, isNull);
     expect(element.returnType, isNull);
     return cs;
   }
 
   CompletionSuggestion assertSuggestTopLevelVar(String name, String returnType,
       [CompletionRelevance relevance = CompletionRelevance.DEFAULT]) {
     CompletionSuggestion cs =
         assertSuggest(CompletionSuggestionKind.TOP_LEVEL_VARIABLE, name, relevance);
     expect(cs.returnType, equals(returnType));
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.TOP_LEVEL_VARIABLE));
     expect(element.name, equals(name));
+    expect(element.parameters, isNull);
     //TODO (danrubel) return type level variable 'type' but not as 'returnType'
 //    expect(
 //        element.returnType,
 //        equals(returnType != null ? returnType : 'dynamic'));
     return cs;
   }
 
   void assertSuggestTopLevelVarGetterSetter(String name, String returnType,
       [CompletionRelevance relevance = CompletionRelevance.DEFAULT]) {
     if (computer is ImportedComputer) {
@@ skipping 1344 matching lines @@
       assertNotSuggested('bar2');
       assertNotSuggested('_B');
       assertSuggestLocalClass('Y');
       assertSuggestLocalClass('C');
       assertSuggestLocalVariable('f', null);
       assertNotSuggested('x');
       assertNotSuggested('e');
     });
   }
 }