improve element parameter string returned by local suggestion computer

pkg/analysis_server/lib/src/services/completion/imported_computer.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 services.completion.computer.dart.toplevel;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/protocol_server.dart' hide Element,
     ElementKind;
@@ skipping 178 matching lines @@
     var directive = node.getAncestor((parent) => parent is NamespaceDirective);
     if (directive is NamespaceDirective) {
       LibraryElement library = directive.uriElement;
       LibraryElementSuggestionBuilder.suggestionsFor(request, library);
       return new Future.value(true);
     }
 
     return new Future.value(false);
   }
 
-  void _addElementSuggestion(Element element, bool typesOnly, bool excludeVoidReturn, CompletionRelevance relevance) {
+  void _addElementSuggestion(Element element, bool typesOnly,
+      bool excludeVoidReturn, CompletionRelevance relevance) {
 
     if (element is ExecutableElement) {
       if (element.isOperator) {
         return;
       }
       if (excludeVoidReturn) {
         DartType returnType = element.returnType;
         if (returnType != null && returnType.isVoid) {
           return;
         }
@@ skipping 29 matching lines @@
     if (type != null) {
       String name = type.displayName;
       if (name != null && name.length > 0 && name != 'dynamic') {
         suggestion.returnType = name;
       }
     }
 
     request.suggestions.add(suggestion);
   }
 
-  void _addElementSuggestions(List<Element> elements, bool typesOnly, bool excludeVoidReturn) {
+  void _addElementSuggestions(List<Element> elements, bool typesOnly,
+      bool excludeVoidReturn) {
     elements.forEach((Element elem) {
-      _addElementSuggestion(elem, typesOnly, excludeVoidReturn, CompletionRelevance.DEFAULT);
+      _addElementSuggestion(
+          elem,
+          typesOnly,
+          excludeVoidReturn,
+          CompletionRelevance.DEFAULT);
     });
   }
 
   Future<bool> _addImportedElementSuggestions(AstNode node, {bool typesOnly:
       false, bool excludeVoidReturn: false}) {
 
     // Exclude elements from local library
     // because they are provided by LocalComputer
     Set<LibraryElement> excludedLibs = new Set<LibraryElement>();
     excludedLibs.add(request.unit.element.enclosingElement);
 
     // Include explicitly imported elements
     Map<String, ClassElement> classMap = new Map<String, ClassElement>();
     request.unit.directives.forEach((Directive directive) {
       if (directive is ImportDirective) {
         ImportElement importElem = directive.element;
         if (importElem != null && importElem.importedLibrary != null) {
           if (directive.prefix == null) {
             Namespace importNamespace =
                 new NamespaceBuilder().createImportNamespaceForDirective(importElem);
             // Include top level elements
             importNamespace.definedNames.forEach((String name, Element elem) {
               if (elem is ClassElement) {
                 classMap[name] = elem;
               }
-                _addElementSuggestion(elem, typesOnly, excludeVoidReturn, CompletionRelevance.DEFAULT);
+              _addElementSuggestion(
+                  elem,
+                  typesOnly,
+                  excludeVoidReturn,
+                  CompletionRelevance.DEFAULT);
             });
           } else {
             // Exclude elements from prefixed imports
             // because they are provided by InvocationComputer
             excludedLibs.add(importElem.importedLibrary);
             _addLibraryPrefixSuggestion(importElem);
           }
         }
       }
     });
 
     // Include implicitly imported dart:core elements
     Source coreUri = request.context.sourceFactory.forUri('dart:core');
     LibraryElement coreLib = request.context.getLibraryElement(coreUri);
     Namespace coreNamespace =
         new NamespaceBuilder().createPublicNamespaceForLibrary(coreLib);
     coreNamespace.definedNames.forEach((String name, Element elem) {
       if (elem is ClassElement) {
         classMap[name] = elem;
       }
-        _addElementSuggestion(elem, typesOnly, excludeVoidReturn, CompletionRelevance.DEFAULT);
+      _addElementSuggestion(
+          elem,
+          typesOnly,
+          excludeVoidReturn,
+          CompletionRelevance.DEFAULT);
     });
 
     // Build a list of inherited types that are imported
     // and include any inherited imported members
     var classDecl = node.getAncestor((p) => p is ClassDeclaration);
     if (classDecl is ClassDeclaration) {
       List<String> inheritedTypes = new List<String>();
       visitInheritedTypes(classDecl, (ClassDeclaration classDecl) {
         // ignored
       }, (String typeName) {
         inheritedTypes.add(typeName);
       });
       Set<String> visited = new Set<String>();
       while (inheritedTypes.length > 0) {
         String name = inheritedTypes.removeLast();
         ClassElement elem = classMap[name];
         if (visited.add(name) && elem != null) {
           _addElementSuggestions(elem.accessors, typesOnly, excludeVoidReturn);
           _addElementSuggestions(elem.methods, typesOnly, excludeVoidReturn);
           elem.allSupertypes.forEach((InterfaceType type) {
             if (visited.add(type.name)) {
-              _addElementSuggestions(type.accessors, typesOnly, excludeVoidReturn);
-              _addElementSuggestions(type.methods, typesOnly, excludeVoidReturn);
+              _addElementSuggestions(
+                  type.accessors,
+                  typesOnly,
+                  excludeVoidReturn);
+              _addElementSuggestions(
+                  type.methods,
+                  typesOnly,
+                  excludeVoidReturn);
             }
           });
         }
       }
     }
 
     // Add non-imported elements as low relevance
     var future = request.searchEngine.searchTopLevelDeclarations('');
     return future.then((List<SearchMatch> matches) {
       Set<String> completionSet = new Set<String>();
       request.suggestions.forEach((CompletionSuggestion suggestion) {
         completionSet.add(suggestion.completion);
       });
       matches.forEach((SearchMatch match) {
         if (match.kind == MatchKind.DECLARATION) {
           Element element = match.element;
           if (element.isPublic &&
               !excludedLibs.contains(element.library) &&
               !completionSet.contains(element.displayName)) {
             if (!typesOnly || element is ClassElement) {
-              _addElementSuggestion(element, typesOnly, excludeVoidReturn, CompletionRelevance.LOW);
+              _addElementSuggestion(
+                  element,
+                  typesOnly,
+                  excludeVoidReturn,
+                  CompletionRelevance.LOW);
             }
           }
         }
       });
       return true;
     });
   }
 
   void _addLibraryPrefixSuggestion(ImportElement importElem) {
     String completion = importElem.prefix.displayName;
     if (completion != null && completion.length > 0) {
       CompletionSuggestion suggestion = new CompletionSuggestion(
           CompletionSuggestionKind.LIBRARY_PREFIX,
           CompletionRelevance.DEFAULT,
           completion,
           completion.length,
           0,
           importElem.isDeprecated,
           false);
       LibraryElement lib = importElem.importedLibrary;
       if (lib != null) {
         suggestion.element = newElement_fromEngine(lib);
       }
       request.suggestions.add(suggestion);
     }
   }
 }