cache suggestions on change in priority sources

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;
+  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;
+      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 200 matching lines @@
    * Compute suggested based upon imported elements.
    */
   Future<bool> computeFull(AstNode node) {
 
     Future<bool> addSuggestions(_) {
       _addInheritedSuggestions(node);
       _addTopLevelSuggestions();
       return new Future.value(true);
     }
 
-    Future future = cache.computeImportInfo(request.unit, request.searchEngine);
-    if (shouldWaitForLowPrioritySuggestions) {
+    Future future = null;
+    if (!cache.isImportInfoCached(request.unit)) {
+      future = cache.computeImportInfo(request.unit, request.searchEngine);
+    }
+    if (future != null && shouldWaitForLowPrioritySuggestions) {
       return future.then(addSuggestions);
-    } else {
-      return addSuggestions(true);
     }
+    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);
       }
     }
   }
 }