more progress implementing analysis server code completion

pkg/analysis_services/lib/src/generated/completion.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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library services.completion;
 
 import 'dart:collection';
 import 'package:analyzer/src/generated/java_core.dart' hide StringUtils;
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/java_io.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/error.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'stubs.dart';
 import 'util.dart';
 
+import '../../completion/completion_suggestion.dart';
+
 class AstNodeClassifier_CompletionEngine_typeOf extends CompletionEngine_AstNodeClassifier {
   final CompletionEngine CompletionEngine_this;
 
   List<DartType> result;
 
   AstNodeClassifier_CompletionEngine_typeOf(this.CompletionEngine_this, this.result) : super();
 
   @override
   Object visitPrefixedIdentifier(PrefixedIdentifier node) => visitSimpleIdentifier(node.identifier);
 
@@ skipping 116 matching lines @@
   }
 
   void _analyzeDeclarationName(VariableDeclaration varDecl) {
     // We might want to propose multiple names for a declaration based on types someday.
     // For now, just use whatever is already there.
     SimpleIdentifier identifier = varDecl.name;
     _filter = _createFilter(identifier);
     VariableDeclarationList varList = varDecl.parent as VariableDeclarationList;
     TypeName type = varList.type;
     if (identifier.length > 0) {
-      _pName3(identifier.name, ProposalKind.VARIABLE);
+      _pName3(identifier.name, CompletionSuggestionKind.VARIABLE);
     }
     if (type == null) {
       if (varList.keyword == null) {
         // Interpret as the type name of a typed variable declaration { DivE!; }
         _analyzeLocalName(identifier);
       }
     } else {
       _pParamName(type.name.name.toLowerCase());
     }
   }
 
   void _analyzeDirectAccess(DartType receiverType, SimpleIdentifier completionNode) {
     if (receiverType != null) {
       // Complete this.!y where this is absent
       Element rcvrTypeElem = receiverType.element;
       if (receiverType.isDynamic) {
         rcvrTypeElem = objectClassElement;
       }
       if (rcvrTypeElem is ClassElement) {
         _directAccess(rcvrTypeElem as ClassElement, completionNode);
       }
     }
   }
 
   void _analyzeImmediateField(SimpleIdentifier fieldName) {
     _filter = _createFilter(fieldName);
     ClassDeclaration classDecl = fieldName.getAncestor((node) => node is ClassDeclaration);
     ClassElement classElement = classDecl.element;
     for (FieldElement field in classElement.fields) {
-      _pName3(field.displayName, ProposalKind.FIELD);
+      _pName3(field.displayName, CompletionSuggestionKind.FIELD);
     }
   }
 
   void _analyzeLiteralReference(BooleanLiteral literal) {
     //    state.setContext(literal);
     Ident ident = _createIdent(literal.parent);
     ident.token = literal.literal;
     _filter = _createFilter(ident);
     _analyzeLocalName(ident);
   }
@@ skipping 59 matching lines @@
       // filter by name
       if (_filterDisallows(parameterElement)) {
         continue;
       }
       // may be already used
       String parameterName = parameterElement.name;
       if (usedNames.contains(parameterName)) {
         continue;
       }
       // OK, add proposal
-      CompletionProposal prop = _createProposal4(ProposalKind.NAMED_ARGUMENT);
+      CompletionProposal prop = _createProposal4(CompletionSuggestionKind.NAMED_ARGUMENT);
       prop.setCompletion(parameterName);
       prop.setParameterName(parameterName);
       prop.setParameterType(parameterElement.type.displayName);
       prop.setLocation(identifier.offset);
       prop.setReplacementLength(identifier.length);
       prop.setRelevance(CompletionProposal.RELEVANCE_HIGH);
       _requestor.accept(prop);
     }
   }
 
@@ skipping 29 matching lines @@
     }
     // show current parameter
     int argIndex = args.arguments.indexOf(identifier);
     if (argIndex == -1) {
       argIndex = 0;
     }
     if (argIndex >= 0 && argIndex < parameters.length) {
       ParameterElement parameter = parameters[argIndex];
       if (parameter.parameterKind != ParameterKind.NAMED) {
         String parameterName = parameter.displayName;
-        CompletionProposal prop = _createProposal4(ProposalKind.OPTIONAL_ARGUMENT);
+        CompletionProposal prop = _createProposal4(CompletionSuggestionKind.OPTIONAL_ARGUMENT);
         prop.setCompletion(parameterName);
         prop.setParameterName(parameterName);
         prop.setParameterType(parameter.type.displayName);
         prop.setLocation(identifier.offset);
         prop.setReplacementLength(identifier.length);
         prop.setRelevance(CompletionProposal.RELEVANCE_HIGH);
         _requestor.accept(prop);
       }
     }
   }
