Change code completion relevance from CompletionRelevance.LOW/DEFAULT/HIGH to int

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 80 matching lines @@
         (CompletionSuggestion cs) => cs.completion == completion,
         orElse: () => null);
     if (suggestion != null) {
       failedCompletion('did not expect completion: $completion\n  $suggestion');
     }
     return null;
   }
 
   CompletionSuggestion assertSuggest(String completion,
       {CompletionSuggestionKind csKind: CompletionSuggestionKind.INVOCATION,
-      CompletionRelevance relevance: CompletionRelevance.DEFAULT,
+      int relevance: COMPLETION_RELEVANCE_DEFAULT,
       protocol.ElementKind elemKind: null, bool isDeprecated: false, bool isPotential:
       false}) {
     CompletionSuggestion cs =
         getSuggest(completion: completion, csKind: csKind, elemKind: elemKind);
     if (cs == null) {
       failedCompletion('expected $completion $csKind', request.suggestions);
     }
     expect(cs.kind, equals(csKind));
     if (isDeprecated) {
-      expect(cs.relevance, equals(CompletionRelevance.LOW));
+      expect(cs.relevance, equals(COMPLETION_RELEVANCE_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;
   }
 
   void assertSuggestArgumentList(List<String> paramNames,
       List<String> paramTypes) {
     CompletionSuggestionKind csKind = CompletionSuggestionKind.ARGUMENT_LIST;
     CompletionSuggestion cs = getSuggest(csKind: csKind);
     if (cs == null) {
       failedCompletion('expected completion $csKind', request.suggestions);
     }
     assertSuggestArgumentList_params(
         paramNames,
         paramTypes,
         cs.parameterNames,
         cs.parameterTypes);
-    expect(cs.relevance, CompletionRelevance.HIGH);
+    expect(cs.relevance, COMPLETION_RELEVANCE_HIGH);
   }
 
   void assertSuggestArgumentList_params(List<String> expectedNames,
       List<String> expectedTypes, List<String> actualNames,
       List<String> actualTypes) {
     if (actualNames != null &&
         actualNames.length == expectedNames.length &&
         actualTypes != null &&
         actualTypes.length == expectedTypes.length) {
       int index = 0;
@@ skipping 11 matching lines @@
     StringBuffer msg = new StringBuffer();
     msg.writeln('Argument list not the same');
     msg.writeln('  Expected names: $expectedNames');
     msg.writeln('           found: $actualNames');
     msg.writeln('  Expected types: $expectedTypes');
     msg.writeln('           found: $actualTypes');
     fail(msg.toString());
   }
 
   CompletionSuggestion assertSuggestClass(String name,
-      [CompletionRelevance relevance = CompletionRelevance.DEFAULT,
+      [int relevance = COMPLETION_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     CompletionSuggestion cs =
         assertSuggest(name, csKind: kind, relevance: relevance);
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.CLASS));
     expect(element.name, equals(name));
     expect(element.parameters, isNull);
     expect(element.returnType, isNull);
     return cs;
   }
 
   CompletionSuggestion assertSuggestClassTypeAlias(String name,
-      [CompletionRelevance relevance = CompletionRelevance.DEFAULT,
+      [int relevance = COMPLETION_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     CompletionSuggestion cs =
         assertSuggest(name, csKind: kind, relevance: relevance);
     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);
     return cs;
   }
 
   CompletionSuggestion assertSuggestField(String name,
-      {CompletionRelevance relevance: CompletionRelevance.DEFAULT,
+      {int relevance: COMPLETION_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION,
       bool isDeprecated: false}) {
     CompletionSuggestion cs = assertSuggest(
         name,
         csKind: kind,
         relevance: relevance,
         elemKind: protocol.ElementKind.FIELD,
         isDeprecated: isDeprecated);
     expect(cs.returnType, isNull);
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.FIELD));
     expect(element.name, equals(name));
     expect(element.parameters, isNull);
     // TODO (danrubel) return type should be null and there should be
     // something that represents the type of the field
     if (element.returnType != null) {
       expect(element.returnType, 'dynamic');
     }
     return cs;
   }
 
   CompletionSuggestion assertSuggestFunction(String name, String returnType,
-      bool isDeprecated, [CompletionRelevance relevance = CompletionRelevance.DEFAULT,
+      bool isDeprecated, [int relevance = COMPLETION_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     CompletionSuggestion cs = assertSuggest(
         name,
         csKind: kind,
         relevance: relevance,
         isDeprecated: isDeprecated);
     expect(cs.returnType, equals(returnType));
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.FUNCTION));
     expect(element.name, equals(name));
     expect(element.isDeprecated, equals(isDeprecated));
     String param = element.parameters;
     expect(param, isNotNull);
     expect(param[0], equals('('));
     expect(param[param.length - 1], equals(')'));
     expect(
         element.returnType,
         equals(returnType != null ? returnType : 'dynamic'));
     return cs;
   }
 
   CompletionSuggestion assertSuggestFunctionTypeAlias(String name,
-      String returnType, bool isDeprecated, [CompletionRelevance relevance =
-      CompletionRelevance.DEFAULT, CompletionSuggestionKind kind =
+      String returnType, bool isDeprecated, [int relevance =
+      COMPLETION_RELEVANCE_DEFAULT, CompletionSuggestionKind kind =
       CompletionSuggestionKind.INVOCATION]) {
     CompletionSuggestion cs = assertSuggest(
         name,
         csKind: kind,
         relevance: relevance,
         isDeprecated: isDeprecated);
     expect(cs.returnType, equals(returnType));
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.FUNCTION_TYPE_ALIAS));
     expect(element.name, equals(name));
     expect(element.isDeprecated, equals(isDeprecated));
     // TODO (danrubel) Determine why params are null
 //    String param = element.parameters;
 //    expect(param, isNotNull);
 //    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,
+      {int relevance: COMPLETION_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION,
       bool isDeprecated: false}) {
     CompletionSuggestion cs = assertSuggest(
         name,
         csKind: kind,
         relevance: relevance,
         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,
         equals(returnType != null ? returnType : 'dynamic'));
     return cs;
   }
 
   CompletionSuggestion assertSuggestLibraryPrefix(String prefix,
-      [CompletionRelevance relevance = CompletionRelevance.DEFAULT,
+      [int relevance = COMPLETION_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     // Library prefix should only be suggested by ImportedComputer
     if (computer is ImportedComputer) {
       CompletionSuggestion cs =
           assertSuggest(prefix, csKind: kind, relevance: relevance);
       protocol.Element element = cs.element;
       expect(element, isNotNull);
       expect(element.kind, equals(protocol.ElementKind.LIBRARY));
       expect(element.parameters, isNull);
       expect(element.returnType, isNull);
       return cs;
     } else {
       return assertNotSuggested(prefix);
     }
   }
 
   CompletionSuggestion assertSuggestLocalVariable(String name,
-      String returnType, [CompletionRelevance relevance = CompletionRelevance.DEFAULT,
+      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, equals(returnType));
       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,
           equals(returnType != null ? returnType : 'dynamic'));
       return cs;
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestMethod(String name, String declaringType,
-      String returnType, [CompletionRelevance relevance = CompletionRelevance.DEFAULT,
+      String returnType, [int relevance = COMPLETION_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     CompletionSuggestion cs =
         assertSuggest(name, csKind: kind, relevance: relevance);
     expect(cs.declaringType, equals(declaringType));
     expect(cs.returnType, equals(returnType));
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.METHOD));
     expect(element.name, equals(name));
     String param = element.parameters;
     expect(param, isNotNull);
     expect(param[0], equals('('));
     expect(param[param.length - 1], equals(')'));
     expect(
         element.returnType,
         equals(returnType != null ? returnType : 'dynamic'));
     return cs;
   }
 
   CompletionSuggestion assertSuggestNamedConstructor(String name,
-      String returnType, [CompletionRelevance relevance = CompletionRelevance.DEFAULT,
+      String returnType, [int relevance = COMPLETION_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     if (computer is InvocationComputer) {
       CompletionSuggestion cs =
           assertSuggest(name, csKind: kind, relevance: relevance);
       protocol.Element element = cs.element;
       expect(element, isNotNull);
       expect(element.kind, equals(protocol.ElementKind.CONSTRUCTOR));
       expect(element.name, equals(name));
       String param = element.parameters;
       expect(param, isNotNull);
       expect(param[0], equals('('));
       expect(param[param.length - 1], equals(')'));
       expect(element.returnType, equals(returnType));
       return cs;
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestParameter(String name, String returnType,
-      [CompletionRelevance relevance = CompletionRelevance.DEFAULT,
+      [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, equals(returnType));
       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);
     }
   }
 
   CompletionSuggestion assertSuggestSetter(String name,
-      [CompletionRelevance relevance = CompletionRelevance.DEFAULT,
+      [int relevance = COMPLETION_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     CompletionSuggestion cs = assertSuggest(
         name,
         csKind: kind,
         relevance: relevance,
         elemKind: protocol.ElementKind.SETTER);
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.SETTER));
     expect(element.name, equals(name));
     // TODO (danrubel) assert setter param
     //expect(element.parameters, isNull);
     // TODO (danrubel) it would be better if this was always null
     if (element.returnType != null) {
       expect(element.returnType, 'dynamic');
     }
     return cs;
   }
 
   CompletionSuggestion assertSuggestTopLevelVar(String name, String returnType,
-      [CompletionRelevance relevance = CompletionRelevance.DEFAULT,
+      [int relevance = COMPLETION_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     CompletionSuggestion cs =
         assertSuggest(name, csKind: kind, relevance: relevance);
     expect(cs.returnType, equals(returnType));
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.TOP_LEVEL_VARIABLE));
     expect(element.name, equals(name));
     expect(element.parameters, isNull);
     //TODO (danrubel) return type level variable 'type' but not as 'returnType'
 //    expect(
 //        element.returnType,
 //        equals(returnType != null ? returnType : 'dynamic'));
     return cs;
   }
 
   void assertSuggestTopLevelVarGetterSetter(String name, String returnType,
-      [CompletionRelevance relevance = CompletionRelevance.DEFAULT]) {
+      [int relevance = COMPLETION_RELEVANCE_DEFAULT]) {
     if (computer is ImportedComputer) {
       assertSuggestGetter(name, returnType);
       assertSuggestSetter(name);
     } else {
       assertNotSuggested(name);
     }
   }
 
   bool computeFast() {
     _computeFastCalled = true;
@@ skipping 137 matching lines @@
 
   /**
    * 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, [CompletionRelevance relevance =
-      CompletionRelevance.DEFAULT]) {
+      String declaringType, String returnType, [int relevance =
+      COMPLETION_RELEVANCE_DEFAULT]) {
     if (computer is LocalComputer) {
       return assertSuggestMethod(name, declaringType, returnType, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestImportedClass(String name,
-      [CompletionRelevance relevance = CompletionRelevance.DEFAULT,
+      [int relevance = COMPLETION_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     if (computer is ImportedComputer) {
       return assertSuggestClass(name, relevance, kind);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestImportedField(String name,
-      [CompletionRelevance relevance = CompletionRelevance.DEFAULT]) {
+      [int relevance = COMPLETION_RELEVANCE_DEFAULT]) {
     if (computer is ImportedComputer) {
       return assertSuggestField(name, relevance: relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestImportedFunction(String name,
-      String returnType, [bool isDeprecated = false, CompletionRelevance relevance =
-      CompletionRelevance.DEFAULT, CompletionSuggestionKind kind =
+      String returnType, [bool isDeprecated = false, int relevance =
+      COMPLETION_RELEVANCE_DEFAULT, CompletionSuggestionKind kind =
       CompletionSuggestionKind.INVOCATION]) {
     if (computer is ImportedComputer) {
       return assertSuggestFunction(
           name,
           returnType,
           isDeprecated,
           relevance,
           kind);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestImportedFunctionTypeAlias(String name,
-      String returnType, [bool isDeprecated = false, CompletionRelevance relevance =
-      CompletionRelevance.DEFAULT, CompletionSuggestionKind kind =
+      String returnType, [bool isDeprecated = false, int relevance =
+      COMPLETION_RELEVANCE_DEFAULT, CompletionSuggestionKind kind =
       CompletionSuggestionKind.INVOCATION]) {
     if (computer is ImportedComputer) {
       return assertSuggestFunctionTypeAlias(
           name,
           returnType,
           isDeprecated,
           relevance,
           kind);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestImportedGetter(String name,
-      String returnType, [CompletionRelevance relevance =
-      CompletionRelevance.DEFAULT]) {
+      String returnType, [int relevance =
+      COMPLETION_RELEVANCE_DEFAULT]) {
     if (computer is ImportedComputer) {
       return assertSuggestGetter(name, returnType, relevance: relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestImportedMethod(String name,
-      String declaringType, String returnType, [CompletionRelevance relevance =
-      CompletionRelevance.DEFAULT]) {
+      String declaringType, String returnType, [int relevance =
+      COMPLETION_RELEVANCE_DEFAULT]) {
     if (computer is ImportedComputer) {
       return assertSuggestMethod(name, declaringType, returnType, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestImportedSetter(String name,
-      [CompletionRelevance relevance = CompletionRelevance.DEFAULT]) {
+      [int relevance = COMPLETION_RELEVANCE_DEFAULT]) {
     if (computer is ImportedComputer) {
       return assertSuggestSetter(name, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestImportedTopLevelVar(String name,
-      String returnType, [CompletionRelevance relevance = CompletionRelevance.DEFAULT,
+      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);
     }
   }
 
   CompletionSuggestion assertSuggestInvocationClass(String name,
-      [CompletionRelevance relevance = CompletionRelevance.DEFAULT]) {
+      [int relevance = COMPLETION_RELEVANCE_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, {int relevance: COMPLETION_RELEVANCE_DEFAULT,
       bool isDeprecated: false}) {
     if (computer is InvocationComputer) {
       return assertSuggestGetter(
           name,
           returnType,
           relevance: relevance,
           isDeprecated: isDeprecated);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestInvocationMethod(String name,
-      String declaringType, String returnType, [CompletionRelevance relevance =
-      CompletionRelevance.DEFAULT]) {
+      String declaringType, String returnType, [int relevance =
+      COMPLETION_RELEVANCE_DEFAULT]) {
     if (computer is InvocationComputer) {
       return assertSuggestMethod(name, declaringType, returnType, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestInvocationSetter(String name,
-      [CompletionRelevance relevance = CompletionRelevance.DEFAULT]) {
+      [int relevance = COMPLETION_RELEVANCE_DEFAULT]) {
     if (computer is InvocationComputer) {
       return assertSuggestSetter(name);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestInvocationTopLevelVar(String name,
-      String returnType, [CompletionRelevance relevance =
-      CompletionRelevance.DEFAULT]) {
+      String returnType, [int relevance =
+      COMPLETION_RELEVANCE_DEFAULT]) {
     if (computer is InvocationComputer) {
       return assertSuggestTopLevelVar(name, returnType, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestLocalClass(String name,
-      [CompletionRelevance relevance = CompletionRelevance.DEFAULT]) {
+      [int relevance = COMPLETION_RELEVANCE_DEFAULT]) {
     if (computer is LocalComputer) {
       return assertSuggestClass(name, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestLocalClassTypeAlias(String name,
-      [CompletionRelevance relevance = CompletionRelevance.DEFAULT]) {
+      [int relevance = COMPLETION_RELEVANCE_DEFAULT]) {
     if (computer is LocalComputer) {
       return assertSuggestClassTypeAlias(name, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestLocalField(String name,
-      [CompletionRelevance relevance = CompletionRelevance.DEFAULT]) {
+      [int relevance = COMPLETION_RELEVANCE_DEFAULT]) {
     if (computer is LocalComputer) {
       return assertSuggestField(name, relevance: relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestLocalFunction(String name,
-      String returnType, [bool isDeprecated = false, CompletionRelevance relevance =
-      CompletionRelevance.DEFAULT]) {
+      String returnType, [bool isDeprecated = false, int relevance =
+      COMPLETION_RELEVANCE_DEFAULT]) {
     if (computer is LocalComputer) {
       return assertSuggestFunction(name, returnType, isDeprecated, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestLocalFunctionTypeAlias(String name,
-      String returnType, [bool isDeprecated = false, CompletionRelevance relevance =
-      CompletionRelevance.DEFAULT]) {
+      String returnType, [bool isDeprecated = false, int relevance =
+      COMPLETION_RELEVANCE_DEFAULT]) {
     if (computer is LocalComputer) {
       return assertSuggestFunctionTypeAlias(
           name,
           returnType,
           isDeprecated,
           relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestLocalGetter(String name, String returnType,
-      [CompletionRelevance relevance = CompletionRelevance.DEFAULT]) {
+      [int relevance = COMPLETION_RELEVANCE_DEFAULT]) {
     if (computer is LocalComputer) {
       return assertSuggestGetter(name, returnType, relevance: relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestLocalMethod(String name,
-      String declaringType, String returnType, [CompletionRelevance relevance =
-      CompletionRelevance.DEFAULT]) {
+      String declaringType, String returnType, [int relevance =
+      COMPLETION_RELEVANCE_DEFAULT]) {
     if (computer is LocalComputer) {
       return assertSuggestMethod(name, declaringType, returnType, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestLocalSetter(String name,
-      [CompletionRelevance relevance = CompletionRelevance.DEFAULT]) {
+      [int relevance = COMPLETION_RELEVANCE_DEFAULT]) {
     if (computer is LocalComputer) {
       return assertSuggestSetter(name, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestLocalTopLevelVar(String name,
-      String returnType, [CompletionRelevance relevance =
-      CompletionRelevance.DEFAULT]) {
+      String returnType, [int relevance =
+      COMPLETION_RELEVANCE_DEFAULT]) {
     if (computer is LocalComputer) {
       return assertSuggestTopLevelVar(name, returnType, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestNonLocalClass(String name,
-      [CompletionRelevance relevance = CompletionRelevance.DEFAULT,
+      [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(
         assertFunction,
         fullAnalysis: fullAnalysis).then(assertCachedCompute);
   }
 
@@ skipping 332 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
       // but imported results are partially filtered
-      //assertSuggestImportedClass('D', CompletionRelevance.LOW);
+      //assertSuggestImportedClass('D', COMPLETION_RELEVANCE_LOW);
       //assertSuggestImportedFunction(
-      //    'D1', null, true, CompletionRelevance.LOW);
+      //    'D1', null, true, COMPLETION_RELEVANCE_LOW);
       assertSuggestLocalFunction('D2', 'Z');
       assertSuggestImportedClass('EE');
       // hidden element suggested as low relevance
-      //assertSuggestImportedClass('F', CompletionRelevance.LOW);
+      //assertSuggestImportedClass('F', COMPLETION_RELEVANCE_LOW);
       assertSuggestLibraryPrefix('g');
       assertNotSuggested('G');
-      //assertSuggestImportedClass('H', CompletionRelevance.LOW);
+      //assertSuggestImportedClass('H', COMPLETION_RELEVANCE_LOW);
       assertSuggestImportedClass('Object');
       assertSuggestImportedFunction('min', 'num', false);
       //assertSuggestImportedFunction(
       //    'max',
       //    'num',
       //    false,
-      //    CompletionRelevance.LOW);
+      //    COMPLETION_RELEVANCE_LOW);
       assertSuggestTopLevelVarGetterSetter('T1', 'String');
       assertNotSuggested('_T2');
-      //assertSuggestImportedTopLevelVar('T3', 'int', CompletionRelevance.LOW);
+      //assertSuggestImportedTopLevelVar('T3', 'int', COMPLETION_RELEVANCE_LOW);
       assertNotSuggested('_T4');
       assertSuggestLocalTopLevelVar('T5', 'int');
       assertSuggestLocalTopLevelVar('_T6', null);
       assertNotSuggested('==');
       assertSuggestLocalGetter('T7', 'String');
       assertSuggestLocalSetter('T8');
       assertSuggestLocalGetter('clog', 'int');
       assertSuggestLocalSetter('blog');
       // TODO (danrubel) suggest HtmlElement as low relevance
       assertNotSuggested('HtmlElement');
@@ skipping 39 matching lines @@
       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);
+      assertSuggestImportedClass('D', COMPLETION_RELEVANCE_LOW);
+      assertSuggestImportedFunction('D1', null, true, COMPLETION_RELEVANCE_LOW);
       assertSuggestLocalFunction('D2', 'Z');
       //assertSuggestImportedClass('EE');
       // hidden element suggested as low relevance
-      //assertSuggestImportedClass('F', CompletionRelevance.LOW);
+      //assertSuggestImportedClass('F', COMPLETION_RELEVANCE_LOW);
       //assertSuggestLibraryPrefix('g');
       assertNotSuggested('G');
-      //assertSuggestImportedClass('H', CompletionRelevance.LOW);
+      //assertSuggestImportedClass('H', COMPLETION_RELEVANCE_LOW);
       //assertSuggestImportedClass('Object');
       //assertSuggestImportedFunction('min', 'num', false);
       //assertSuggestImportedFunction(
       //    'max',
       //    'num',
       //    false,
-      //    CompletionRelevance.LOW);
+      //    COMPLETION_RELEVANCE_LOW);
       //assertSuggestTopLevelVarGetterSetter('T1', 'String');
       assertNotSuggested('_T2');
-      //assertSuggestImportedTopLevelVar('T3', 'int', CompletionRelevance.LOW);
+      //assertSuggestImportedTopLevelVar('T3', 'int', COMPLETION_RELEVANCE_LOW);
       assertNotSuggested('_T4');
       //assertSuggestLocalTopLevelVar('T5', 'int');
       //assertSuggestLocalTopLevelVar('_T6', null);
       assertNotSuggested('==');
       // TODO (danrubel) suggest HtmlElement as low relevance
       assertNotSuggested('HtmlElement');
     });
   }
 
   test_Block_inherited_imported() {
@@ skipping 164 matching lines @@
     addSource('/testB.dart', '''
       class B { }''');
     addTestSource('''
       import "testB.dart" as x;
       @deprecated class A {^}
       class _B {}
       A T;''');
     computeFast();
     return computeFull((bool result) {
       CompletionSuggestion suggestionA =
-          assertSuggestLocalClass('A', CompletionRelevance.LOW);
+          assertSuggestLocalClass('A', COMPLETION_RELEVANCE_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 536 matching lines @@
     // Block  BlockFunctionBody  MethodDeclaration
     addTestSource('class A {@deprecated X get f => 0; Z a() {^} get _g => 1;}');
     computeFast();
     return computeFull((bool result) {
       CompletionSuggestion methodA = assertSuggestLocalMethod('a', 'A', 'Z');
       if (methodA != null) {
         expect(methodA.element.isDeprecated, isFalse);
         expect(methodA.element.isPrivate, isFalse);
       }
       CompletionSuggestion getterF =
-          assertSuggestLocalGetter('f', 'X', CompletionRelevance.LOW);
+          assertSuggestLocalGetter('f', 'X', COMPLETION_RELEVANCE_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((bool result) {
       CompletionSuggestion methodA = assertSuggestLocalMethod('_a', 'A', 'Z');
       if (methodA != null) {
         expect(methodA.element.isDeprecated, isFalse);
         expect(methodA.element.isPrivate, isTrue);
       }
       CompletionSuggestion getterF =
-          assertSuggestLocalField('f', CompletionRelevance.LOW);
+          assertSuggestLocalField('f', COMPLETION_RELEVANCE_LOW);
       if (getterF != null) {
         expect(getterF.element.isDeprecated, isTrue);
         expect(getterF.element.isPrivate, isFalse);
         expect(getterF.element.parameters, isNull);
       }
       CompletionSuggestion getterG = assertSuggestLocalField('_g');
       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) {
       CompletionSuggestion methodA =
-          assertSuggestLocalMethod('a', 'A', 'Z', CompletionRelevance.LOW);
+          assertSuggestLocalMethod('a', 'A', 'Z', COMPLETION_RELEVANCE_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 487 matching lines @@
       assertNotSuggested('bar2');
       assertNotSuggested('_B');
       assertSuggestLocalClass('Y');
       assertSuggestLocalClass('C');
       assertSuggestLocalVariable('f', null);
       assertNotSuggested('x');
       assertNotSuggested('e');
     });
   }
 }