move relevance computation from client to server

pkg/analysis_server/test/services/completion/local_computer_test.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.dart.local;
 
 import 'package:analysis_server/src/protocol_server.dart';
 import 'package:analysis_server/src/services/completion/dart_completion_manager.dart';
 import 'package:analysis_server/src/services/completion/local_computer.dart';
 import 'package:unittest/unittest.dart';
@@ skipping 12 matching lines @@
   @override
   CompletionSuggestion assertSuggestLocalClass(String name, {int relevance:
       COMPLETION_RELEVANCE_DEFAULT, bool isDeprecated: false}) {
     return assertSuggestClass(
         name,
         relevance: relevance,
         isDeprecated: isDeprecated);
   }
 
   @override
+  CompletionSuggestion assertSuggestLocalClassTypeAlias(String name,
+      {int relevance: COMPLETION_RELEVANCE_DEFAULT}) {
+    return assertSuggestClassTypeAlias(name, relevance);
+  }
+
+  @override
   CompletionSuggestion assertSuggestLocalField(String name, String type,
-      {int relevance: COMPLETION_RELEVANCE_DEFAULT, bool isDeprecated: false}) {
+      {int relevance: DART_RELEVANCE_LOCAL_FIELD, bool deprecated: false}) {
     return assertSuggestField(
         name,
         type,
         relevance: relevance,
-        isDeprecated: isDeprecated);
+        isDeprecated: deprecated);
+  }
+
+  @override
+  CompletionSuggestion assertSuggestLocalFunction(String name,
+      String returnType, {bool deprecated: false, int relevance:
+      DART_RELEVANCE_LOCAL_FUNCTION}) {
+    return assertSuggestFunction(name, returnType, deprecated, relevance);
+  }
+
+  @override
+  CompletionSuggestion assertSuggestLocalFunctionTypeAlias(String name,
+      String returnType, {bool deprecated: false, int relevance:
+      COMPLETION_RELEVANCE_DEFAULT}) {
+    return assertSuggestFunctionTypeAlias(
+        name,
+        returnType,
+        deprecated,
+        relevance);
   }
 
   @override
   CompletionSuggestion assertSuggestLocalGetter(String name, String returnType,
-      {int relevance: COMPLETION_RELEVANCE_DEFAULT, bool isDeprecated: false}) {
+      {int relevance: DART_RELEVANCE_LOCAL_ACCESSOR, bool deprecated: false}) {
     return assertSuggestGetter(
         name,
         returnType,
         relevance: relevance,
-        isDeprecated: isDeprecated);
+        isDeprecated: deprecated);
   }
 
   @override
   CompletionSuggestion assertSuggestLocalMethod(String name,
       String declaringType, String returnType, {int relevance:
-      COMPLETION_RELEVANCE_DEFAULT, bool isDeprecated: false}) {
+      DART_RELEVANCE_LOCAL_METHOD, bool deprecated: false}) {
     return assertSuggestMethod(
         name,
         declaringType,
         returnType,
         relevance: relevance,
-        isDeprecated: isDeprecated);
+        isDeprecated: deprecated);
+  }
+
+  @override
+  CompletionSuggestion assertSuggestLocalSetter(String name, {int relevance:
+      DART_RELEVANCE_LOCAL_ACCESSOR}) {
+    return assertSuggestSetter(name, relevance);
+  }
+
+  @override
+  CompletionSuggestion assertSuggestLocalTopLevelVar(String name,
+      String returnType, {int relevance: DART_RELEVANCE_LOCAL_TOP_LEVEL_VARIABLE}) {
+    return assertSuggestTopLevelVar(name, returnType, relevance);
+  }
+
+  @override
+  CompletionSuggestion assertSuggestLocalVariable(String name,
+      String returnType, {int relevance: DART_RELEVANCE_LOCAL_VARIABLE}) {
+    // Local variables should only be suggested by LocalComputer
+    CompletionSuggestion cs = assertSuggest(
+        name,
+        csKind: CompletionSuggestionKind.INVOCATION,
+        relevance: relevance);
+    expect(cs.returnType, returnType != null ? returnType : 'dynamic');
+    Element element = cs.element;
+    expect(element, isNotNull);
+    expect(element.kind, equals(ElementKind.LOCAL_VARIABLE));
+    expect(element.name, equals(name));
+    expect(element.parameters, isNull);
+    expect(element.returnType, returnType != null ? returnType : 'dynamic');
+    assertHasNoParameterInfo(cs);
+    return cs;
+  }
+
+  CompletionSuggestion assertSuggestParameter(String name, String returnType,
+      {int relevance: DART_RELEVANCE_PARAMETER}) {
+    CompletionSuggestion cs = assertSuggest(
+        name,
+        csKind: CompletionSuggestionKind.INVOCATION,
+        relevance: relevance);
+    expect(cs.returnType, returnType != null ? returnType : 'dynamic');
+    Element element = cs.element;
+    expect(element, isNotNull);
+    expect(element.kind, equals(ElementKind.PARAMETER));
+    expect(element.name, equals(name));
+    expect(element.parameters, isNull);
+    expect(
+        element.returnType,
+        equals(returnType != null ? returnType : 'dynamic'));
+    return cs;
   }
 
   fail_mixin_ordering() {
     // TODO(paulberry): Duplicates aren't being removed, so we see both M1.m()
     // and M2.m().
     addTestSource('''
 class B {}
 class M1 {
   void m() {}
 }
@@ skipping 294 matching lines @@
   }
 
   test_function_parameters_mixed_required_and_named() {
     addTestSource('''
 void m(x, {int y}) {}
 class B extends A {
   main() {^}
 }
 ''');
     expect(computeFast(), isTrue);
-    CompletionSuggestion suggestion = assertSuggestFunction('m', 'void');
+    CompletionSuggestion suggestion = assertSuggestLocalFunction('m', 'void');
     expect(suggestion.parameterNames, hasLength(2));
     expect(suggestion.parameterNames[0], 'x');
     expect(suggestion.parameterTypes[0], 'dynamic');
     expect(suggestion.parameterNames[1], 'y');
     expect(suggestion.parameterTypes[1], 'int');
     expect(suggestion.requiredParameterCount, 1);
     expect(suggestion.hasNamedParameters, true);
   }
 
   test_function_parameters_mixed_required_and_positional() {
     addTestSource('''
 void m(x, [int y]) {}
 class B extends A {
   main() {^}
 }
 ''');
     expect(computeFast(), isTrue);
-    CompletionSuggestion suggestion = assertSuggestFunction('m', 'void');
+    CompletionSuggestion suggestion = assertSuggestLocalFunction('m', 'void');
     expect(suggestion.parameterNames, hasLength(2));
     expect(suggestion.parameterNames[0], 'x');
     expect(suggestion.parameterTypes[0], 'dynamic');
     expect(suggestion.parameterNames[1], 'y');
     expect(suggestion.parameterTypes[1], 'int');
     expect(suggestion.requiredParameterCount, 1);
     expect(suggestion.hasNamedParameters, false);
   }
 
   test_function_parameters_named() {
     addTestSource('''
 void m({x, int y}) {}
 class B extends A {
   main() {^}
 }
 ''');
     expect(computeFast(), isTrue);
-    CompletionSuggestion suggestion = assertSuggestFunction('m', 'void');
+    CompletionSuggestion suggestion = assertSuggestLocalFunction('m', 'void');
     expect(suggestion.parameterNames, hasLength(2));
     expect(suggestion.parameterNames[0], 'x');
     expect(suggestion.parameterTypes[0], 'dynamic');
     expect(suggestion.parameterNames[1], 'y');
     expect(suggestion.parameterTypes[1], 'int');
     expect(suggestion.requiredParameterCount, 0);
     expect(suggestion.hasNamedParameters, true);
   }
 
   test_function_parameters_none() {
     addTestSource('''
 void m() {}
 class B extends A {
   main() {^}
 }
 ''');
     expect(computeFast(), isTrue);
-    CompletionSuggestion suggestion = assertSuggestFunction('m', 'void');
+    CompletionSuggestion suggestion = assertSuggestLocalFunction('m', 'void');
     expect(suggestion.parameterNames, isEmpty);
     expect(suggestion.parameterTypes, isEmpty);
     expect(suggestion.requiredParameterCount, 0);
     expect(suggestion.hasNamedParameters, false);
   }
 
   test_function_parameters_positional() {
     addTestSource('''
 void m([x, int y]) {}
 class B extends A {
   main() {^}
 }
 ''');
     expect(computeFast(), isTrue);
-    CompletionSuggestion suggestion = assertSuggestFunction('m', 'void');
+    CompletionSuggestion suggestion = assertSuggestLocalFunction('m', 'void');
     expect(suggestion.parameterNames, hasLength(2));
     expect(suggestion.parameterNames[0], 'x');
     expect(suggestion.parameterTypes[0], 'dynamic');
     expect(suggestion.parameterNames[1], 'y');
     expect(suggestion.parameterTypes[1], 'int');
     expect(suggestion.requiredParameterCount, 0);
     expect(suggestion.hasNamedParameters, false);
   }
 
   test_function_parameters_required() {
     addTestSource('''
 void m(x, int y) {}
 class B extends A {
   main() {^}
 }
 ''');
     expect(computeFast(), isTrue);
-    CompletionSuggestion suggestion = assertSuggestFunction('m', 'void');
+    CompletionSuggestion suggestion = assertSuggestLocalFunction('m', 'void');
     expect(suggestion.parameterNames, hasLength(2));
     expect(suggestion.parameterNames[0], 'x');
     expect(suggestion.parameterTypes[0], 'dynamic');
     expect(suggestion.parameterNames[1], 'y');
     expect(suggestion.parameterTypes[1], 'int');
     expect(suggestion.requiredParameterCount, 2);
     expect(suggestion.hasNamedParameters, false);
   }
 
   test_method_parameters_mixed_required_and_named() {
     addTestSource('''
 class A {
   void m(x, {int y}) {}
 }
 class B extends A {
   main() {^}
 }
 ''');
     expect(computeFast(), isTrue);
-    CompletionSuggestion suggestion = assertSuggestMethod('m', 'A', 'void');
+    CompletionSuggestion suggestion =
+        assertSuggestLocalMethod('m', 'A', 'void');
     expect(suggestion.parameterNames, hasLength(2));
     expect(suggestion.parameterNames[0], 'x');
     expect(suggestion.parameterTypes[0], 'dynamic');
     expect(suggestion.parameterNames[1], 'y');
     expect(suggestion.parameterTypes[1], 'int');
     expect(suggestion.requiredParameterCount, 1);
     expect(suggestion.hasNamedParameters, true);
   }
 
   test_method_parameters_mixed_required_and_positional() {
     addTestSource('''
 class A {
   void m(x, [int y]) {}
 }
 class B extends A {
   main() {^}
 }
 ''');
     expect(computeFast(), isTrue);
-    CompletionSuggestion suggestion = assertSuggestMethod('m', 'A', 'void');
+    CompletionSuggestion suggestion =
+        assertSuggestLocalMethod('m', 'A', 'void');
     expect(suggestion.parameterNames, hasLength(2));
     expect(suggestion.parameterNames[0], 'x');
     expect(suggestion.parameterTypes[0], 'dynamic');
     expect(suggestion.parameterNames[1], 'y');
     expect(suggestion.parameterTypes[1], 'int');
     expect(suggestion.requiredParameterCount, 1);
     expect(suggestion.hasNamedParameters, false);
   }
 
   test_method_parameters_named() {
     addTestSource('''
 class A {
   void m({x, int y}) {}
 }
 class B extends A {
   main() {^}
 }
 ''');
     expect(computeFast(), isTrue);
-    CompletionSuggestion suggestion = assertSuggestMethod('m', 'A', 'void');
+    CompletionSuggestion suggestion =
+        assertSuggestLocalMethod('m', 'A', 'void');
     expect(suggestion.parameterNames, hasLength(2));
     expect(suggestion.parameterNames[0], 'x');
     expect(suggestion.parameterTypes[0], 'dynamic');
     expect(suggestion.parameterNames[1], 'y');
     expect(suggestion.parameterTypes[1], 'int');
     expect(suggestion.requiredParameterCount, 0);
     expect(suggestion.hasNamedParameters, true);
   }
 
   test_method_parameters_none() {
     addTestSource('''
 class A {
   void m() {}
 }
 class B extends A {
   main() {^}
 }
 ''');
     expect(computeFast(), isTrue);
-    CompletionSuggestion suggestion = assertSuggestMethod('m', 'A', 'void');
+    CompletionSuggestion suggestion =
+        assertSuggestLocalMethod('m', 'A', 'void');
     expect(suggestion.parameterNames, isEmpty);
     expect(suggestion.parameterTypes, isEmpty);
     expect(suggestion.requiredParameterCount, 0);
     expect(suggestion.hasNamedParameters, false);
   }
 
   test_method_parameters_positional() {
     addTestSource('''
 class A {
   void m([x, int y]) {}
 }
 class B extends A {
   main() {^}
 }
 ''');
     expect(computeFast(), isTrue);
-    CompletionSuggestion suggestion = assertSuggestMethod('m', 'A', 'void');
+    CompletionSuggestion suggestion =
+        assertSuggestLocalMethod('m', 'A', 'void');
     expect(suggestion.parameterNames, hasLength(2));
     expect(suggestion.parameterNames[0], 'x');
     expect(suggestion.parameterTypes[0], 'dynamic');
     expect(suggestion.parameterNames[1], 'y');
     expect(suggestion.parameterTypes[1], 'int');
     expect(suggestion.requiredParameterCount, 0);
     expect(suggestion.hasNamedParameters, false);
   }
 
   test_method_parameters_required() {
     addTestSource('''
 class A {
   void m(x, int y) {}
 }
 class B extends A {
   main() {^}
 }
 ''');
     expect(computeFast(), isTrue);
-    CompletionSuggestion suggestion = assertSuggestMethod('m', 'A', 'void');
+    CompletionSuggestion suggestion =
+        assertSuggestLocalMethod('m', 'A', 'void');
     expect(suggestion.parameterNames, hasLength(2));
     expect(suggestion.parameterNames[0], 'x');
     expect(suggestion.parameterTypes[0], 'dynamic');
     expect(suggestion.parameterNames[1], 'y');
     expect(suggestion.parameterTypes[1], 'int');
     expect(suggestion.requiredParameterCount, 2);
     expect(suggestion.hasNamedParameters, false);
   }
 }