@@ skipping 247 matching lines @@
             }
           }
         }
       }
     }
     // add known package: URIs
     for (String uri in packageUris) {
       if (_filterDisallows2(uri)) {
         continue;
       }
-      CompletionProposal prop = _createProposal4(ProposalKind.IMPORT);
+      CompletionProposal prop = _createProposal4(CompletionSuggestionKind.IMPORT);
       prop.setCompletion(uri);
       // put "lib" before "lib/src"
       if (!uri.contains("/src/")) {
         prop.setRelevance(CompletionProposal.RELEVANCE_HIGH);
       }
       // done
       _requestor.accept(prop);
     }
   }
 
@@ skipping 60 matching lines @@
       if (library.isImplementation) {
         continue;
       }
       // standard libraries name name starting with "dart:"
       name = StringUtils.removeStart(name, "dart:");
       // ignore private libraries
       if (Identifier.isPrivateName(name)) {
         continue;
       }
       // add with "dart:" prefix
-      _pName3("dart:${name}", ProposalKind.IMPORT);
+      _pName3("dart:${name}", CompletionSuggestionKind.IMPORT);
     }
   }
 
   void _operatorAccess(Expression expr, SimpleIdentifier identifier) {
     _state._requiresOperators();
     _analyzePrefixedAccess(expr, identifier);
   }
 
   void _prefixedAccess(InterfaceType type, bool forSuper, SimpleIdentifier identifier) {
     // Complete identifier when it refers to field or method in classElement.
@@ skipping 81 matching lines @@
     if (type != null) {
       prop.setReturnType(type.name);
     }
     if (identifier != null) {
       prop.setReplacementLengthIdentifier(identifier.length);
     }
     return prop;
   }
 
   CompletionProposal _createProposal3(Element element, String completion) {
-    ProposalKind kind = _proposalKindOf(element);
+    CompletionSuggestionKind kind = _proposalKindOf(element);
     CompletionProposal prop = _createProposal4(kind);
     prop.setElement(element);
     prop.setCompletion(completion);
     prop.setDeprecated(_isDeprecated(element));
     if (_isPrivate(element)) {
       prop.setRelevance(CompletionProposal.RELEVANCE_LOW);
     }
     if (_filter._isSameCasePrefix(element.name)) {
       prop.incRelevance();
     }
     return prop;
   }
 
-  CompletionProposal _createProposal4(ProposalKind kind) => _factory.createCompletionProposal(kind, _completionTokenOffset());
+  CompletionProposal _createProposal4(CompletionSuggestionKind kind) => _factory.createCompletionProposal(kind, _completionTokenOffset());
 
   List<LibraryElement> _currentLibraryList() {
     Set<LibraryElement> libraries = new Set<LibraryElement>();
     LibraryElement curLib = currentLibrary;
     libraries.add(curLib);
     Queue<LibraryElement> queue = new Queue<LibraryElement>();
     queue.addAll(curLib.importedLibraries);
     _currentLibraryLister(queue, libraries);
     return new List.from(libraries);
   }
