add arguments to constructor completions

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'
@@ skipping 11 matching lines @@
  */
 class ImportedComputer extends DartCompletionComputer {
   bool shouldWaitForLowPrioritySuggestions;
   _ImportedSuggestionBuilder builder;
 
   ImportedComputer({this.shouldWaitForLowPrioritySuggestions: false});
 
   @override
   bool computeFast(DartCompletionRequest request) {
     OpType optype = request.optype;
-    if (optype.includeTopLevelSuggestions) {
+    if (optype.includeTopLevelSuggestions ||
+        optype.includeConstructorSuggestions) {
       builder = new _ImportedSuggestionBuilder(request,
           typesOnly: optype.includeOnlyTypeNameSuggestions,
-          excludeVoidReturn: !optype.includeVoidReturnSuggestions);
+          excludeVoidReturn: !optype.includeVoidReturnSuggestions,
+          constructorsOnly: optype.includeConstructorSuggestions);
       builder.shouldWaitForLowPrioritySuggestions =
           shouldWaitForLowPrioritySuggestions;
       return builder.computeFast(request.node);
     }
     return true;
   }
 
   @override
   Future<bool> computeFull(DartCompletionRequest request) {
     if (builder != null) {
       return builder.computeFull(request.node);
     }
     return new Future.value(false);
   }
 }
 
 /**
  * [_ImportedSuggestionBuilder] traverses the imports and builds suggestions
  * based upon imported elements.
  */
 class _ImportedSuggestionBuilder extends ElementSuggestionBuilder
     implements SuggestionBuilder {
   bool shouldWaitForLowPrioritySuggestions;
   final DartCompletionRequest request;
   final bool typesOnly;
   final bool excludeVoidReturn;
+  final bool constructorsOnly;
   DartCompletionCache cache;
 
-  _ImportedSuggestionBuilder(this.request,
-      {this.typesOnly: false, this.excludeVoidReturn: false}) {
+  _ImportedSuggestionBuilder(this.request, {this.typesOnly: false,
+      this.excludeVoidReturn: false, this.constructorsOnly: false}) {
     cache = request.cache;
   }
 
   @override
   CompletionSuggestionKind get kind => CompletionSuggestionKind.INVOCATION;
 
   /**
    * 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();
+      _addSuggestions(node);
       return true;
     }
     return false;
   }
 
   /**
    * Compute suggested based upon imported elements.
    */
   Future<bool> computeFull(AstNode node) {
     Future<bool> addSuggestions(_) {
-      _addInheritedSuggestions(node);
-      _addTopLevelSuggestions();
+      _addSuggestions(node);
       return new Future.value(true);
     }
 
     Future future = null;
     if (!cache.isImportInfoCached(request.unit)) {
       future = cache.computeImportInfo(request.unit, request.searchEngine,
           shouldWaitForLowPrioritySuggestions);
     }
     if (future != null) {
       return future.then(addSuggestions);
     }
     return addSuggestions(true);
   }
 
   /**
+   * Add constructor suggestions from the cache.
+   * To reduce the number of suggestions sent to the client,
+   * filter the suggestions based upon the first character typed.
+   * If no characters are available to use for filtering,
+   * then exclude all low priority suggestions.
+   */
+  void _addConstructorSuggestions() {
+    String filterText = request.filterText;
+    if (filterText.length > 1) {
+      filterText = filterText.substring(0, 1);
+    }
+    DartCompletionCache cache = request.cache;
+    _addFilteredSuggestions(filterText, cache.importedConstructorSuggestions);
+  }
+
+  /**
    * Add imported element suggestions.
    */
   void _addElementSuggestions(List<Element> elements,
       {int relevance: DART_RELEVANCE_DEFAULT}) {
     elements.forEach((Element elem) {
       if (elem is! ClassElement) {
         if (typesOnly) {
           return;
         }
         if (elem is ExecutableElement) {
           DartType returnType = elem.returnType;
           if (returnType != null && returnType.isVoid) {
             if (excludeVoidReturn) {
               return;
             }
           }
         }
       }
       addSuggestion(elem, relevance: relevance);
     });
   }
 
   /**
+   * Add suggestions which start with the given text.
+   */
+  _addFilteredSuggestions(
+      String filterText, List<CompletionSuggestion> unfiltered) {
+    //TODO (danrubel) Revisit this filtering once paged API has been added
+    unfiltered.forEach((CompletionSuggestion suggestion) {
+      if (filterText.length > 0) {
+        if (suggestion.completion.startsWith(filterText)) {
+          request.suggestions.add(suggestion);
+        }
+      } else {
+        if (suggestion.relevance != DART_RELEVANCE_LOW) {
+          request.suggestions.add(suggestion);
+        }
+      }
+    });
+  }
+
+  /**
    * Add suggestions for any inherited imported members.
    */
   void _addInheritedSuggestions(AstNode node) {
     var classDecl = node.getAncestor((p) => p is ClassDeclaration);
     if (classDecl is ClassDeclaration) {
       // Build a list of inherited types that are imported
       // and include any inherited imported members
       List<String> inheritedTypes = new List<String>();
       visitInheritedTypes(classDecl, (_) {
         // local declarations are handled by the local computer
@@ skipping 20 matching lines @@
               _addElementSuggestions(type.element.methods,
                   relevance: DART_RELEVANCE_INHERITED_METHOD);
             }
           });
         }
       }
     }
   }
 
   /**
+   * Add suggested based upon imported elements.
+   */
+  void _addSuggestions(AstNode node) {
+    if (constructorsOnly) {
+      _addConstructorSuggestions();
+    } else {
+      _addInheritedSuggestions(node);
+      _addTopLevelSuggestions();
+    }
+  }
+
+  /**
    * Add top level suggestions from the cache.
    * To reduce the number of suggestions sent to the client,
    * filter the suggestions based upon the first character typed.
    * If no characters are available to use for filtering,
    * then exclude all low priority suggestions.
    */
   void _addTopLevelSuggestions() {
     String filterText = request.filterText;
     if (filterText.length > 1) {
       filterText = filterText.substring(0, 1);
     }
-
-    //TODO (danrubel) Revisit this filtering once paged API has been added
-    addFilteredSuggestions(List<CompletionSuggestion> unfiltered) {
-      unfiltered.forEach((CompletionSuggestion suggestion) {
-        if (filterText.length > 0) {
-          if (suggestion.completion.startsWith(filterText)) {
-            request.suggestions.add(suggestion);
-          }
-        } else {
-          if (suggestion.relevance != DART_RELEVANCE_LOW) {
-            request.suggestions.add(suggestion);
-          }
-        }
-      });
-    }
-
     DartCompletionCache cache = request.cache;
-    addFilteredSuggestions(cache.importedTypeSuggestions);
-    addFilteredSuggestions(cache.libraryPrefixSuggestions);
+    _addFilteredSuggestions(filterText, cache.importedTypeSuggestions);
+    _addFilteredSuggestions(filterText, cache.libraryPrefixSuggestions);
     if (!typesOnly) {
-      addFilteredSuggestions(cache.otherImportedSuggestions);
+      _addFilteredSuggestions(filterText, cache.otherImportedSuggestions);
       if (!excludeVoidReturn) {
-        addFilteredSuggestions(cache.importedVoidReturnSuggestions);
+        _addFilteredSuggestions(
+            filterText, cache.importedVoidReturnSuggestions);
       }
     }
   }
 }