make deprecated elements have low suggestion relevance

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 78 matching lines @@
                 'expected exactly one $completion',
                 request.suggestions.where((s) => s.completion == completion));
           }
         }
       }
     });
     if (cs == null) {
       _failedCompletion('expected $completion $csKind', request.suggestions);
     }
     expect(cs.kind, equals(csKind));
-    expect(cs.relevance, equals(relevance));
+    if (isDeprecated) {
+      expect(cs.relevance, equals(CompletionRelevance.LOW));
+    } else {
+      expect(cs.relevance, equals(relevance));
+    }
     expect(cs.selectionOffset, equals(completion.length));
     expect(cs.selectionLength, equals(0));
     expect(cs.isDeprecated, equals(isDeprecated));
     expect(cs.isPotential, equals(isPotential));
     return cs;
   }
 
   CompletionSuggestion assertSuggestClass(String name,
       [CompletionRelevance relevance = CompletionRelevance.DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
@@ skipping 67 matching lines @@
 //    expect(param[0], equals('('));
 //    expect(param[param.length - 1], equals(')'));
     // TODO (danrubel) Determine why return type is null
 //    expect(
 //        element.returnType,
 //        equals(returnType != null ? returnType : 'dynamic'));
     return cs;
   }
 
   CompletionSuggestion assertSuggestGetter(String name, String returnType,
-      [CompletionRelevance relevance = CompletionRelevance.DEFAULT,
-      CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
+      {CompletionRelevance relevance: CompletionRelevance.DEFAULT,
+      CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION,
+      bool isDeprecated: false}) {
     CompletionSuggestion cs = assertSuggest(
         name,
         csKind: kind,
         relevance: relevance,
-        elemKind: protocol.ElementKind.GETTER);
+        elemKind: protocol.ElementKind.GETTER,
+        isDeprecated: isDeprecated);
     expect(cs.returnType, equals(returnType));
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.GETTER));
     expect(element.name, equals(name));
     //TODO (danrubel) getter should have parameters
     // but not used in code completion
     //expect(element.parameters, '()');
     expect(
         element.returnType,
@@ skipping 300 matching lines @@
           kind);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestImportedGetter(String name,
       String returnType, [CompletionRelevance relevance =
       CompletionRelevance.DEFAULT]) {
     if (computer is ImportedComputer) {
-      return assertSuggestGetter(name, returnType, relevance);
+      return assertSuggestGetter(name, returnType, relevance: relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestImportedMethod(String name,
       String declaringType, String returnType, [CompletionRelevance relevance =
       CompletionRelevance.DEFAULT]) {
     if (computer is ImportedComputer) {
       return assertSuggestMethod(name, declaringType, returnType, relevance);
@@ skipping 15 matching lines @@
   CompletionSuggestion assertSuggestInvocationClass(String name,
       [CompletionRelevance relevance = CompletionRelevance.DEFAULT]) {
     if (computer is InvocationComputer) {
       return assertSuggestClass(name, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestInvocationGetter(String name,
-      String returnType, [CompletionRelevance relevance =
-      CompletionRelevance.DEFAULT]) {
+      String returnType, {CompletionRelevance relevance: CompletionRelevance.DEFAULT,
+      bool isDeprecated: false}) {
     if (computer is InvocationComputer) {
-      return assertSuggestGetter(name, returnType, relevance);
+      return assertSuggestGetter(
+          name,
+          returnType,
+          relevance: relevance,
+          isDeprecated: isDeprecated);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestInvocationMethod(String name,
       String declaringType, String returnType, [CompletionRelevance relevance =
       CompletionRelevance.DEFAULT]) {
     if (computer is InvocationComputer) {
       return assertSuggestMethod(name, declaringType, returnType, relevance);
@@ skipping 59 matching lines @@
           isDeprecated,
           relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestLocalGetter(String name, String returnType,
       [CompletionRelevance relevance = CompletionRelevance.DEFAULT]) {
     if (computer is LocalComputer) {
-      return assertSuggestGetter(name, returnType, relevance);
+      return assertSuggestGetter(name, returnType, relevance: relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestLocalMethod(String name,
       String declaringType, String returnType, [CompletionRelevance relevance =
       CompletionRelevance.DEFAULT]) {
     if (computer is LocalComputer) {
       return assertSuggestMethod(name, declaringType, returnType, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestLocalTopLevelVar(String name,
       String returnType, [CompletionRelevance relevance =
       CompletionRelevance.DEFAULT]) {
     if (computer is LocalComputer) {
       return assertSuggestTopLevelVar(name, returnType, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   test_ArgumentList() {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
     addSource('/libA.dart', '''
       library A;
+      bool hasLength(int expected) { }
+      void baz() { }''');
+    addTestSource('''
+      import '/libA.dart'
+      String bar() => true;
+      void main() {expect(^)}''');
+    computeFast();
+    return computeFull(true).then((_) {
+      assertSuggestLocalFunction('bar', 'String');
+      assertSuggestImportedFunction('hasLength', 'bool');
+      assertNotSuggested('main');
+      assertNotSuggested('baz');
+    });
+  }
+
+  test_ArgumentList_namedParam() {
+    // SimpleIdentifier  NamedExpression  ArgumentList  MethodInvocation
+    // ExpressionStatement
+    addSource('/libA.dart', '''
+      library A;
       bool hasLength(int expected) { }''');
     addTestSource('''
       import '/libA.dart'
-      main() {expect(^)}''');
+      String bar() => true;
+      void main() {expect(foo: ^)}''');
     computeFast();
     return computeFull(true).then((_) {
-      assertSuggestLocalFunction('main', null);
+      assertSuggestLocalFunction('bar', 'String');
       assertSuggestImportedFunction('hasLength', 'bool');
+      assertNotSuggested('main');
     });
   }
 
   test_AssignmentExpression_name() {
     // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
     // VariableDeclarationStatement  Block
     addTestSource('class A {} main() {int a; int ^b = 1;}');
     computeFast();
     return computeFull(true).then((_) {
       assertNoSuggestions();
@@ skipping 105 matching lines @@
       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);
+      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(
@@ skipping 99 matching lines @@
       assertSuggestInvocationGetter('_c', 'X');
       assertNotSuggested('Object');
       assertNotSuggested('A');
       assertNotSuggested('B');
       assertNotSuggested('X');
       assertNotSuggested('z');
       assertNotSuggested('==');
     });
   }
 
+  test_CascadeExpression_selector2_withTrailingReturn() {
+    // PropertyAccess  CascadeExpression  ExpressionStatement  Block
+    addSource('/testB.dart', '''
+      class B { }''');
+    addTestSource('''
+      import "/testB.dart";
+      class A {var b; X _c;}
+      class X{}
+      main() {A a; a..^ return}''');
+    computeFast();
+    return computeFull(true).then((_) {
+      assertSuggestInvocationGetter('b', null);
+      assertSuggestInvocationGetter('_c', 'X');
+      assertNotSuggested('Object');
+      assertNotSuggested('A');
+      assertNotSuggested('B');
+      assertNotSuggested('X');
+      assertNotSuggested('z');
+      assertNotSuggested('==');
+    });
+  }
+
   test_CascadeExpression_target() {
     // SimpleIdentifier  CascadeExpression  ExpressionStatement
     addTestSource('''
       class A {var b; X _c;}
       class X{}
       main() {A a; a^..b}''');
     computeFast();
     return computeFull(true).then((_) {
       assertNotSuggested('b');
       assertNotSuggested('_c');
@@ skipping 34 matching lines @@
     // ClassDeclaration  CompilationUnit
     addSource('/testB.dart', '''
       class B { }''');
     addTestSource('''
       import "testB.dart" as x;
       @deprecated class A {^}
       class _B {}
       A T;''');
     computeFast();
     return computeFull(true).then((_) {
-      CompletionSuggestion suggestionA = assertSuggestLocalClass('A');
+      CompletionSuggestion suggestionA =
+          assertSuggestLocalClass('A', CompletionRelevance.LOW);
       if (suggestionA != null) {
         expect(suggestionA.element.isDeprecated, isTrue);
         expect(suggestionA.element.isPrivate, isFalse);
       }
       CompletionSuggestion suggestionB = assertSuggestLocalClass('_B');
       if (suggestionB != null) {
         expect(suggestionB.element.isDeprecated, isFalse);
         expect(suggestionB.element.isPrivate, isTrue);
       }
       CompletionSuggestion suggestionO = assertSuggestImportedClass('Object');
@@ skipping 478 matching lines @@
   test_MethodDeclaration_body_getters() {
     // Block  BlockFunctionBody  MethodDeclaration
     addTestSource('class A {@deprecated X get f => 0; Z a() {^} get _g => 1;}');
     computeFast();
     return computeFull(true).then((_) {
       CompletionSuggestion methodA = assertSuggestLocalMethod('a', 'A', 'Z');
       if (methodA != null) {
         expect(methodA.element.isDeprecated, isFalse);
         expect(methodA.element.isPrivate, isFalse);
       }
-      CompletionSuggestion getterF = assertSuggestLocalGetter('f', 'X');
+      CompletionSuggestion getterF =
+          assertSuggestLocalGetter('f', 'X', CompletionRelevance.LOW);
       if (getterF != null) {
         expect(getterF.element.isDeprecated, isTrue);
         expect(getterF.element.isPrivate, isFalse);
       }
       CompletionSuggestion getterG = assertSuggestLocalGetter('_g', null);
       if (getterG != null) {
         expect(getterG.element.isDeprecated, isFalse);
         expect(getterG.element.isPrivate, isTrue);
       }
     });
   }
 
   test_MethodDeclaration_members() {
     // Block  BlockFunctionBody  MethodDeclaration
     addTestSource('class A {@deprecated X f; Z _a() {^} var _g;}');
     computeFast();
     return computeFull(true).then((_) {
       CompletionSuggestion methodA = assertSuggestLocalMethod('_a', 'A', 'Z');
       if (methodA != null) {
         expect(methodA.element.isDeprecated, isFalse);
         expect(methodA.element.isPrivate, isTrue);
       }
-      CompletionSuggestion getterF = assertSuggestLocalGetter('f', 'X');
+      CompletionSuggestion getterF =
+          assertSuggestLocalGetter('f', 'X', CompletionRelevance.LOW);
       if (getterF != null) {
         expect(getterF.element.isDeprecated, isTrue);
         expect(getterF.element.isPrivate, isFalse);
       }
       CompletionSuggestion getterG = assertSuggestLocalGetter('_g', null);
       if (getterG != null) {
         expect(getterG.element.isDeprecated, isFalse);
         expect(getterG.element.isPrivate, isTrue);
       }
       assertSuggestImportedClass('bool');
     });
   }
 
   test_MethodDeclaration_parameters_named() {
     // Block  BlockFunctionBody  MethodDeclaration
     addTestSource('class A {@deprecated Z a(X x, _, b, {y: boo}) {^}}');
     computeFast();
     return computeFull(true).then((_) {
-      CompletionSuggestion methodA = assertSuggestLocalMethod('a', 'A', 'Z');
+      CompletionSuggestion methodA =
+          assertSuggestLocalMethod('a', 'A', 'Z', CompletionRelevance.LOW);
       if (methodA != null) {
         expect(methodA.element.isDeprecated, isTrue);
         expect(methodA.element.isPrivate, isFalse);
       }
       assertSuggestParameter('x', 'X');
       assertSuggestParameter('y', null);
       assertSuggestParameter('b', null);
       assertSuggestImportedClass('int');
       assertNotSuggested('_');
     });
@@ skipping 93 matching lines @@
     });
   }
 
   test_PrefixedIdentifier_class_imported() {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
     addSource('/testB.dart', '''
       lib B;
       class I {X get f => new A();get _g => new A();}
       class A implements I {
         static const int sc = 12;
-        var b; X _c;
+        @deprecated var b; X _c;
         X get d => new A();get _e => new A();
         set s1(I x) {} set _s2(I x) {}
         m(X x) {} I _n(X x) {}}
       class X{}''');
     addTestSource('''
       import "/testB.dart";
       main() {A a; a.^}''');
     computeFast();
     return computeFull(true).then((_) {
       assertSuggestInvocationGetter('sc', 'int');
-      assertSuggestInvocationGetter('b', null);
+      assertSuggestInvocationGetter('b', null, isDeprecated: true);
       assertNotSuggested('_c');
       assertSuggestInvocationGetter('d', 'X');
       assertNotSuggested('_e');
       assertSuggestInvocationGetter('f', 'X');
       assertNotSuggested('_g');
       assertSuggestInvocationSetter('s1');
       assertNotSuggested('_s2');
       assertSuggestInvocationMethod('m', 'A', null);
       assertNotSuggested('_n');
       assertNotSuggested('a');
@@ skipping 220 matching lines @@
       assertNotSuggested('bar2');
       assertNotSuggested('_B');
       assertSuggestLocalClass('Y');
       assertSuggestLocalClass('C');
       assertSuggestLocalVariable('f', null);
       assertNotSuggested('x');
       assertNotSuggested('e');
     });
   }
 }