@@ skipping 202 matching lines @@
     }
   }
 
   void _pArgumentList(CompletionProposal proposal, int offset, int len) {
     // prepare parameters
     List<String> parameterNames = proposal.parameterNames;
     if (parameterNames.length == 0) {
       return;
     }
     // fill arguments proposal
-    CompletionProposal prop = _createProposal4(ProposalKind.ARGUMENT_LIST);
+    CompletionProposal prop = _createProposal4(CompletionSuggestionKind.ARGUMENT_LIST);
     prop.setElement(proposal.element);
     prop.setCompletion(proposal.completion).setReturnType(proposal.returnType);
     prop.setParameterNames(parameterNames);
     prop.setParameterTypes(proposal.parameterTypes);
     prop.setParameterStyle(proposal.positionalParameterCount, proposal.hasNamed, proposal.hasPositional);
     prop.setReplacementLength(0).setLocation(_completionLocation());
     prop.setRelevance(CompletionProposal.RELEVANCE_HIGH);
     _requestor.accept(prop);
   }
 
   void _pDynamic() {
-    _pWord(_C_DYNAMIC, ProposalKind.VARIABLE);
+    _pWord(_C_DYNAMIC, CompletionSuggestionKind.VARIABLE);
   }
 
   void _pExecutable(Element element, FunctionType functionType, SimpleIdentifier identifier, bool isPotentialMatch) {
     // Create a completion proposal for the element: function, method, getter, setter, constructor.
     String name = element.displayName;
     if (name.isEmpty) {
       return;
     }
     if (_filterDisallows(element)) {
       return;
     }
     if (!_isVisible(element)) {
       return;
     }
     // May be we are in argument of function type parameter, propose function reference.
     if (_state._targetParameter != null) {
       DartType parameterType = _state._targetParameter.type;
       if (parameterType is FunctionType) {
         if (functionType.isAssignableTo(parameterType)) {
-          _pName2(name, element, CompletionProposal.RELEVANCE_HIGH, ProposalKind.METHOD_NAME);
+          _pName2(name, element, CompletionProposal.RELEVANCE_HIGH, CompletionSuggestionKind.METHOD_NAME);
         }
       }
     }
     CompletionProposal prop = _createProposal(element);
     prop.setPotentialMatch(isPotentialMatch);
     if (isPotentialMatch) {
       prop.setRelevance(CompletionProposal.RELEVANCE_LOW);
     }
     _setParameterInfo(functionType, prop);
     prop.setCompletion(name).setReturnType(functionType.returnType.displayName);
     // If there is already argument list, then update only method name.
     if (identifier.parent is MethodInvocation && (identifier.parent as MethodInvocation).argumentList != null) {
-      prop.setKind(ProposalKind.METHOD_NAME);
+      prop.setKind(CompletionSuggestionKind.METHOD_NAME);
     }
     Element container = element.enclosingElement;
     if (container != null) {
       prop.setDeclaringType(container.displayName);
     }
     _requestor.accept(prop);
   }
 
   void _pExecutable2(ExecutableElement element, SimpleIdentifier identifier, bool isPotentialMatch) {
     _pExecutable(element, element.type, identifier, isPotentialMatch);
@@ skipping 13 matching lines @@
     if (container != null) {
       prop.setDeclaringType(container.displayName);
     }
     if (identifier != null) {
       prop.setReplacementLengthIdentifier(identifier.length);
     }
     _requestor.accept(prop);
   }
 
   void _pFalse() {
-    _pWord(_C_FALSE, ProposalKind.VARIABLE);
+    _pWord(_C_FALSE, CompletionSuggestionKind.VARIABLE);
   }
 
   void _pField(FieldElement element, SimpleIdentifier identifier, ClassElement classElement) {
     // Create a completion proposal for the element: field only.
     if (_filterDisallows(element)) {
       return;
     }
     CompletionProposal prop = _createProposal(element);
     Element container = element.enclosingElement;
     prop.setDeclaringType(container.displayName);
     _requestor.accept(prop);
   }
 
   /**
    * Proposes URI with the given scheme for the given [NamespaceDirective].
    */
   void _pImportUriWithScheme(NamespaceDirective node, String uriScheme) {
     String newUri = "${uriScheme}${new String.fromCharCode(CompletionProposal.CURSOR_MARKER)}";
     if (node.uri.isSynthetic) {
       newUri = "'${newUri}'";
       if (node.semicolon == null || node.semicolon.isSynthetic) {
         newUri += ";";
       }
     }
     if (_context.selectionOffset == node.keyword.end) {
       newUri = " ${newUri}";
     }
-    _pName3(newUri, ProposalKind.IMPORT);
+    _pName3(newUri, CompletionSuggestionKind.IMPORT);
   }
 
   void _pKeyword(Token keyword) {
     _filter = new Filter.con2(keyword.lexeme, keyword.offset, _completionLocation());
     // This isn't as useful as it might seem. It only works in the case that completion
     // is requested on an existing recognizable keyword.
     // TODO: Add keyword proposal kind
-    CompletionProposal prop = _createProposal4(ProposalKind.LIBRARY_PREFIX);
+    CompletionProposal prop = _createProposal4(CompletionSuggestionKind.LIBRARY_PREFIX);
     prop.setCompletion(keyword.lexeme);
     _requestor.accept(prop);
   }
 
   void _pName(Element element, SimpleIdentifier identifier) {
     CompletionProposal prop = _createProposal2(element, identifier);
     if (prop != null) {
       _requestor.accept(prop);
     }
   }
 
