Refactor CompletionSuggestionKind

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;
+import 'package:analysis_server/src/protocol.dart' hide Element, ElementKind;
 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';
@@ skipping 43 matching lines @@
     CompletionSuggestion suggestion = request.suggestions.firstWhere(
         (cs) => cs.completion == completion,
         orElse: () => null);
     if (suggestion != null) {
       _failedCompletion(
           'did not expect completion: $completion\n  $suggestion');
     }
     return null;
   }
 
-  CompletionSuggestion assertSuggest(CompletionSuggestionKind kind,
-      String completion, [CompletionRelevance relevance = CompletionRelevance.DEFAULT,
-      bool isDeprecated = false, bool isPotential = false]) {
+  CompletionSuggestion assertSuggest(String completion,
+      {CompletionSuggestionKind csKind: CompletionSuggestionKind.INVOCATION,
+      CompletionRelevance relevance: CompletionRelevance.DEFAULT,
+      protocol.ElementKind elemKind: null, bool isDeprecated: false, bool isPotential:
+      false}) {
     CompletionSuggestion cs;
     request.suggestions.forEach((s) {
-      if (s.completion == completion && s.kind == kind) {
-        if (cs == null) {
-          cs = s;
-        } else {
-          _failedCompletion(
-              'expected exactly one $completion',
-              request.suggestions.where((s) => s.completion == completion));
+      if (s.completion == completion && s.kind == csKind) {
+        protocol.Element element = s.element;
+        if (elemKind == null || (element != null && elemKind == element.kind)) {
+          if (cs == null) {
+            cs = s;
+          } else {
+            _failedCompletion(
+                'expected exactly one $completion',
+                request.suggestions.where((s) => s.completion == completion));
+          }
         }
       }
     });
     if (cs == null) {
-      _failedCompletion('expected $completion $kind', request.suggestions);
+      _failedCompletion('expected $completion $csKind', request.suggestions);
     }
-    expect(cs.kind, equals(kind));
+    expect(cs.kind, equals(csKind));
     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]) {
+      [CompletionRelevance relevance = CompletionRelevance.DEFAULT,
+      CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     CompletionSuggestion cs =
-        assertSuggest(CompletionSuggestionKind.CLASS, name, relevance);
+        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]) {
+      [CompletionRelevance relevance = CompletionRelevance.DEFAULT,
+      CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     CompletionSuggestion cs =
-        assertSuggest(CompletionSuggestionKind.CLASS_ALIAS, name, relevance);
+        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 assertSuggestFunction(String name, String returnType,
-      bool isDeprecated, [CompletionRelevance relevance =
-      CompletionRelevance.DEFAULT]) {
+      bool isDeprecated, [CompletionRelevance relevance = CompletionRelevance.DEFAULT,
+      CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     CompletionSuggestion cs = assertSuggest(
-        CompletionSuggestionKind.FUNCTION,
         name,
-        relevance,
-        isDeprecated);
+        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]) {
+      CompletionRelevance.DEFAULT, CompletionSuggestionKind kind =
+      CompletionSuggestionKind.INVOCATION]) {
     CompletionSuggestion cs = assertSuggest(
-        CompletionSuggestionKind.FUNCTION_TYPE_ALIAS,
         name,
-        relevance,
-        isDeprecated);
+        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]) {
-    CompletionSuggestion cs =
-        assertSuggest(CompletionSuggestionKind.GETTER, name, relevance);
+      [CompletionRelevance relevance = CompletionRelevance.DEFAULT,
+      CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
+    CompletionSuggestion cs = assertSuggest(
+        name,
+        csKind: kind,
+        relevance: relevance,
+        elemKind: protocol.ElementKind.GETTER);
     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]) {
+      [CompletionRelevance relevance = CompletionRelevance.DEFAULT,
+      CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     // Library prefix should only be suggested by ImportedComputer
     if (computer is ImportedComputer) {
       CompletionSuggestion cs =
-          assertSuggest(CompletionSuggestionKind.LIBRARY_PREFIX, prefix, relevance);
+          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, [CompletionRelevance relevance = CompletionRelevance.DEFAULT,
+      CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     // Local variables should only be suggested by LocalComputer
     if (computer is LocalComputer) {
       CompletionSuggestion cs =
-          assertSuggest(CompletionSuggestionKind.LOCAL_VARIABLE, name, relevance);
+          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, [CompletionRelevance relevance = CompletionRelevance.DEFAULT,
+      CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     CompletionSuggestion cs =
-        assertSuggest(CompletionSuggestionKind.METHOD, name, relevance);
+        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, [CompletionRelevance relevance = CompletionRelevance.DEFAULT,
+      CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     if (computer is InvocationComputer) {
       CompletionSuggestion cs =
-          assertSuggest(CompletionSuggestionKind.CONSTRUCTOR, name, relevance);
+          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]) {
+      [CompletionRelevance relevance = CompletionRelevance.DEFAULT,
+      CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     // Parameters should only be suggested by LocalComputer
     if (computer is LocalComputer) {
       CompletionSuggestion cs =
-          assertSuggest(CompletionSuggestionKind.PARAMETER, name, relevance);
+          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]) {
-    CompletionSuggestion cs =
-        assertSuggest(CompletionSuggestionKind.SETTER, name, relevance);
+      [CompletionRelevance relevance = CompletionRelevance.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);
     expect(element.returnType, isNull);
     return cs;
   }
 
   CompletionSuggestion assertSuggestTopLevelVar(String name, String returnType,
-      [CompletionRelevance relevance = CompletionRelevance.DEFAULT]) {
+      [CompletionRelevance relevance = CompletionRelevance.DEFAULT,
+      CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     CompletionSuggestion cs =
-        assertSuggest(CompletionSuggestionKind.TOP_LEVEL_VARIABLE, name, relevance);
+        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'));
@@ skipping 114 matching lines @@
       String declaringType, String returnType, [CompletionRelevance relevance =
       CompletionRelevance.DEFAULT]) {
     if (computer is LocalComputer) {
       return assertSuggestMethod(name, declaringType, returnType, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestImportedClass(String name,
-      [CompletionRelevance relevance = CompletionRelevance.DEFAULT]) {
+      [CompletionRelevance relevance = CompletionRelevance.DEFAULT,
+      CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     if (computer is ImportedComputer) {
-      return assertSuggestClass(name, relevance);
+      return assertSuggestClass(name, relevance, kind);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestImportedFunction(String name,
       String returnType, [bool isDeprecated = false, CompletionRelevance relevance =
-      CompletionRelevance.DEFAULT]) {
+      CompletionRelevance.DEFAULT, CompletionSuggestionKind kind =
+      CompletionSuggestionKind.INVOCATION]) {
     if (computer is ImportedComputer) {
-      return assertSuggestFunction(name, returnType, isDeprecated, relevance);
+      return assertSuggestFunction(
+          name,
+          returnType,
+          isDeprecated,
+          relevance,
+          kind);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestImportedFunctionTypeAlias(String name,
       String returnType, [bool isDeprecated = false, CompletionRelevance relevance =
-      CompletionRelevance.DEFAULT]) {
+      CompletionRelevance.DEFAULT, CompletionSuggestionKind kind =
+      CompletionSuggestionKind.INVOCATION]) {
     if (computer is ImportedComputer) {
       return assertSuggestFunctionTypeAlias(
           name,
           returnType,
           isDeprecated,
-          relevance);
+          relevance,
+          kind);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestImportedGetter(String name,
       String returnType, [CompletionRelevance relevance =
       CompletionRelevance.DEFAULT]) {
     if (computer is ImportedComputer) {
       return assertSuggestGetter(name, returnType, 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);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestImportedTopLevelVar(String name,
-      String returnType, [CompletionRelevance relevance =
-      CompletionRelevance.DEFAULT]) {
+      String returnType, [CompletionRelevance relevance = CompletionRelevance.DEFAULT,
+      CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     if (computer is ImportedComputer) {
-      return assertSuggestTopLevelVar(name, returnType, relevance);
+      return assertSuggestTopLevelVar(name, returnType, relevance, kind);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestInvocationClass(String name,
       [CompletionRelevance relevance = CompletionRelevance.DEFAULT]) {
     if (computer is InvocationComputer) {
       return assertSuggestClass(name, relevance);
     } else {
@@ skipping 456 matching lines @@
       class PB { }''');
     addSource('/testCD.dart', '''
       class C { }
       class D { }''');
     addTestSource('''
       import "/testAB.dart" hide ^;
       import "/testCD.dart";
       class X {}''');
     computeFast();
     return computeFull(true).then((_) {
-      assertSuggestImportedClass('A');
-      assertSuggestImportedClass('B');
-      assertSuggestImportedClass('PB');
-      assertSuggestImportedTopLevelVar('T1', null);
-      assertSuggestImportedFunction('F1', 'PB');
+      assertSuggestImportedClass(
+          'A',
+          CompletionRelevance.DEFAULT,
+          CompletionSuggestionKind.IDENTIFIER);
+      assertSuggestImportedClass(
+          'B',
+          CompletionRelevance.DEFAULT,
+          CompletionSuggestionKind.IDENTIFIER);
+      assertSuggestImportedClass(
+          'PB',
+          CompletionRelevance.DEFAULT,
+          CompletionSuggestionKind.IDENTIFIER);
+      assertSuggestImportedTopLevelVar(
+          'T1',
+          null,
+          CompletionRelevance.DEFAULT,
+          CompletionSuggestionKind.IDENTIFIER);
+      assertSuggestImportedFunction(
+          'F1',
+          'PB',
+          false,
+          CompletionRelevance.DEFAULT,
+          CompletionSuggestionKind.IDENTIFIER);
       assertNotSuggested('C');
       assertNotSuggested('D');
       assertNotSuggested('X');
       assertNotSuggested('Object');
     });
   }
 
   test_Combinator_show() {
     // SimpleIdentifier  HideCombinator  ImportDirective
     addSource('/testAB.dart', '''
@@ skipping 10 matching lines @@
       class PB { }''');
     addSource('/testCD.dart', '''
       class C { }
       class D { }''');
     addTestSource('''
       import "/testAB.dart" show ^;
       import "/testCD.dart";
       class X {}''');
     computeFast();
     return computeFull(true).then((_) {
-      assertSuggestImportedClass('A');
-      assertSuggestImportedClass('B');
-      assertSuggestImportedClass('PB');
-      assertSuggestImportedTopLevelVar('T1', null);
-      assertSuggestImportedFunction('F1', 'PB');
-      assertSuggestImportedClass('Clz');
-      assertSuggestImportedFunctionTypeAlias('F2', null);
+      assertSuggestImportedClass(
+          'A',
+          CompletionRelevance.DEFAULT,
+          CompletionSuggestionKind.IDENTIFIER);
+      assertSuggestImportedClass(
+          'B',
+          CompletionRelevance.DEFAULT,
+          CompletionSuggestionKind.IDENTIFIER);
+      assertSuggestImportedClass(
+          'PB',
+          CompletionRelevance.DEFAULT,
+          CompletionSuggestionKind.IDENTIFIER);
+      assertSuggestImportedTopLevelVar(
+          'T1',
+          null,
+          CompletionRelevance.DEFAULT,
+          CompletionSuggestionKind.IDENTIFIER);
+      assertSuggestImportedFunction(
+          'F1',
+          'PB',
+          false,
+          CompletionRelevance.DEFAULT,
+          CompletionSuggestionKind.IDENTIFIER);
+      assertSuggestImportedClass(
+          'Clz',
+          CompletionRelevance.DEFAULT,
+          CompletionSuggestionKind.IDENTIFIER);
+      assertSuggestImportedFunctionTypeAlias(
+          'F2',
+          null,
+          false,
+          CompletionRelevance.DEFAULT,
+          CompletionSuggestionKind.IDENTIFIER);
       assertNotSuggested('C');
       assertNotSuggested('D');
       assertNotSuggested('X');
       assertNotSuggested('Object');
     });
   }
 
   test_ConstructorName_importedClass() {
     // SimpleIdentifier  PrefixedIdentifier  TypeName  ConstructorName
     // InstanceCreationExpression
@@ skipping 760 matching lines @@
       assertNotSuggested('bar2');
       assertNotSuggested('_B');
       assertSuggestLocalClass('Y');
       assertSuggestLocalClass('C');
       assertSuggestLocalVariable('f', null);
       assertNotSuggested('x');
       assertNotSuggested('e');
     });
   }
 }