add arguments to constructor completions

pkg/analysis_server/test/services/completion/completion_test_util.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 test.services.completion.util;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/protocol.dart' as protocol
     show Element, ElementKind;
@@ skipping 183 matching lines @@
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.CLASS_TYPE_ALIAS));
     expect(element.name, equals(name));
     expect(element.parameters, isNull);
     expect(element.returnType, isNull);
     assertHasNoParameterInfo(cs);
     return cs;
   }
 
+  CompletionSuggestion assertSuggestConstructor(String name) {
+    CompletionSuggestion cs = assertSuggest(name);
+    protocol.Element element = cs.element;
+    expect(element, isNotNull);
+    expect(element.kind, equals(protocol.ElementKind.CONSTRUCTOR));
+    expect(element.name, name);
+    return cs;
+  }
+
   CompletionSuggestion assertSuggestField(String name, String type,
       {int relevance: DART_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION,
       bool isDeprecated: false}) {
     CompletionSuggestion cs = assertSuggest(name,
         csKind: kind,
         relevance: relevance,
         elemKind: protocol.ElementKind.FIELD,
         isDeprecated: isDeprecated);
     // The returnType represents the type of a field
@@ skipping 347 matching lines @@
   CompletionSuggestion assertSuggestImportedClass(String name,
       [int relevance = DART_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     if (computer is ImportedComputer) {
       return assertSuggestClass(name, relevance: relevance, kind: kind);
     } else {
       return assertNotSuggested(name);
     }
   }
 
+  CompletionSuggestion assertSuggestImportedConstructor(String name) {
+    return assertNotSuggested(name);
+  }
+
   CompletionSuggestion assertSuggestImportedField(String name, String type,
       {int relevance: DART_RELEVANCE_INHERITED_FIELD}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestImportedFunction(
       String name, String returnType, [bool isDeprecated = false,
       int relevance = DART_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     if (computer is ImportedComputer) {
@@ skipping 101 matching lines @@
   CompletionSuggestion assertSuggestLocalClass(String name,
       {int relevance: DART_RELEVANCE_DEFAULT, bool isDeprecated: false}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestLocalClassTypeAlias(String name,
       {int relevance: DART_RELEVANCE_DEFAULT}) {
     return assertNotSuggested(name);
   }
 
+  CompletionSuggestion assertSuggestLocalConstructor(String name) {
+    return assertNotSuggested(name);
+  }
+
   CompletionSuggestion assertSuggestLocalField(String name, String type,
       {int relevance: DART_RELEVANCE_LOCAL_FIELD, bool deprecated: false}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestLocalFunction(
       String name, String returnType,
       {bool deprecated: false, int relevance: DART_RELEVANCE_LOCAL_FUNCTION}) {
     return assertNotSuggested(name);
   }
@@ skipping 1403 matching lines @@
       // TODO (danrubel) getter is being suggested instead of top level var
       //assertSuggestImportedTopLevelVar('T1', 'int');
     });
   }
 
   test_InstanceCreationExpression_imported() {
     // SimpleIdentifier  TypeName  ConstructorName  InstanceCreationExpression
     addSource('/testA.dart', '''
       int T1;
       F1() { }
-      class A {int x;}''');
+      class A {A(this.x) { } int x;}''');
     addTestSource('''
       import "/testA.dart";
       int T2;
       F2() { }
-      class B {int x;}
+      class B {B(this.x, [String boo]) { } int x;}
       class C {foo(){var f; {var x;} new ^}}''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
-      assertSuggestImportedClass('Object');
-      assertSuggestImportedClass('A');
-      assertSuggestLocalClass('B');
-      assertSuggestLocalClass('C');
+      assertSuggestImportedConstructor('Object');
+      assertSuggestImportedConstructor('A');
+      assertSuggestLocalConstructor('B');
+      assertSuggestLocalConstructor('C');
       assertNotSuggested('f');
       assertNotSuggested('x');
       assertNotSuggested('foo');
       assertNotSuggested('F1');
       assertNotSuggested('F2');
       assertNotSuggested('T1');
       assertNotSuggested('T2');
     });
   }
 
@@ skipping 337 matching lines @@
       F1() { }
       class X {X.c(); X._d(); z() {}}''');
     addSource('/testA.dart', '''
       library libA;
       import "/testB.dart";
       part "$testFile";
       class A { }
       var m;''');
     addTestSource('''
       part of libA;
-      class B { }
+      class B { factory B.bar(int x) => null; }
       main() {new ^}''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
-      assertSuggestLocalClass('B');
-      assertSuggestImportedClass('Object');
-      assertSuggestImportedClass('X');
-      assertSuggestNonLocalClass('A');
+      assertSuggestLocalConstructor('B.bar');
+      assertSuggestImportedConstructor('Object');
+      assertSuggestImportedConstructor('X.c');
+      assertNotSuggested('X._d');
+      assertSuggestImportedConstructor('A');
       assertNotSuggested('F1');
       assertNotSuggested('T1');
       assertNotSuggested('_d');
       assertNotSuggested('z');
       assertNotSuggested('m');
     });
   }
 
   test_partFile_TypeName2() {
     // SimpleIdentifier  TypeName  ConstructorName
     addSource('/testB.dart', '''
       lib B;
       int T1;
       F1() { }
       class X {X.c(); X._d(); z() {}}''');
     addSource('/testA.dart', '''
       part of libA;
       class B { }''');
     addTestSource('''
       library libA;
       import "/testB.dart";
       part "/testA.dart";
-      class A { }
+      class A { A({String boo: 'hoo'}) { } }
       main() {new ^}
       var m;''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
-      assertSuggestLocalClass('A');
-      assertSuggestImportedClass('Object');
-      assertSuggestImportedClass('X');
-      assertSuggestNonLocalClass('B');
+      assertSuggestLocalConstructor('A');
+      assertSuggestImportedConstructor('Object');
+      assertSuggestImportedConstructor('X.c');
+      assertNotSuggested('X._d');
+      assertSuggestImportedConstructor('B');
       assertNotSuggested('F1');
       assertNotSuggested('T1');
       assertNotSuggested('_d');
       assertNotSuggested('z');
       assertNotSuggested('m');
     });
   }
 
   test_PrefixedIdentifier_class_const() {
     // SimpleIdentifier PrefixedIdentifier ExpressionStatement Block
@@ skipping 508 matching lines @@
       assertNotSuggested('bar2');
       assertNotSuggested('_B');
       assertSuggestLocalClass('Y');
       assertSuggestLocalClass('C');
       assertSuggestLocalVariable('f', null);
       assertNotSuggested('x');
       assertNotSuggested('e');
     });
   }
 }