-  void _pName2(String name, Element element, int relevance, ProposalKind kind) {
+  void _pName2(String name, Element element, int relevance, CompletionSuggestionKind kind) {
     if (_filterDisallows2(name)) {
       return;
     }
     CompletionProposal prop = _createProposal4(kind);
     prop.setRelevance(relevance);
     prop.setCompletion(name);
     prop.setElement(element);
     _requestor.accept(prop);
   }
 
-  void _pName3(String name, ProposalKind kind) {
+  void _pName3(String name, CompletionSuggestionKind kind) {
     if (_filterDisallows2(name)) {
       return;
     }
     CompletionProposal prop = _createProposal4(kind);
     prop.setCompletion(name);
     _requestor.accept(prop);
   }
 
   void _pNamedConstructor(ClassElement classElement, ConstructorElement element, SimpleIdentifier identifier) {
     // Create a completion proposal for the named constructor.
     String name = classElement.displayName;
     if (!element.displayName.isEmpty) {
       name += ".${element.displayName}";
     }
     if (_filterDisallows2(name)) {
       return;
     }
     CompletionProposal prop = _createProposal3(element, name);
     _setParameterInfo(element.type, prop);
     prop.setReturnType(element.type.returnType.name);
     Element container = element.enclosingElement;
     prop.setDeclaringType(container.displayName);
     if (identifier != null) {
       prop.setReplacementLengthIdentifier(identifier.length);
     }
     _requestor.accept(prop);
   }
 
   void _pNull() {
-    _pWord(_C_NULL, ProposalKind.VARIABLE);
+    _pWord(_C_NULL, CompletionSuggestionKind.VARIABLE);
   }
 
   void _pParamName(String name) {
     if (_filterDisallows2(name)) {
       return;
     }
-    CompletionProposal prop = _createProposal4(ProposalKind.PARAMETER);
+    CompletionProposal prop = _createProposal4(CompletionSuggestionKind.PARAMETER);
     prop.setCompletion(name);
     _requestor.accept(prop);
   }
 
-  ProposalKind _proposalKindOf(Element element) {
-    ProposalKind kind;
+  CompletionSuggestionKind _proposalKindOf(Element element) {
+    CompletionSuggestionKind kind;
     while (true) {
       if (element.kind == ElementKind.CONSTRUCTOR) {
-        kind = ProposalKind.CONSTRUCTOR;
+        kind = CompletionSuggestionKind.CONSTRUCTOR;
       } else if (element.kind == ElementKind.FUNCTION) {
-        kind = ProposalKind.FUNCTION;
+        kind = CompletionSuggestionKind.FUNCTION;
       } else if (element.kind == ElementKind.METHOD) {
-        kind = ProposalKind.METHOD;
+        kind = CompletionSuggestionKind.METHOD;
       } else if (element.kind == ElementKind.GETTER) {
-        kind = ProposalKind.GETTER;
+        kind = CompletionSuggestionKind.GETTER;
       } else if (element.kind == ElementKind.SETTER) {
-        kind = ProposalKind.SETTER;
+        kind = CompletionSuggestionKind.SETTER;
       } else if (element.kind == ElementKind.CLASS) {
-        kind = ProposalKind.CLASS;
+        kind = CompletionSuggestionKind.CLASS;
       } else if (element.kind == ElementKind.FIELD) {
-        kind = ProposalKind.FIELD;
+        kind = CompletionSuggestionKind.FIELD;
       } else if (element.kind == ElementKind.IMPORT) {
-        kind = ProposalKind.IMPORT;
+        kind = CompletionSuggestionKind.IMPORT;
       } else if (element.kind == ElementKind.PARAMETER) {
-        kind = ProposalKind.PARAMETER;
+        kind = CompletionSuggestionKind.PARAMETER;
       } else if (element.kind == ElementKind.PREFIX) {
-        kind = ProposalKind.LIBRARY_PREFIX;
+        kind = CompletionSuggestionKind.LIBRARY_PREFIX;
       } else if (element.kind == ElementKind.FUNCTION_TYPE_ALIAS) {
-        kind = ProposalKind.CLASS_ALIAS;
+        kind = CompletionSuggestionKind.CLASS_ALIAS;
       } else if (element.kind == ElementKind.TYPE_PARAMETER) {
-        kind = ProposalKind.TYPE_PARAMETER;
+        kind = CompletionSuggestionKind.TYPE_PARAMETER;
       } else if (element.kind == ElementKind.LOCAL_VARIABLE || element.kind == ElementKind.TOP_LEVEL_VARIABLE) {
-        kind = ProposalKind.VARIABLE;
+        kind = CompletionSuggestionKind.VARIABLE;
       } else {
         throw new IllegalArgumentException();
       }
       break;
     }
     return kind;
   }
 
   void _proposeCombinator(Combinator node, SimpleIdentifier identifier) {
     _filter = _createFilter(identifier);
     NamespaceDirective directive = node.parent as NamespaceDirective;
     LibraryElement libraryElement = directive.uriElement;
     if (libraryElement != null) {
       // prepare Elements with unique names
       CompletionEngine_NameCollector nameCollector = _createNameCollector();
       Iterable<Element> elements = CorrectionUtils.getExportNamespace2(libraryElement).values;
       for (Element element in elements) {
         if (_filterDisallows(element)) {
           continue;
         }
         nameCollector._mergeName(element);
       }
       // propose each Element
       for (Element element in nameCollector.uniqueElements) {
         CompletionProposal proposal = _createProposal(element);
-        if (proposal.kind == ProposalKind.FUNCTION) {
-          proposal.setKind(ProposalKind.METHOD_NAME);
+        if (proposal.kind == CompletionSuggestionKind.FUNCTION) {
+          proposal.setKind(CompletionSuggestionKind.METHOD_NAME);
         }
         _requestor.accept(proposal);
       }
     }
   }
 
   void _proposeName(Element element, SimpleIdentifier identifier, CompletionEngine_NameCollector names) {
     while (true) {
       if (element.kind == ElementKind.FUNCTION || element.kind == ElementKind.GETTER || element.kind == ElementKind.METHOD || element.kind == ElementKind.SETTER) {
         ExecutableElement candidate = element as ExecutableElement;
@@ skipping 14 matching lines @@
     }
   }
 
   void _proposeNames(CompletionEngine_NameCollector names, SimpleIdentifier identifier) {
     for (Element element in names.uniqueElements) {
       _proposeName(element, identifier, names);
     }
   }
 
   void _pTrue() {
-    _pWord(_C_TRUE, ProposalKind.VARIABLE);
+    _pWord(_C_TRUE, CompletionSuggestionKind.VARIABLE);
   }
 
   void _pVar() {
-    _pWord(_C_VAR, ProposalKind.VARIABLE);
+    _pWord(_C_VAR, CompletionSuggestionKind.VARIABLE);
   }
 
   void _pVoid() {
-    _pWord(_C_VOID, ProposalKind.VARIABLE);
+    _pWord(_C_VOID, CompletionSuggestionKind.VARIABLE);
   }
 
-  void _pWord(String word, ProposalKind kind) {
+  void _pWord(String word, CompletionSuggestionKind kind) {
     if (_filterDisallows2(word)) {
       return;
     }
     CompletionProposal prop = _createProposal4(kind);
     prop.setCompletion(word);
     _requestor.accept(prop);
   }
 
   void _removeNotMatchingFilter(List<Element> elements) {
     if (_filter == null) {
@@ skipping 164 matching lines @@
 
   @override
   Object visitComment(Comment node) {
     node.parent.accept(this);
     // propose names
     for (Element element in _names.uniqueElements) {
       CompletionProposal proposal = CompletionEngine_this._createProposal2(element, _identifier);
       if (proposal != null) {
         // we don't want to add arguments, just names
         if (element is MethodElement || element is FunctionElement) {
-          proposal.setKind(ProposalKind.METHOD_NAME);
+          proposal.setKind(CompletionSuggestionKind.METHOD_NAME);
         }
         // elevate priority for local elements
         if (_enclosingElements.contains(element.enclosingElement)) {
           proposal.setRelevance(CompletionProposal.RELEVANCE_HIGH);
         }
         // propose
         CompletionEngine_this._requestor.accept(proposal);
       }
     }
     // done
@@ skipping 96 matching lines @@
   Object visitCommentReference(CommentReference node) {
     AstNode comment = node.parent;
     CompletionEngine_CommentReferenceCompleter visitor = new CompletionEngine_CommentReferenceCompleter(CompletionEngine_this, _completionNode);
     return comment.accept(visitor);
   }
 
   @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     if (identical(node.returnType, _completionNode)) {
       CompletionEngine_this._filter = CompletionEngine_this._createFilter(_completionNode);
-      CompletionEngine_this._pName3(_completionNode.name, ProposalKind.CONSTRUCTOR);
+      CompletionEngine_this._pName3(_completionNode.name, CompletionSuggestionKind.CONSTRUCTOR);
     }
     return null;
   }
 
   @override
   Object visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     // { A() : this.!x = 1; }
     if (identical(node.fieldName, _completionNode)) {
       ClassElement classElement = (node.parent as ConstructorDeclaration).element.enclosingElement;
       CompletionEngine_this._fieldReference(classElement, node.fieldName);
@@ skipping 1238 matching lines @@
   }
 }
 
 /**
  * The factory class used to create completion proposals.
  */
 class CompletionFactory {
   /**
    * Create a completion proposal of the given kind.
    */
-  CompletionProposal createCompletionProposal(ProposalKind kind, int insertionPoint) {
+  CompletionProposal createCompletionProposal(CompletionSuggestionKind kind, int insertionPoint) {
     CompletionProposalImpl prop = new CompletionProposalImpl();
     prop.setKind(kind);
     prop.setLocation(insertionPoint);
     return prop;
   }
 }
 
 abstract class CompletionProposal {
   static final int RELEVANCE_LOW = 0;
 
   static final int RELEVANCE_DEFAULT = 10;
 
   static final int RELEVANCE_HIGH = 20;
 
   /**
    * This character is used to specify location of the cursor after completion.
    */
   static final int CURSOR_MARKER = 0x2758;
 
   void applyPartitionOffset(int partitionOffset);
 
   String get completion;
 
   String get declaringType;
 
   Element get element;
 
-  ProposalKind get kind;
+  CompletionSuggestionKind get kind;
 
   int get location;
 
   String get parameterName;
 
   List<String> get parameterNames;
 
   String get parameterType;
 
   List<String> get parameterTypes;
@@ skipping 19 matching lines @@
   bool get isPotentialMatch;
 
   CompletionProposal setCompletion(String x);
 
   CompletionProposal setDeclaringType(String name);
 
   CompletionProposal setDeprecated(bool deprecated);
 
   CompletionProposal setElement(Element element);
 
-  CompletionProposal setKind(ProposalKind x);
+  CompletionProposal setKind(CompletionSuggestionKind x);
 
   CompletionProposal setLocation(int x);
 
   CompletionProposal setParameterName(String paramName);
 
   CompletionProposal setParameterNames(List<String> paramNames);
 
   CompletionProposal setParameterStyle(int count, bool named, bool positional);
 
   CompletionProposal setParameterType(String paramType);
@@ skipping 21 matching lines @@
   String _declaringType = "";
 
   List<String> _parameterNames = StringUtilities.EMPTY_ARRAY;
 
   List<String> _parameterTypes = StringUtilities.EMPTY_ARRAY;
 
   String _parameterName;
 
   String _parameterType;
 
-  ProposalKind _kind = ProposalKind.NONE;
+  CompletionSuggestionKind _kind = null;
 
   int _location = 0;
 
   int _replacementLength = 0;
 
   int _replacementLength2 = 0;
 
   int _positionalParameterCount = 0;
 
   bool _named = false;
@@ skipping 14 matching lines @@
   @override
   String get completion => _completion;
 
   @override
   String get declaringType => _declaringType;
 
   @override
   Element get element => _element;
 
   @override
-  ProposalKind get kind => _kind;
+  CompletionSuggestionKind get kind => _kind;
 
   @override
   int get location => _location;
 
   @override
   String get parameterName => _parameterName;
 
   @override
   List<String> get parameterNames => _parameterNames;
 
@@ skipping 57 matching lines @@
     return this;
   }
 
   @override
   CompletionProposal setElement(Element element) {
     this._element = element;
     return this;
   }
 
   @override
-  CompletionProposal setKind(ProposalKind x) {
+  CompletionProposal setKind(CompletionSuggestionKind x) {
     _kind = x;
     return this;
   }
 
   @override
   CompletionProposal setLocation(int x) {
     _location = x;
     return this;
   }
 
@@ skipping 574 matching lines @@
   }
 
   @override
   void endReporting() {
     requestor.endReporting();
   }
 
   List<CompletionProposal> get proposals => _proposals;
 }
 
-/**
- * The various kinds of completion proposals. Each specifies the kind of completion to be created,
- * corresponding to different syntactical elements.
- */
-class ProposalKind extends Enum<ProposalKind> {
-  static const ProposalKind NONE = const ProposalKind('NONE', 0);
-
-  static const ProposalKind CLASS = const ProposalKind('CLASS', 1);
-
-  static const ProposalKind CLASS_ALIAS = const ProposalKind('CLASS_ALIAS', 2);
-
-  static const ProposalKind CONSTRUCTOR = const ProposalKind('CONSTRUCTOR', 3);
-
-  static const ProposalKind FIELD = const ProposalKind('FIELD', 4);
-
-  static const ProposalKind FUNCTION = const ProposalKind('FUNCTION', 5);
-
-  static const ProposalKind FUNCTION_ALIAS = const ProposalKind('FUNCTION_ALIAS', 6);
-
-  static const ProposalKind GETTER = const ProposalKind('GETTER', 7);
-
-  static const ProposalKind IMPORT = const ProposalKind('IMPORT', 8);
-
-  static const ProposalKind LIBRARY_PREFIX = const ProposalKind('LIBRARY_PREFIX', 9);
-
-  static const ProposalKind METHOD = const ProposalKind('METHOD', 10);
-
-  static const ProposalKind METHOD_NAME = const ProposalKind('METHOD_NAME', 11);
-
-  static const ProposalKind PARAMETER = const ProposalKind('PARAMETER', 12);
-
-  static const ProposalKind SETTER = const ProposalKind('SETTER', 13);
-
-  static const ProposalKind VARIABLE = const ProposalKind('VARIABLE', 14);
-
-  static const ProposalKind TYPE_PARAMETER = const ProposalKind('TYPE_PARAMETER', 15);
-
-  static const ProposalKind ARGUMENT_LIST = const ProposalKind('ARGUMENT_LIST', 16);
-
-  static const ProposalKind OPTIONAL_ARGUMENT = const ProposalKind('OPTIONAL_ARGUMENT', 17);
-
-  static const ProposalKind NAMED_ARGUMENT = const ProposalKind('NAMED_ARGUMENT', 18);
-
-  static const List<ProposalKind> values = const [
-      NONE,
-      CLASS,
-      CLASS_ALIAS,
-      CONSTRUCTOR,
-      FIELD,
-      FUNCTION,
-      FUNCTION_ALIAS,
-      GETTER,
-      IMPORT,
-      LIBRARY_PREFIX,
-      METHOD,
-      METHOD_NAME,
-      PARAMETER,
-      SETTER,
-      VARIABLE,
-      TYPE_PARAMETER,
-      ARGUMENT_LIST,
-      OPTIONAL_ARGUMENT,
-      NAMED_ARGUMENT];
-
-  const ProposalKind(String name, int ordinal) : super(name, ordinal);
-}
-
 class SearchFilter_CompletionEngine_allSubtypes implements SearchFilter {
   ClassElement classElement;
 
   SearchFilter_CompletionEngine_allSubtypes(this.classElement);
 
   @override
   bool passes(SearchMatch match) {
     Element element = match.element;
     if (element is ClassElement) {
       ClassElement clElem = element;
@@ skipping 14 matching lines @@
 
 class TopLevelNamesKind extends Enum<TopLevelNamesKind> {
   static const TopLevelNamesKind DECLARED_AND_IMPORTS = const TopLevelNamesKind('DECLARED_AND_IMPORTS', 0);
 
   static const TopLevelNamesKind DECLARED_AND_EXPORTS = const TopLevelNamesKind('DECLARED_AND_EXPORTS', 1);
 
   static const List<TopLevelNamesKind> values = const [DECLARED_AND_IMPORTS, DECLARED_AND_EXPORTS];
 
   const TopLevelNamesKind(String name, int ordinal) : super(name, ordinal);
 }