include unimported sdk lib types as low priority suggestions

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);
+  CompletionSuggestion assertSuggestConstructor(String name,
+      {int relevance: DART_RELEVANCE_DEFAULT}) {
+    CompletionSuggestion cs = assertSuggest(name, relevance: relevance);
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.CONSTRUCTOR));
     int index = name.indexOf('.');
     expect(element.name, index >= 0 ? name.substring(index + 1) : '');
     return cs;
   }
 
   CompletionSuggestion assertSuggestField(String name, String type,
       {int relevance: DART_RELEVANCE_DEFAULT,
@@ skipping 347 matching lines @@
   CompletionSuggestion assertSuggestImportedClass(String name,
       {CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION,
       int relevance: DART_RELEVANCE_DEFAULT}) {
     if (computer is ImportedComputer) {
       return assertSuggestClass(name, relevance: relevance, kind: kind);
     } else {
       return assertNotSuggested(name);
     }
   }
 
-  CompletionSuggestion assertSuggestImportedConstructor(String name) {
+  CompletionSuggestion assertSuggestImportedConstructor(String name,
+      {int relevance: DART_RELEVANCE_DEFAULT}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestImportedField(String name, String type,
       {int relevance: DART_RELEVANCE_INHERITED_FIELD}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestImportedFunction(
       String name, String returnType,
@@ skipping 235 matching lines @@
       import 'dart:async';
       import '/libA.dart';
       class B { }
       String bar() => true;
       void main() {new A(^)}''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
-      assertSuggestLocalFunction(
-          'bar', 'String', kind: CompletionSuggestionKind.IDENTIFIER);
+      assertSuggestLocalFunction('bar', 'String',
+          kind: CompletionSuggestionKind.IDENTIFIER);
       assertSuggestImportedFunction('hasLength', 'bool',
           kind: CompletionSuggestionKind.IDENTIFIER);
       assertSuggestImportedFunction('identical', 'bool',
           kind: CompletionSuggestionKind.IDENTIFIER);
       assertSuggestLocalClass('B', kind: CompletionSuggestionKind.IDENTIFIER);
       assertSuggestImportedClass('A',
           kind: CompletionSuggestionKind.IDENTIFIER);
       assertSuggestImportedClass('Object',
           kind: CompletionSuggestionKind.IDENTIFIER);
       assertNotSuggested('main');
@@ skipping 14 matching lines @@
       import 'dart:async';
       import '/libA.dart';
       class B { }
       String bar() => true;
       void main() {new A(^)}''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
-      assertSuggestLocalFunction(
-          'bar', 'String', kind: CompletionSuggestionKind.IDENTIFIER);
+      assertSuggestLocalFunction('bar', 'String',
+          kind: CompletionSuggestionKind.IDENTIFIER);
       assertSuggestImportedFunction('hasLength', 'bool',
           kind: CompletionSuggestionKind.IDENTIFIER);
       assertSuggestImportedFunction('identical', 'bool',
           kind: CompletionSuggestionKind.IDENTIFIER);
       assertSuggestLocalClass('B', kind: CompletionSuggestionKind.IDENTIFIER);
       assertSuggestImportedClass('A',
           kind: CompletionSuggestionKind.IDENTIFIER);
       assertSuggestImportedClass('Object',
           kind: CompletionSuggestionKind.IDENTIFIER);
       assertNotSuggested('main');
@@ skipping 69 matching lines @@
       import 'dart:async';
       import '/libA.dart';
       class B { }
       String bar(f()) => true;
       void main() {bar(^);}''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
-      assertSuggestLocalFunction(
-          'bar', 'String', kind: CompletionSuggestionKind.IDENTIFIER);
+      assertSuggestLocalFunction('bar', 'String',
+          kind: CompletionSuggestionKind.IDENTIFIER);
       assertSuggestImportedFunction('hasLength', 'bool',
           kind: CompletionSuggestionKind.IDENTIFIER);
       assertSuggestImportedFunction('identical', 'bool',
           kind: CompletionSuggestionKind.IDENTIFIER);
       assertSuggestLocalClass('B', kind: CompletionSuggestionKind.IDENTIFIER);
       assertSuggestImportedClass('A',
           kind: CompletionSuggestionKind.IDENTIFIER);
       assertSuggestImportedClass('Object',
           kind: CompletionSuggestionKind.IDENTIFIER);
       assertNotSuggested('main');
@@ skipping 12 matching lines @@
     addTestSource('''
       import 'dart:async';
       import '/libA.dart';
       class B { String bar(f()) => true; }
       void main() {new B().bar(^);}''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
-      assertSuggestImportedFunction(
-          'hasLength', 'bool', kind: CompletionSuggestionKind.IDENTIFIER);
+      assertSuggestImportedFunction('hasLength', 'bool',
+          kind: CompletionSuggestionKind.IDENTIFIER);
       assertSuggestImportedFunction('identical', 'bool',
           kind: CompletionSuggestionKind.IDENTIFIER);
       assertSuggestLocalClass('B', kind: CompletionSuggestionKind.IDENTIFIER);
       assertSuggestImportedClass('A',
           kind: CompletionSuggestionKind.IDENTIFIER);
       assertSuggestImportedClass('Object',
           kind: CompletionSuggestionKind.IDENTIFIER);
       assertNotSuggested('main');
       assertNotSuggested('baz');
       assertNotSuggested('print');
@@ skipping 307 matching lines @@
       String T1;
       var _T2;
       class C { }
       class D { }''');
     addSource('/testEEF.dart', '''
       class EE { }
       class F { }''');
     addSource('/testG.dart', 'class G { }');
     addSource('/testH.dart', '''
       class H { }
+      class D3 { }
       int T3;
       var _T4;'''); // not imported
     addTestSource('''
       import "/testAB.dart";
       import "/testCD.dart" hide D;
       import "/testEEF.dart" show EE;
       import "/testG.dart" as g;
       int T5;
       var _T6;
       Z D2() {int x;}
@@ skipping 12 matching lines @@
       // Don't suggest locals out of scope
       assertNotSuggested('r');
       assertNotSuggested('x');
 
       // imported elements are portially filtered
       //assertSuggestImportedClass('A');
       assertNotSuggested('_B');
       //assertSuggestImportedClass('C');
       // hidden element suggested as low relevance
       assertSuggestImportedClass('D', relevance: DART_RELEVANCE_LOW);
-      assertSuggestImportedFunction(
-          'D1', null, deprecated: true, relevance: DART_RELEVANCE_LOW);
+      assertSuggestImportedFunction('D1', null,
+          deprecated: true, relevance: DART_RELEVANCE_LOW);
       assertSuggestLocalFunction('D2', 'Z');
+      // unimported elements suggested with low relevance
+      assertSuggestImportedClass('D3', relevance: DART_RELEVANCE_LOW);
       //assertSuggestImportedClass('EE');
       // hidden element suggested as low relevance
       //assertSuggestImportedClass('F', COMPLETION_RELEVANCE_LOW);
       //assertSuggestLibraryPrefix('g');
       assertNotSuggested('G');
       //assertSuggestImportedClass('H', COMPLETION_RELEVANCE_LOW);
       //assertSuggestImportedClass('Object');
       //assertSuggestImportedFunction('min', 'num', false);
       //assertSuggestImportedFunction(
       //    'max',
@@ skipping 62 matching lines @@
       assertSuggestLocalField('m1', null);
       assertSuggestLocalGetter('f3', null);
       assertSuggestLocalSetter('f4');
       assertSuggestLocalMethod('e2', 'E', null);
       assertSuggestLocalMethod('f2', 'F', null);
       assertSuggestLocalMethod('i2', 'I', null);
       assertSuggestLocalMethod('m2', 'M', 'int');
     });
   }
 
+  test_Block_unimported() {
+    addSource('/testAB.dart', 'class Foo { }');
+    addTestSource('class C {foo(){F^}}');
+    computeFast();
+    return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset - 1);
+      expect(request.replacementLength, 1);
+      assertSuggestImportedClass('Foo', relevance: DART_RELEVANCE_LOW);
+      assertSuggestImportedClass('Future', relevance: DART_RELEVANCE_LOW);
+    });
+  }
+
   test_CascadeExpression_selector1() {
     // PropertyAccess  CascadeExpression  ExpressionStatement  Block
     addSource('/testB.dart', '''
       class B { }''');
     addTestSource('''
       import "/testB.dart";
       class A {var b; X _c;}
       class X{}
       // looks like a cascade to the parser
       // but the user is trying to get completions for a non-cascade
@@ skipping 905 matching lines @@
   }
 
   test_InstanceCreationExpression_imported() {
     // SimpleIdentifier  TypeName  ConstructorName  InstanceCreationExpression
     addSource('/testA.dart', '''
       int T1;
       F1() { }
       class A {A(this.x) { } int x;}''');
     addTestSource('''
       import "/testA.dart";
+      import "dart:async";
       int T2;
       F2() { }
       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);
       assertSuggestImportedConstructor('Object');
+      assertSuggestImportedConstructor('Future');
       assertSuggestImportedConstructor('A');
       assertSuggestLocalConstructor('B');
       assertSuggestLocalConstructor('C');
       assertNotSuggested('f');
       assertNotSuggested('x');
       assertNotSuggested('foo');
       assertNotSuggested('F1');
       assertNotSuggested('F2');
       assertNotSuggested('T1');
       assertNotSuggested('T2');
     });
   }
 
+  test_InstanceCreationExpression_unimported() {
+    // SimpleIdentifier  TypeName  ConstructorName  InstanceCreationExpression
+    addSource('/testAB.dart', 'class Foo { }');
+    addTestSource('class C {foo(){new F^}}');
+    computeFast();
+    return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset - 1);
+      expect(request.replacementLength, 1);
+      assertSuggestImportedConstructor('Foo', relevance: DART_RELEVANCE_LOW);
+      assertSuggestImportedConstructor('Future', relevance: DART_RELEVANCE_LOW);
+    });
+  }
+
   test_InterpolationExpression() {
     // SimpleIdentifier  InterpolationExpression  StringInterpolation
     addSource('/testA.dart', '''
       int T1;
       F1() { }
       typedef D1();
       class C1 {C1(this.x) { } int x;}''');
     addTestSource('''
       import "/testA.dart";
       int T2;
@@ skipping 1230 matching lines @@
       assertNotSuggested('bar2');
       assertNotSuggested('_B');
       assertSuggestLocalClass('Y');
       assertSuggestLocalClass('C');
       assertSuggestLocalVariable('f', null);
       assertNotSuggested('x');
       assertNotSuggested('e');
     });
   }
 }