add code completion declared and return types

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.dart' hide Element;
 import 'package:analysis_server/src/services/completion/dart_completion_manager.dart';
@@ skipping 38 matching lines @@
         node.getAncestor((parent) => parent is NamespaceDirective);
     if (directive != null) {
       LibraryElement library = directive.uriElement;
       LibraryElementSuggestionBuilder.suggestionsFor(request, library);
       return new Future.value(true);
     }
     return new Future.value(false);
   }
 
   @override
+  Future<bool> visitExpressionStatement(ExpressionStatement node) {
+    Expression expression = node.expression;
+    if (expression is SimpleIdentifier) {
+      if (expression.end < request.offset) {
+        // Don't suggest imported elements for local var name
+        return new Future.value(false);
+      }
+    }
+    return visitNode(node);
+  }
+
+  @override
   Future<bool> visitNode(AstNode node) {
     return _addImportedElements();
   }
 
   @override
   Future<bool> visitSimpleIdentifier(SimpleIdentifier node) {
     return node.parent.accept(this);
   }
 
   @override
@@ skipping 26 matching lines @@
 
       // Build the set of visible and excluded libraries
       // and the list of names that should be shown or hidden
       request.unit.directives.forEach((Directive directive) {
         if (directive is ImportDirective) {
           LibraryElement lib = directive.element.importedLibrary;
           if (directive.prefix == null) {
             visibleLibs.add(lib);
             directive.combinators.forEach((Combinator combinator) {
               if (combinator is ShowCombinator) {
-                showNames[lib] = combinator.shownNames.map(
-                    (SimpleIdentifier id) => id.name).toSet();
+                showNames[lib] =
+                    combinator.shownNames.map((SimpleIdentifier id) => id.name).toSet();
               } else if (combinator is HideCombinator) {
-                hideNames[lib] = combinator.hiddenNames.map(
-                    (SimpleIdentifier id) => id.name).toSet();
+                hideNames[lib] =
+                    combinator.hiddenNames.map((SimpleIdentifier id) => id.name).toSet();
               }
             });
           } else {
             excludedLibs.add(lib);
           }
         }
       });
 
       // Compute the set of possible classes, functions, and top level variables
       matches.forEach((SearchMatch match) {
         if (match.kind == MatchKind.DECLARATION) {
           Element element = match.element;
           LibraryElement lib = element.library;
           if (element.isPublic && !excludedLibs.contains(lib)) {
             String completion = element.displayName;
             Set<String> show = showNames[lib];
             Set<String> hide = hideNames[lib];
             if ((show == null || show.contains(completion)) &&
                 (hide == null || !hide.contains(completion))) {
-              request.suggestions.add(
-                  new CompletionSuggestion(
-                      new CompletionSuggestionKind.fromElementKind(element.kind),
-                      visibleLibs.contains(lib) || lib.isDartCore ?
-                          CompletionRelevance.DEFAULT :
-                          CompletionRelevance.LOW,
-                      completion,
-                      completion.length,
-                      0,
-                      element.isDeprecated,
-                      false));
+
+              CompletionSuggestionKind kind =
+                  new CompletionSuggestionKind.fromElementKind(element.kind);
+
+              CompletionRelevance relevance;
+              if (visibleLibs.contains(lib) || lib.isDartCore) {
+                relevance = CompletionRelevance.DEFAULT;
+              } else {
+                relevance = CompletionRelevance.LOW;
+              }
+
+              CompletionSuggestion suggestion = new CompletionSuggestion(
+                  kind,
+                  relevance,
+                  completion,
+                  completion.length,
+                  0,
+                  element.isDeprecated,
+                  false);
+
+              DartType type;
+              if (element is TopLevelVariableElement) {
+                type = element.type;
+              } else if (element is FunctionElement) {
+                type = element.returnType;
+              }
+              if (type != null) {
+                String name = type.displayName;
+                if (name != null && name.length > 0 && name != 'dynamic') {
+                  suggestion.returnType = name;
+                }
+              }
+
+              request.suggestions.add(suggestion);
             }
           }
         }
       });
       return true;
     });
   }
 }
-