rename CompletionSuggestionKind.VARIABLE to LOCAL_VARIABLE to match spec

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';
@@ skipping 143 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, CompletionSuggestionKind.VARIABLE);
+      _pName3(identifier.name, CompletionSuggestionKind.LOCAL_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());
     }
   }
@@ skipping 839 matching lines @@
     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, CompletionSuggestionKind.VARIABLE);
+    _pWord(_C_DYNAMIC, CompletionSuggestionKind.LOCAL_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;
@@ skipping 46 matching lines @@
     if (container != null) {
       prop.setDeclaringType(container.displayName);
     }
     if (identifier != null) {
       prop.setReplacementLengthIdentifier(identifier.length);
     }
     _requestor.accept(prop);
   }
 
   void _pFalse() {
-    _pWord(_C_FALSE, CompletionSuggestionKind.VARIABLE);
+    _pWord(_C_FALSE, CompletionSuggestionKind.LOCAL_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);
@@ skipping 68 matching lines @@
     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, CompletionSuggestionKind.VARIABLE);
+    _pWord(_C_NULL, CompletionSuggestionKind.LOCAL_VARIABLE);
   }
 
   void _pParamName(String name) {
     if (_filterDisallows2(name)) {
       return;
     }
     CompletionProposal prop = _createProposal4(CompletionSuggestionKind.PARAMETER);
     prop.setCompletion(name);
     _requestor.accept(prop);
   }
@@ skipping 19 matching lines @@
         kind = CompletionSuggestionKind.IMPORT;
       } else if (element.kind == ElementKind.PARAMETER) {
         kind = CompletionSuggestionKind.PARAMETER;
       } else if (element.kind == ElementKind.PREFIX) {
         kind = CompletionSuggestionKind.LIBRARY_PREFIX;
       } else if (element.kind == ElementKind.FUNCTION_TYPE_ALIAS) {
         kind = CompletionSuggestionKind.CLASS_ALIAS;
       } else if (element.kind == ElementKind.TYPE_PARAMETER) {
         kind = CompletionSuggestionKind.TYPE_PARAMETER;
       } else if (element.kind == ElementKind.LOCAL_VARIABLE || element.kind == ElementKind.TOP_LEVEL_VARIABLE) {
-        kind = CompletionSuggestionKind.VARIABLE;
+        kind = CompletionSuggestionKind.LOCAL_VARIABLE;
       } else {
         throw new IllegalArgumentException();
       }
       break;
     }
     return kind;
   }
 
   void _proposeCombinator(Combinator node, SimpleIdentifier identifier) {
     _filter = _createFilter(identifier);
@@ skipping 41 matching lines @@
     }
   }
 
   void _proposeNames(CompletionEngine_NameCollector names, SimpleIdentifier identifier) {
     for (Element element in names.uniqueElements) {
       _proposeName(element, identifier, names);
     }
   }
 
   void _pTrue() {
-    _pWord(_C_TRUE, CompletionSuggestionKind.VARIABLE);
+    _pWord(_C_TRUE, CompletionSuggestionKind.LOCAL_VARIABLE);
   }
 
   void _pVar() {
-    _pWord(_C_VAR, CompletionSuggestionKind.VARIABLE);
+    _pWord(_C_VAR, CompletionSuggestionKind.LOCAL_VARIABLE);
   }
 
   void _pVoid() {
-    _pWord(_C_VOID, CompletionSuggestionKind.VARIABLE);
+    _pWord(_C_VOID, CompletionSuggestionKind.LOCAL_VARIABLE);
   }
 
   void _pWord(String word, CompletionSuggestionKind kind) {
     if (_filterDisallows2(word)) {
       return;
     }
     CompletionProposal prop = _createProposal4(kind);
     prop.setCompletion(word);
     _requestor.accept(prop);
   }
@@ skipping 2395 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);
 }