add arguments to constructor completions

pkg/analysis_server/lib/src/services/completion/dart_completion_cache.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.dart.cache;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analysis_server/src/protocol_server.dart'
@@ skipping 38 matching lines @@
    */
   List<CompletionSuggestion> importedVoidReturnSuggestions;
 
   /**
    * Other suggestions based upon imports,
    * or `null` if nothing has been cached.
    */
   List<CompletionSuggestion> otherImportedSuggestions;
 
   /**
+   * Suggestions for constructors
+   * or `null` if nothing has been cached.
+   */
+  List<CompletionSuggestion> importedConstructorSuggestions;
+
+  /**
    * A collection of all imported completions
    * or `null` if nothing has been cached.
    */
   HashSet<String> _importedCompletions;
 
   /**
    * A map of simple identifier to imported class element
    * or `null` if nothing has been cached.
    */
   Map<String, ClassElement> importedClassMap;
@@ skipping 35 matching lines @@
    * the returned future will complete sooner, but the cache will not include
    * the lower priority suggestions added as a result of a global search.
    * In this case, those lower priority suggestions will be added later
    * when the index has been updated and the global search completes.
    */
   Future<bool> computeImportInfo(CompilationUnit unit,
       SearchEngine searchEngine, bool shouldWaitForLowPrioritySuggestions) {
     importedTypeSuggestions = <CompletionSuggestion>[];
     libraryPrefixSuggestions = <CompletionSuggestion>[];
     otherImportedSuggestions = <CompletionSuggestion>[];
+    importedConstructorSuggestions = <CompletionSuggestion>[];
     importedVoidReturnSuggestions = <CompletionSuggestion>[];
     importedClassMap = new Map<String, ClassElement>();
     _importedCompletions = new HashSet<String>();
 
     // Assert that the compilation unit is resolved
     // and represents the expected source
     assert(unit.element.source == source);
 
     // Exclude elements from local library
     // because they are provided by LocalComputer
@@ skipping 37 matching lines @@
   }
 
   /**
    * Return `true` if the import information is cached for the given
    * compilation unit.
    */
   bool isImportInfoCached(CompilationUnit unit) =>
       _importKey != null && _importKey == _computeImportKey(unit);
 
   /**
+   * Add constructor suggestions for the given class.
+   */
+  void _addConstructorSuggestions(ClassElement classElem, int relevance) {
+    String className = classElem.name;
+    for (ConstructorElement constructor in classElem.constructors) {
+      if (!constructor.isPrivate) {
+        CompletionSuggestion suggestion =
+            createSuggestion(constructor, relevance: relevance);
+        String name = suggestion.completion;
+        name = name.length > 0 ? '$className.$name' : className;
+        suggestion.completion = name;
+        suggestion.element.name = name;
+        suggestion.selectionOffset = suggestion.completion.length;
+        importedConstructorSuggestions.add(suggestion);
+      }
+    }
+  }
+
+  /**
    * Add suggestions for implicitly imported elements in dart:core.
    */
   void _addDartCoreSuggestions() {
     Source coreUri = context.sourceFactory.forUri('dart:core');
     LibraryElement coreLib = context.getLibraryElement(coreUri);
     Namespace coreNamespace =
         new NamespaceBuilder().createPublicNamespaceForLibrary(coreLib);
     coreNamespace.definedNames.forEach((String name, Element elem) {
       if (elem is ClassElement) {
         importedClassMap[name] = elem;
@@ skipping 94 matching lines @@
 
     if (element is ExecutableElement) {
       DartType returnType = element.returnType;
       if (returnType != null && returnType.isVoid) {
         importedVoidReturnSuggestions.add(suggestion);
       } else {
         otherImportedSuggestions.add(suggestion);
       }
     } else if (element is ClassElement) {
       importedTypeSuggestions.add(suggestion);
+      _addConstructorSuggestions(element, relevance);
     } else {
       otherImportedSuggestions.add(suggestion);
     }
     _importedCompletions.add(suggestion.completion);
   }
 
   /**
    * Compute the hash of the imports for the given compilation unit.
    */
   String _computeImportKey(CompilationUnit unit) {
@@ skipping 55 matching lines @@
   @override
   void visitFunctionTypeAliasElement(FunctionTypeAliasElement element) {
     cache._addSuggestion(element, DART_RELEVANCE_DEFAULT);
   }
 
   @override
   void visitTopLevelVariableElement(TopLevelVariableElement element) {
     cache._addSuggestion(element, DART_RELEVANCE_DEFAULT);
   }
 }