include lower relevance suggestions only if they are already cached

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 'dart:collection';
 
 import 'package:analysis_server/src/protocol_server.dart' hide Element,
     ElementKind;
 import 'package:analysis_server/src/services/completion/dart_completion_cache.dart';
 import 'package:analysis_server/src/services/completion/dart_completion_manager.dart';
 import 'package:analysis_server/src/services/completion/suggestion_builder.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 
 /**
  * A computer for calculating imported class and top level variable
  * `completion.getSuggestions` request results.
  */
 class ImportedComputer extends DartCompletionComputer {
+  final bool shouldWaitForLowPrioritySuggestions;
   _ImportedSuggestionBuilder builder;
 
+  ImportedComputer({this.shouldWaitForLowPrioritySuggestions: false});
+
   @override
   bool computeFast(DartCompletionRequest request) {
     builder = request.node.accept(new _ImportedAstVisitor(request));
     if (builder != null) {
+      builder.shouldWaitForLowPrioritySuggestions = shouldWaitForLowPrioritySuggestions;
       return builder.computeFast(request.node);
     }
     return true;
   }
 
   @override
   Future<bool> computeFull(DartCompletionRequest request) {
     if (builder != null) {
       return builder.computeFull(request.node);
     }
@@ skipping 164 matching lines @@
     }
     return null;
   }
 }
 
 /**
  * [_ImportedSuggestionBuilder] traverses the imports and builds suggestions
  * based upon imported elements.
  */
 class _ImportedSuggestionBuilder implements SuggestionBuilder {
+  bool shouldWaitForLowPrioritySuggestions;
   final DartCompletionRequest request;
   final bool typesOnly;
   final bool excludeVoidReturn;
   DartCompletionCache cache;
 
   _ImportedSuggestionBuilder(this.request, {this.typesOnly: false,
       this.excludeVoidReturn: false}) {
     cache = request.cache;
   }
 
   /**
    * If the needed information is cached, then add suggestions and return `true`
    * else return `false` indicating that additional work is necessary.
    */
   bool computeFast(AstNode node) {
     CompilationUnit unit = request.unit;
     if (cache.isImportInfoCached(unit)) {
       _addInheritedSuggestions(node);
       _addTopLevelSuggestions();
       return true;
     }
     return false;
   }
 
   /**
    * Compute suggested based upon imported elements.
    */
   Future<bool> computeFull(AstNode node) {
-    return cache.computeImportInfo(
-        request.unit,
-        request.searchEngine).then((_) {
+
+    Future<bool> addSuggestions(_) {
       _addInheritedSuggestions(node);
       _addTopLevelSuggestions();
-      return true;
-    });
+      return new Future.value(true);
+    }
+
+    Future future = cache.computeImportInfo(request.unit, request.searchEngine);
+    if (shouldWaitForLowPrioritySuggestions) {
+      return future.then(addSuggestions);
+    } else {
+      return addSuggestions(true);
+    }
   }
 
   /**
    * Add imported element suggestions.
    */
   void _addElementSuggestions(List<Element> elements) {
     elements.forEach((Element elem) {
       if (elem is! ClassElement) {
         if (typesOnly) {
           return;
@@ skipping 53 matching lines @@
         ..addAll(cache.importedTypeSuggestions)
         ..addAll(cache.libraryPrefixSuggestions);
     if (!typesOnly) {
       request.suggestions.addAll(cache.otherImportedSuggestions);
       if (!excludeVoidReturn) {
         request.suggestions.addAll(cache.importedVoidReturnSuggestions);
       }
     }
   }
 }