only wait for analysis if necessary when computing invocation suggestions

pkg/analysis_server/lib/src/services/completion/suggestion_builder.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.suggestion.builder;
 
+import 'dart:async';
+
 import 'package:analysis_server/src/protocol_server.dart' as protocol;
 import 'package:analysis_server/src/protocol_server.dart' hide Element,
     ElementKind;
 import 'package:analysis_server/src/services/completion/dart_completion_manager.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 
 /**
  * Call the given function with each non-null non-empty inherited type name
  * that is defined in the given class.
@@ skipping 195 matching lines @@
   static void suggestionsFor(DartCompletionRequest request,
       CompletionSuggestionKind kind, LibraryElement library) {
     if (library != null) {
       library.visitChildren(new LibraryElementSuggestionBuilder(request, kind));
     }
   }
 }
 
 /**
  * This class visits elements in a class and provides suggestions based upon
- * the visible named constructors in that class. Clients should call
- * [NamedConstructorSuggestionBuilder.suggestionsFor].
+ * the visible named constructors in that class.
  */
-class NamedConstructorSuggestionBuilder extends _AbstractSuggestionBuilder {
+class NamedConstructorSuggestionBuilder extends _AbstractSuggestionBuilder
+    implements SuggestionBuilder {
 
   NamedConstructorSuggestionBuilder(DartCompletionRequest request)
       : super(request, CompletionSuggestionKind.INVOCATION);
 
   @override
+  bool computeFast(AstNode node) {
+    return false;
+  }
+
+  @override
+  Future<bool> computeFull(AstNode node) {
+    if (node is SimpleIdentifier) {
+      node = node.parent;
+    }
+    if (node is ConstructorName) {
+      TypeName typeName = node.type;
+      if (typeName != null) {
+        DartType type = typeName.type;
+        if (type != null) {
+          if (type.element is ClassElement) {
+            type.element.accept(this);
+          }
+          return new Future.value(true);
+        }
+      }
+    }
+    return new Future.value(false);
+  }
+
+  @override
   visitClassElement(ClassElement element) {
     element.visitChildren(this);
   }
 
   @override
   visitConstructorElement(ConstructorElement element) {
     _addElementSuggestion(
         element,
         element.returnType,
         element.enclosingElement);
   }
 
   @override
   visitElement(Element element) {
     // ignored
   }
-
-  /**
-   * Add suggestions for the visible members in the given class
-   */
-  static void suggestionsFor(DartCompletionRequest request, Element element) {
-    if (element is ClassElement) {
-      element.accept(new NamedConstructorSuggestionBuilder(request));
-    }
-  }
 }
 
 /**
+ * Common interface implemented by suggestion builders.
+ */
+abstract class SuggestionBuilder {
+  /**
+   * Compute suggestions and return `true` if building is complete,
+   * or `false` if [computeFull] should be called.
+   */
+  bool computeFast(AstNode node);
+
+  /**
+   * Return a future that computes the suggestions given a fully resolved AST.
+   * The future returns `true` if suggestions were added, else `false`.
+   */
+  Future<bool> computeFull(AstNode node);
+}
+
+/**
  * Common superclass for sharing behavior
  */
 class _AbstractSuggestionBuilder extends GeneralizingElementVisitor {
   final DartCompletionRequest request;
   final CompletionSuggestionKind kind;
   final Set<String> _completions = new Set<String>();
 
   _AbstractSuggestionBuilder(this.request, this.kind);
 
   void _addElementSuggestion(Element element, DartType type,
@@ skipping 36 matching lines @@
     }
     if (type != null) {
       String typeName = type.displayName;
       if (typeName != null && typeName.length > 0 && typeName != 'dynamic') {
         suggestion.returnType = typeName;
       }
     }
     request.suggestions.add(suggestion);
   }
 }