move relevance computation from client to server

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;
 import 'package:analysis_server/src/protocol.dart' hide Element, ElementKind;
 import 'package:analysis_server/src/services/completion/completion_manager.dart';
 import 'package:analysis_server/src/services/completion/dart_completion_cache.dart';
 import 'package:analysis_server/src/services/completion/dart_completion_manager.dart';
 import 'package:analysis_server/src/services/completion/imported_computer.dart';
 import 'package:analysis_server/src/services/completion/invocation_computer.dart';
-import 'package:analysis_server/src/services/completion/local_computer.dart';
 import 'package:analysis_server/src/services/index/index.dart';
 import 'package:analysis_server/src/services/index/local_memory_index.dart';
 import 'package:analysis_server/src/services/search/search_engine_internal.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:unittest/unittest.dart';
 
 import '../../abstract_context.dart';
@@ skipping 311 matching lines @@
       expect(element.kind, equals(protocol.ElementKind.LIBRARY));
       expect(element.parameters, isNull);
       expect(element.returnType, isNull);
       assertHasNoParameterInfo(cs);
       return cs;
     } else {
       return assertNotSuggested(prefix);
     }
   }
 
-  CompletionSuggestion assertSuggestLocalVariable(String name,
-      String returnType, [int relevance = COMPLETION_RELEVANCE_DEFAULT,
-      CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
-    // Local variables should only be suggested by LocalComputer
-    if (computer is LocalComputer) {
-      CompletionSuggestion cs =
-          assertSuggest(name, csKind: kind, relevance: relevance);
-      expect(cs.returnType, returnType != null ? returnType : 'dynamic');
-      protocol.Element element = cs.element;
-      expect(element, isNotNull);
-      expect(element.kind, equals(protocol.ElementKind.LOCAL_VARIABLE));
-      expect(element.name, equals(name));
-      expect(element.parameters, isNull);
-      expect(element.returnType, returnType != null ? returnType : 'dynamic');
-      assertHasNoParameterInfo(cs);
-      return cs;
-    } else {
-      return assertNotSuggested(name);
-    }
-  }
-
   CompletionSuggestion assertSuggestMethod(String name, String declaringType,
       String returnType, {int relevance: COMPLETION_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION,
       bool isDeprecated: false}) {
     CompletionSuggestion cs = assertSuggest(
         name,
         csKind: kind,
         relevance: relevance,
         isDeprecated: isDeprecated);
     expect(cs.declaringType, equals(declaringType));
@@ skipping 27 matching lines @@
       expect(param[param.length - 1], equals(')'));
       expect(element.returnType, equals(returnType));
       assertHasParameterInfo(cs);
       return cs;
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestParameter(String name, String returnType,
-      [int relevance = COMPLETION_RELEVANCE_DEFAULT, CompletionSuggestionKind kind =
-      CompletionSuggestionKind.INVOCATION]) {
-    // Parameters should only be suggested by LocalComputer
-    if (computer is LocalComputer) {
-      CompletionSuggestion cs =
-          assertSuggest(name, csKind: kind, relevance: relevance);
-      expect(cs.returnType, returnType != null ? returnType : 'dynamic');
-      protocol.Element element = cs.element;
-      expect(element, isNotNull);
-      expect(element.kind, equals(protocol.ElementKind.PARAMETER));
-      expect(element.name, equals(name));
-      expect(element.parameters, isNull);
-      expect(
-          element.returnType,
-          equals(returnType != null ? returnType : 'dynamic'));
-      return cs;
-    } else {
-      return assertNotSuggested(name);
-    }
+      {int relevance: DART_RELEVANCE_PARAMETER}) {
+    return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestSetter(String name, [int relevance =
       COMPLETION_RELEVANCE_DEFAULT, CompletionSuggestionKind kind =
       CompletionSuggestionKind.INVOCATION]) {
     CompletionSuggestion cs = assertSuggest(
         name,
         csKind: kind,
         relevance: relevance,
         elemKind: protocol.ElementKind.SETTER);
@@ skipping 171 matching lines @@
 abstract class AbstractSelectorSuggestionTest extends AbstractCompletionTest {
 
   /**
    * Assert that the ImportedComputer uses cached results to produce identical
    * suggestions to the original set of suggestions.
    */
   void assertCachedCompute(_) {
     // Subclasses override
   }
 
-  CompletionSuggestion assertLocalSuggestMethod(String name,
-      String declaringType, String returnType, [int relevance =
-      COMPLETION_RELEVANCE_DEFAULT]) {
-    if (computer is LocalComputer) {
-      return assertSuggestMethod(
-          name,
-          declaringType,
-          returnType,
-          relevance: relevance);
-    } else {
-      return assertNotSuggested(name);
-    }
-  }
-
   CompletionSuggestion assertSuggestImportedClass(String name, [int relevance =
       COMPLETION_RELEVANCE_DEFAULT, CompletionSuggestionKind kind =
       CompletionSuggestionKind.INVOCATION]) {
     if (computer is ImportedComputer) {
       return assertSuggestClass(name, relevance: relevance, kind: kind);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestImportedField(String name, String type,
-      [int relevance = COMPLETION_RELEVANCE_DEFAULT]) {
+      {int relevance: DART_RELEVANCE_INHERITED_FIELD}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestImportedFunction(String name,
       String returnType, [bool isDeprecated = false, int relevance =
       COMPLETION_RELEVANCE_DEFAULT, CompletionSuggestionKind kind =
       CompletionSuggestionKind.INVOCATION]) {
     if (computer is ImportedComputer) {
       return assertSuggestFunction(
           name,
@@ skipping 16 matching lines @@
           returnType,
           isDeprecated,
           relevance,
           kind);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestImportedGetter(String name,
-      String returnType, [int relevance = COMPLETION_RELEVANCE_DEFAULT]) {
-    if (computer is ImportedComputer) {
-      return assertSuggestGetter(name, returnType, relevance: relevance);
-    } else {
-      return assertNotSuggested(name);
-    }
+      String returnType, {int relevance: DART_RELEVANCE_INHERITED_ACCESSOR}) {
+    return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestImportedMethod(String name,
-      String declaringType, String returnType, [int relevance =
-      COMPLETION_RELEVANCE_DEFAULT]) {
-    if (computer is ImportedComputer) {
-      return assertSuggestMethod(
-          name,
-          declaringType,
-          returnType,
-          relevance: relevance);
-    } else {
-      return assertNotSuggested(name);
-    }
+      String declaringType, String returnType, {int relevance:
+      DART_RELEVANCE_INHERITED_METHOD}) {
+    return assertNotSuggested(name);
   }
 
-  CompletionSuggestion assertSuggestImportedSetter(String name, [int relevance =
-      COMPLETION_RELEVANCE_DEFAULT]) {
-    if (computer is ImportedComputer) {
-      return assertSuggestSetter(name, relevance);
-    } else {
-      return assertNotSuggested(name);
-    }
+  CompletionSuggestion assertSuggestImportedSetter(String name, {int relevance:
+      DART_RELEVANCE_INHERITED_ACCESSOR}) {
+    return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestImportedTopLevelVar(String name,
       String returnType, [int relevance = COMPLETION_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     if (computer is ImportedComputer) {
       return assertSuggestTopLevelVar(name, returnType, relevance, kind);
     } else {
       return assertNotSuggested(name);
     }
@@ skipping 58 matching lines @@
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestLocalClass(String name, {int relevance:
       COMPLETION_RELEVANCE_DEFAULT, bool isDeprecated: false}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestLocalClassTypeAlias(String name,
-      [int relevance = COMPLETION_RELEVANCE_DEFAULT]) {
-    if (computer is LocalComputer) {
-      return assertSuggestClassTypeAlias(name, relevance);
-    } else {
-      return assertNotSuggested(name);
-    }
+      {int relevance: COMPLETION_RELEVANCE_DEFAULT}) {
+    return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestLocalField(String name, String type,
-      {int relevance: COMPLETION_RELEVANCE_DEFAULT, bool isDeprecated: false}) {
+      {int relevance: DART_RELEVANCE_LOCAL_FIELD, bool deprecated: false}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestLocalFunction(String name,
-      String returnType, [bool isDeprecated = false, int relevance =
-      COMPLETION_RELEVANCE_DEFAULT]) {
-    if (computer is LocalComputer) {
-      return assertSuggestFunction(name, returnType, isDeprecated, relevance);
-    } else {
-      return assertNotSuggested(name);
-    }
+      String returnType, {bool deprecated: false, int relevance:
+      DART_RELEVANCE_LOCAL_FUNCTION}) {
+    return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestLocalFunctionTypeAlias(String name,
-      String returnType, [bool isDeprecated = false, int relevance =
-      COMPLETION_RELEVANCE_DEFAULT]) {
-    if (computer is LocalComputer) {
-      return assertSuggestFunctionTypeAlias(
-          name,
-          returnType,
-          isDeprecated,
-          relevance);
-    } else {
-      return assertNotSuggested(name);
-    }
+      String returnType, {bool deprecated: false, int relevance:
+      COMPLETION_RELEVANCE_DEFAULT}) {
+    return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestLocalGetter(String name, String returnType,
-      {int relevance: COMPLETION_RELEVANCE_DEFAULT, bool isDeprecated: false}) {
+      {int relevance: DART_RELEVANCE_LOCAL_ACCESSOR, bool deprecated: false}) {
     return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestLocalMethod(String name,
       String declaringType, String returnType, {int relevance:
-      COMPLETION_RELEVANCE_DEFAULT, bool isDeprecated: false}) {
+      DART_RELEVANCE_LOCAL_METHOD, bool deprecated: false}) {
     return assertNotSuggested(name);
   }
 
-  CompletionSuggestion assertSuggestLocalSetter(String name, [int relevance =
-      COMPLETION_RELEVANCE_DEFAULT]) {
-    if (computer is LocalComputer) {
-      return assertSuggestSetter(name, relevance);
-    } else {
-      return assertNotSuggested(name);
-    }
+  CompletionSuggestion assertSuggestLocalSetter(String name, {int relevance:
+      DART_RELEVANCE_LOCAL_ACCESSOR}) {
+    return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestLocalTopLevelVar(String name,
-      String returnType, [int relevance = COMPLETION_RELEVANCE_DEFAULT]) {
-    if (computer is LocalComputer) {
-      return assertSuggestTopLevelVar(name, returnType, relevance);
-    } else {
-      return assertNotSuggested(name);
-    }
+      String returnType, {int relevance: DART_RELEVANCE_LOCAL_TOP_LEVEL_VARIABLE}) {
+    return assertNotSuggested(name);
+  }
+
+  CompletionSuggestion assertSuggestLocalVariable(String name,
+      String returnType, {int relevance: DART_RELEVANCE_LOCAL_VARIABLE}) {
+    return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestNonLocalClass(String name, [int relevance =
       COMPLETION_RELEVANCE_DEFAULT, CompletionSuggestionKind kind =
       CompletionSuggestionKind.INVOCATION]) {
     return assertSuggestImportedClass(name, relevance, kind);
   }
 
   Future computeFull(assertFunction(bool result), {bool fullAnalysis: true}) {
     return super.computeFull(
@@ skipping 353 matching lines @@
         }
         void b() { }}
       class Z { }''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
 
       assertSuggestLocalClass('X');
       assertSuggestLocalClass('Z');
-      assertLocalSuggestMethod('a', 'X', null);
-      assertLocalSuggestMethod('b', 'X', 'void');
+      assertSuggestLocalMethod('a', 'X', null);
+      assertSuggestLocalMethod('b', 'X', 'void');
       assertSuggestLocalFunction('localF', null);
       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
@@ skipping 60 matching lines @@
       Z D2() {int x;}
       class X {a() {var f; {var x;} D^ var r;} void b() { }}
       class Z { }''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset - 1);
       expect(request.replacementLength, 1);
 
       assertSuggestLocalClass('X');
       assertSuggestLocalClass('Z');
-      assertLocalSuggestMethod('a', 'X', null);
-      assertLocalSuggestMethod('b', 'X', 'void');
+      assertSuggestLocalMethod('a', 'X', null);
+      assertSuggestLocalMethod('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
@@ skipping 611 matching lines @@
 
   test_FunctionExpression_body_function() {
     // Block  BlockFunctionBody  FunctionExpression
     addTestSource('''
       void bar() { }
       String foo(List args) {x.then((R b) {^});}''');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
-      var f = assertSuggestLocalFunction('foo', 'String', false);
+      var f = assertSuggestLocalFunction('foo', 'String', deprecated: false);
       if (f != null) {
         expect(f.element.isPrivate, isFalse);
       }
       assertSuggestLocalFunction('bar', 'void');
       assertSuggestParameter('args', 'List');
       assertSuggestParameter('b', 'R');
       assertSuggestImportedClass('Object');
     });
   }
 
@@ skipping 224 matching lines @@
       expect(request.replacementLength, 0);
       CompletionSuggestion methodA = assertSuggestLocalMethod('a', 'A', 'Z');
       if (methodA != null) {
         expect(methodA.element.isDeprecated, isFalse);
         expect(methodA.element.isPrivate, isFalse);
       }
       CompletionSuggestion getterF = assertSuggestLocalGetter(
           'f',
           'X',
           relevance: COMPLETION_RELEVANCE_LOW,
-          isDeprecated: true);
+          deprecated: true);
       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((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       CompletionSuggestion methodA = assertSuggestLocalMethod('_a', 'A', 'Z');
       if (methodA != null) {
         expect(methodA.element.isDeprecated, isFalse);
         expect(methodA.element.isPrivate, isTrue);
       }
       CompletionSuggestion getterF = assertSuggestLocalField(
           'f',
           'X',
           relevance: COMPLETION_RELEVANCE_LOW,
-          isDeprecated: true);
+          deprecated: true);
       if (getterF != null) {
         expect(getterF.element.isDeprecated, isTrue);
         expect(getterF.element.isPrivate, isFalse);
         expect(getterF.element.parameters, isNull);
       }
       CompletionSuggestion getterG = assertSuggestLocalField('_g', null);
       if (getterG != null) {
         expect(getterG.element.isDeprecated, isFalse);
         expect(getterG.element.isPrivate, isTrue);
         expect(getterF.element.parameters, isNull);
       }
       assertSuggestImportedClass('bool');
     });
   }
 
   test_MethodDeclaration_parameters_named() {
     // Block  BlockFunctionBody  MethodDeclaration
     addTestSource('class A {@deprecated Z a(X x, _, b, {y: boo}) {^}}');
     computeFast();
     return computeFull((bool result) {
       expect(request.replacementOffset, completionOffset);
       expect(request.replacementLength, 0);
       CompletionSuggestion methodA = assertSuggestLocalMethod(
           'a',
           'A',
           'Z',
           relevance: COMPLETION_RELEVANCE_LOW,
-          isDeprecated: true);
+          deprecated: true);
       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 523 matching lines @@
       assertNotSuggested('bar2');
       assertNotSuggested('_B');
       assertSuggestLocalClass('Y');
       assertSuggestLocalClass('C');
       assertSuggestLocalVariable('f', null);
       assertNotSuggested('x');
       assertNotSuggested('e');
     });
   }
 }