filter imported element suggestions to reduce number of results sent to client

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 441 matching lines @@
 
       // If the unit has been resolved, then finish the completion
       LibraryElement library = context.getLibraryElement(testSource);
       if (library != null) {
         CompilationUnit unit =
             context.getResolvedCompilationUnit(testSource, library);
         if (unit != null) {
           request.unit = unit;
           request.node =
               new NodeLocator.con1(completionOffset).searchWithin(unit);
+          if (request.node is SimpleIdentifier) {
+            request.replacementOffset = request.node.offset;
+            request.replacementLength = request.node.length;
+          } else {
+            request.replacementOffset = request.offset;
+            request.replacementLength = 0;
+          }
+          if (request.replacementOffset == null) {
+            fail('expected non null');
+          }
           resolved = true;
           if (!fullAnalysis) {
             break;
           }
         }
       }
 
       result = context.performAnalysisTask();
     }
     if (!resolved) {
@@ skipping 401 matching lines @@
       String bar() => true;
       void main() {expect(foo: ^)}''');
     computeFast();
     return computeFull((bool result) {
       assertSuggestLocalFunction('bar', 'String');
       assertSuggestImportedFunction('hasLength', 'bool');
       assertNotSuggested('main');
     });
   }
 
+  test_AsExpression() {
+    // SimpleIdentifier  TypeName  AsExpression
+    addTestSource('''
+      class A {var b; X _c; foo() {var a; (a as ^).foo();}''');
+    computeFast();
+    return computeFull((bool result) {
+      assertNotSuggested('b');
+      assertNotSuggested('_c');
+      assertSuggestImportedClass('Object');
+      assertSuggestLocalClass('A');
+      assertNotSuggested('==');
+    });
+  }
+
   test_AssignmentExpression_name() {
     // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
     // VariableDeclarationStatement  Block
     addTestSource('class A {} main() {int a; int ^b = 1;}');
     computeFast();
     return computeFull((bool result) {
       assertNoSuggestions();
     });
   }
 
@@ skipping 101 matching lines @@
       assertLocalSuggestMethod('b', 'X', 'void');
       assertSuggestLocalVariable('f', null);
       // Don't suggest locals out of scope
       assertNotSuggested('r');
       assertNotSuggested('x');
 
       assertSuggestImportedClass('A');
       assertNotSuggested('_B');
       assertSuggestImportedClass('C');
       // hidden element suggested as low relevance
-      assertSuggestImportedClass('D', CompletionRelevance.LOW);
-      assertSuggestImportedFunction('D1', null, true, CompletionRelevance.LOW);
+      // but imported results are partially filtered
+      //assertSuggestImportedClass('D', CompletionRelevance.LOW);
+      //assertSuggestImportedFunction('D1', null, true, CompletionRelevance.LOW);
       assertSuggestLocalFunction('D2', 'Z');
       assertSuggestImportedClass('EE');
       // hidden element suggested as low relevance
-      assertSuggestImportedClass('F', CompletionRelevance.LOW);
+      //assertSuggestImportedClass('F', CompletionRelevance.LOW);
       assertSuggestLibraryPrefix('g');
       assertNotSuggested('G');
-      assertSuggestImportedClass('H', CompletionRelevance.LOW);
+      //assertSuggestImportedClass('H', CompletionRelevance.LOW);
       assertSuggestImportedClass('Object');
       assertSuggestImportedFunction('min', 'num', false);
-      assertSuggestImportedFunction(
-          'max',
-          'num',
-          false,
-          CompletionRelevance.LOW);
+      //assertSuggestImportedFunction(
+      //    'max',
+      //    'num',
+      //    false,
+      //    CompletionRelevance.LOW);
       assertSuggestTopLevelVarGetterSetter('T1', 'String');
       assertNotSuggested('_T2');
-      assertSuggestImportedTopLevelVar('T3', 'int', CompletionRelevance.LOW);
+      //assertSuggestImportedTopLevelVar('T3', 'int', CompletionRelevance.LOW);
       assertNotSuggested('_T4');
       assertSuggestLocalTopLevelVar('T5', 'int');
       assertSuggestLocalTopLevelVar('_T6', null);
       assertNotSuggested('==');
       // TODO (danrubel) suggest HtmlElement as low relevance
       assertNotSuggested('HtmlElement');
     });
   }
 
+  test_Block_identifier_partial() {
+    addSource('/testAB.dart', '''
+      export "dart:math" hide max;
+      class A {int x;}
+      @deprecated D1() {int x;}
+      class _B { }''');
+    addSource('/testCD.dart', '''
+      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 { }
+      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;}
+      class X {a() {var f; {var x;} D^ var r;} void b() { }}
+      class Z { }''');
+    computeFast();
+    return computeFull((bool result) {
+
+      assertSuggestLocalClass('X');
+      assertSuggestLocalClass('Z');
+      assertLocalSuggestMethod('a', 'X', null);
+      assertLocalSuggestMethod('b', 'X', 'void');
+      assertSuggestLocalVariable('f', null);
+      // 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', CompletionRelevance.LOW);
+      assertSuggestImportedFunction('D1', null, true, CompletionRelevance.LOW);
+      assertSuggestLocalFunction('D2', 'Z');
+      //assertSuggestImportedClass('EE');
+      // hidden element suggested as low relevance
+      //assertSuggestImportedClass('F', CompletionRelevance.LOW);
+      //assertSuggestLibraryPrefix('g');
+      assertNotSuggested('G');
+      //assertSuggestImportedClass('H', CompletionRelevance.LOW);
+      //assertSuggestImportedClass('Object');
+      //assertSuggestImportedFunction('min', 'num', false);
+      //assertSuggestImportedFunction(
+      //    'max',
+      //    'num',
+      //    false,
+      //    CompletionRelevance.LOW);
+      //assertSuggestTopLevelVarGetterSetter('T1', 'String');
+      assertNotSuggested('_T2');
+      //assertSuggestImportedTopLevelVar('T3', 'int', CompletionRelevance.LOW);
+      assertNotSuggested('_T4');
+      //assertSuggestLocalTopLevelVar('T5', 'int');
+      //assertSuggestLocalTopLevelVar('_T6', null);
+      assertNotSuggested('==');
+      // TODO (danrubel) suggest HtmlElement as low relevance
+      assertNotSuggested('HtmlElement');
+    });
+  }
+
   test_Block_inherited_imported() {
     // Block  BlockFunctionBody  MethodDeclaration  ClassDeclaration
     addSource('/testB.dart', '''
       lib B;
       class F { var f1; f2() { } }
       class E extends F { var e1; e2() { } }
       class I { int i1; i2() { } }
       class M { var m1; int m2() { } }''');
     addTestSource('''
       import "/testB.dart";
@@ skipping 108 matching lines @@
       class A {var b; X _c;}
       class X{}
       main() {A a; a^..b}''');
     computeFast();
     return computeFull((bool result) {
       assertNotSuggested('b');
       assertNotSuggested('_c');
       assertSuggestLocalVariable('a', 'A');
       assertSuggestLocalClass('A');
       assertSuggestLocalClass('X');
-      assertSuggestImportedClass('Object');
+      // top level results are partially filtered
+      //assertSuggestImportedClass('Object');
       assertNotSuggested('==');
     });
   }
 
   test_CatchClause_typed() {
     // Block  CatchClause  TryStatement
     addTestSource('class A {a() {try{var x;} on E catch (e) {^}}}');
     computeFast();
     return computeFull((bool result) {
       assertSuggestParameter('e', 'E');
@@ skipping 173 matching lines @@
   test_ExpressionStatement_identifier() {
     // SimpleIdentifier  ExpressionStatement  Block
     addSource('/testA.dart', '''
       _B F1() { }
       class A {int x;}
       class _B { }''');
     addTestSource('''
       import "/testA.dart";
       typedef int F2(int blat);
       class Clz = Object with Object;
-      class C {foo(){O^} void bar() {}}''');
+      class C {foo(){^} void bar() {}}''');
     computeFast();
     return computeFull((bool result) {
       assertSuggestImportedClass('A');
       assertSuggestImportedFunction('F1', '_B', false);
       assertSuggestLocalClass('C');
       assertSuggestLocalMethod('foo', 'C', null);
       assertSuggestLocalMethod('bar', 'C', 'void');
       assertSuggestLocalFunctionTypeAlias('F2', 'int');
       assertSuggestLocalClassTypeAlias('Clz');
       assertSuggestLocalClass('C');
@@ skipping 211 matching lines @@
       assertSuggestImportedClass('Object');
     });
   }
 
   test_InterpolationExpression_block() {
     // SimpleIdentifier  InterpolationExpression  StringInterpolation
     addTestSource('main() {String name; print("hello \${n^}");}');
     computeFast();
     return computeFull((bool result) {
       assertSuggestLocalVariable('name', 'String');
-      assertSuggestImportedClass('Object');
+      // top level results are partially filtered
+      //assertSuggestImportedClass('Object');
     });
   }
 
   test_InterpolationExpression_prefix_selector() {
     // SimpleIdentifier  PrefixedIdentifier  InterpolationExpression
     addTestSource('main() {String name; print("hello \${name.^}");}');
     computeFast();
     return computeFull((bool result) {
       assertSuggestInvocationGetter('length', 'int');
       assertNotSuggested('name');
       assertNotSuggested('Object');
       assertNotSuggested('==');
     });
   }
 
   test_InterpolationExpression_prefix_target() {
     // SimpleIdentifier  PrefixedIdentifier  InterpolationExpression
     addTestSource('main() {String name; print("hello \${nam^e.length}");}');
     computeFast();
     return computeFull((bool result) {
       assertSuggestLocalVariable('name', 'String');
-      assertSuggestImportedClass('Object');
+      // top level results are partially filtered
+      //assertSuggestImportedClass('Object');
       assertNotSuggested('length');
     });
   }
 
   test_IsExpression() {
     // SimpleIdentifier  TypeName  IsExpression  IfStatement
     addSource('/testB.dart', '''
       lib B;
       foo() { }
       class X {X.c(); X._d(); z() {}}''');
@@ skipping 36 matching lines @@
       main(){var a; if (a is ^)}''');
     computeFast();
     return computeFull((bool result) {
       assertNotSuggested('a');
       assertNotSuggested('main');
       assertSuggestLocalClass('A');
       assertSuggestImportedClass('Object');
     });
   }
 
+  test_IsExpression_type_partial() {
+    // SimpleIdentifier  TypeName  IsExpression  IfStatement
+    addTestSource('''
+      class A {int x; int y() => 0;}
+      main(){var a; if (a is Obj^)}''');
+    computeFast();
+    return computeFull((bool result) {
+      assertNotSuggested('a');
+      assertNotSuggested('main');
+      assertSuggestLocalClass('A');
+      assertSuggestImportedClass('Object');
+    });
+  }
+
   test_Literal_string() {
     // SimpleStringLiteral  ExpressionStatement  Block
     addTestSource('class A {a() {"hel^lo"}}');
     computeFast();
     return computeFull((bool result) {
       assertNoSuggestions();
     });
   }
 
   test_MethodDeclaration_body_getters() {
@@ skipping 410 matching lines @@
       assertNotSuggested('bar2');
       assertNotSuggested('_B');
       assertSuggestLocalClass('Y');
       assertSuggestLocalClass('C');
       assertSuggestLocalVariable('f', null);
       assertNotSuggested('x');
       assertNotSuggested('e');
     });
   }
 }