improve import suggestion

pkg/analysis_server/lib/src/services/completion/keyword_contributor.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.contributor.dart.keyword;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/protocol.dart';
 import 'package:analysis_server/src/services/completion/dart_completion_manager.dart';
@@ skipping 89 matching lines @@
         // then the user is probably finishing that
         _addImportDirectiveKeywords(previousMember);
         return;
       }
     }
     if (previousMember == null || previousMember is Directive) {
       if (previousMember == null &&
           !node.directives.any((d) => d is LibraryDirective)) {
         _addSuggestions([Keyword.LIBRARY], DART_RELEVANCE_HIGH);
       }
-      _addSuggestions(
-          [Keyword.EXPORT, Keyword.IMPORT, Keyword.PART], DART_RELEVANCE_HIGH);
+      _addSuggestions([Keyword.EXPORT, Keyword.PART], DART_RELEVANCE_HIGH);
+      _addSuggestion2("import '';",
+          offset: 8, relevance: DART_RELEVANCE_HIGH + 1);
+      _addSuggestion2("import '' as ;",
+          offset: 8, relevance: DART_RELEVANCE_HIGH);
+      _addSuggestion2("import '' hide ;",
+          offset: 8, relevance: DART_RELEVANCE_HIGH);
+      _addSuggestion2("import '' show ;",
+          offset: 8, relevance: DART_RELEVANCE_HIGH);
     }
     if (entity == null || entity is Declaration) {
       if (previousMember is FunctionDeclaration &&
           previousMember.functionExpression is FunctionExpression &&
           previousMember.functionExpression.body is EmptyFunctionBody) {
-        _addSuggestion2(ASYNC, DART_RELEVANCE_HIGH);
+        _addSuggestion2(ASYNC, relevance: DART_RELEVANCE_HIGH);
       }
       _addCompilationUnitKeywords();
     }
   }
 
   @override
   visitExpressionFunctionBody(ExpressionFunctionBody node) {
     if (entity == node.expression) {
       _addExpressionKeywords(node);
     }
   }
 
   @override
   visitFormalParameterList(FormalParameterList node) {
     AstNode constructorDecl =
         node.getAncestor((p) => p is ConstructorDeclaration);
     if (constructorDecl != null) {
       _addSuggestions([Keyword.THIS]);
     }
   }
 
   @override
   visitFunctionExpression(FunctionExpression node) {
     if (entity == node.body) {
-      _addSuggestion2(ASYNC, DART_RELEVANCE_HIGH);
+      _addSuggestion2(ASYNC, relevance: DART_RELEVANCE_HIGH);
       if (node.body is EmptyFunctionBody &&
           node.parent is FunctionDeclaration &&
           node.parent.parent is CompilationUnit) {
         _addCompilationUnitKeywords();
       }
     }
   }
 
   @override
   visitIfStatement(IfStatement node) {
@@ skipping 14 matching lines @@
     }
   }
 
   @override
   visitMethodDeclaration(MethodDeclaration node) {
     if (entity == node.body) {
       if (node.body is EmptyFunctionBody) {
         _addClassBodyKeywords();
         _addSuggestion2(ASYNC);
       } else {
-        _addSuggestion2(ASYNC, DART_RELEVANCE_HIGH);
+        _addSuggestion2(ASYNC, relevance: DART_RELEVANCE_HIGH);
       }
     }
   }
 
   @override
   visitNamedExpression(NamedExpression node) {
     if (entity is SimpleIdentifier && entity == node.expression) {
       _addExpressionKeywords(node);
     }
   }
@@ skipping 113 matching lines @@
       Keyword.THROW,
       Keyword.TRY,
       Keyword.VAR,
       Keyword.VOID,
       Keyword.WHILE
     ]);
   }
 
   void _addSuggestion(Keyword keyword,
       [int relevance = DART_RELEVANCE_KEYWORD]) {
-    _addSuggestion2(keyword.syntax, relevance);
+    _addSuggestion2(keyword.syntax, relevance: relevance);
   }
 
   void _addSuggestion2(String completion,
-      [int relevance = DART_RELEVANCE_KEYWORD]) {
+      {int offset, int relevance: DART_RELEVANCE_KEYWORD}) {
+    if (offset == null) {
+      offset = completion.length;
+    }
     request.addSuggestion(new CompletionSuggestion(
-        CompletionSuggestionKind.KEYWORD, relevance, completion,
-        completion.length, 0, false, false));
+        CompletionSuggestionKind.KEYWORD, relevance, completion, offset, 0,
+        false, false));
   }
 
   void _addSuggestions(List<Keyword> keywords,
       [int relevance = DART_RELEVANCE_KEYWORD]) {
     keywords.forEach((Keyword keyword) {
       _addSuggestion(keyword, relevance);
     });
   }
 
   bool _inAsyncMethodOrFunction(AstNode node) {
     FunctionBody body = node.getAncestor((n) => n is FunctionBody);
     return body != null && body.isAsynchronous;
   }
 
   bool _inClassMemberBody(AstNode node) {
     while (true) {
       AstNode body = node.getAncestor((n) => n is FunctionBody);
       if (body == null) {
         return false;
       }
       AstNode parent = body.parent;
       if (parent is ConstructorDeclaration || parent is MethodDeclaration) {
         return true;
       }
       node = parent;
     }
   }
 }