@zzzen/pyright-internal 1.2.0-dev.20231119 → 1.2.0-dev.20231203

package/dist/languageService/completionProvider.js

@@ -10,7 +10,11 @@
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -252,17 +256,17 @@ class CompletionProvider {
     }
     isSimpleDefault(node) {
         switch (node.nodeType) {
-            case 40 /* Number */:
-            case 11 /* Constant */:
-            case 35 /* MemberAccess */:
+            case 40 /* ParseNodeType.Number */:
+            case 11 /* ParseNodeType.Constant */:
+            case 35 /* ParseNodeType.MemberAccess */:
                 return true;
-            case 49 /* String */:
-                return (node.token.flags & 64 /* Format */) === 0;
-            case 48 /* StringList */:
+            case 49 /* ParseNodeType.String */:
+                return (node.token.flags & 64 /* StringTokenFlags.Format */) === 0;
+            case 48 /* ParseNodeType.StringList */:
                 return node.strings.every(this.isSimpleDefault);
-            case 55 /* UnaryOperation */:
+            case 55 /* ParseNodeType.UnaryOperation */:
                 return this.isSimpleDefault(node.expression);
-            case 7 /* BinaryOperation */:
+            case 7 /* ParseNodeType.BinaryOperation */:
                 return this.isSimpleDefault(node.leftExpression) && this.isSimpleDefault(node.rightExpression);
             default:
                 return false;
@@ -291,7 +295,7 @@ class CompletionProvider {
         symbolTable.forEach((symbol, name) => {
             var _a;
             let decl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(symbol);
-            if (decl && decl.type === 5 /* Function */) {
+            if (decl && decl.type === 5 /* DeclarationType.Function */) {
                 if (StringUtils.isPatternInSymbol(partialName.value, name)) {
                     const declaredType = (_a = this.evaluator.getTypeForDeclaration(decl)) === null || _a === void 0 ? void 0 : _a.type;
                     if (!declaredType) {
@@ -309,7 +313,7 @@ class CompletionProvider {
                         // For properties, we should override the "getter", which is typically
                         // the first declaration.
                         const typedDecls = symbol.getTypedDeclarations();
-                        if (typedDecls.length > 0 && typedDecls[0].type === 5 /* Function */) {
+                        if (typedDecls.length > 0 && typedDecls[0].type === 5 /* DeclarationType.Function */) {
                             decl = typedDecls[0];
                         }
                     }
@@ -375,12 +379,12 @@ class CompletionProvider {
                 if (parameter.name) {
                     results.push([
                         parameter,
-                        parameter.category === 0 /* Simple */ && !!parameter.name && sawKeywordOnlySeparator,
+                        parameter.category === 0 /* ParameterCategory.Simple */ && !!parameter.name && sawKeywordOnlySeparator,
                     ]);
                 }
                 // All simple parameters after a `*` or `*args` parameter
                 // are considered keyword only.
-                if (parameter.category === 1 /* ArgsList */) {
+                if (parameter.category === 1 /* ParameterCategory.ArgsList */) {
                     sawKeywordOnlySeparator = true;
                 }
             }
@@ -389,17 +393,17 @@ class CompletionProvider {
         function convertToString(parameter) {
             var _a;
             const name = (_a = parameter[0].name) === null || _a === void 0 ? void 0 : _a.value;
-            if (parameter[0].category === 1 /* ArgsList */) {
+            if (parameter[0].category === 1 /* ParameterCategory.ArgsList */) {
                 return `*${name}`;
             }
-            if (parameter[0].category === 2 /* KwargsDict */) {
+            if (parameter[0].category === 2 /* ParameterCategory.KwargsDict */) {
                 return `**${name}`;
             }
             return parameter[1] ? `${name}=${name}` : name;
         }
     }
     createReplaceEdits(priorWord, node, text) {
-        const replaceOrInsertEndChar = (node === null || node === void 0 ? void 0 : node.nodeType) === 38 /* Name */
+        const replaceOrInsertEndChar = (node === null || node === void 0 ? void 0 : node.nodeType) === 38 /* ParseNodeType.Name */
             ? this.position.character - priorWord.length + node.value.length
             : this.position.character;
         const range = {
@@ -474,11 +478,11 @@ class CompletionProvider {
             // Handle enum members specially. Enum members normally look like
             // variables, but the are declared using assignment expressions
             // within an enum class.
-            if (primaryDecl.type === 1 /* Variable */ &&
+            if (primaryDecl.type === 1 /* DeclarationType.Variable */ &&
                 detail.boundObjectOrClass &&
                 (0, types_1.isInstantiableClass)(detail.boundObjectOrClass) &&
                 types_1.ClassType.isEnumClass(detail.boundObjectOrClass) &&
-                ((_c = primaryDecl.node.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 3 /* Assignment */) {
+                ((_c = primaryDecl.node.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 3 /* ParseNodeType.Assignment */) {
                 itemKind = vscode_languageserver_1.CompletionItemKind.EnumMember;
             }
             this.addNameToCompletions((_d = detail.autoImportAlias) !== null && _d !== void 0 ? _d : name, itemKind, priorWord, completionMap, {
@@ -594,7 +598,7 @@ class CompletionProvider {
         }
     }
     checkDecorator(node, value) {
-        return node.expression.nodeType === 38 /* Name */ && node.expression.value === value;
+        return node.expression.nodeType === 38 /* ParseNodeType.Name */ && node.expression.value === value;
     }
     addExtraCommitChar(item) {
         // extra commit char is not supported.
@@ -738,16 +742,16 @@ class CompletionProvider {
         let node = ParseTreeUtils.findNodeByOffset(this.parseResults.parseTree, offset);
         // See if we're inside a string literal or an f-string statement.
         const token = ParseTreeUtils.getTokenOverlapping(this.parseResults.tokenizerOutput.tokens, offset);
-        if ((token === null || token === void 0 ? void 0 : token.type) === 5 /* String */) {
+        if ((token === null || token === void 0 ? void 0 : token.type) === 5 /* TokenType.String */) {
             const stringToken = token;
             this._stringLiteralContainer = textRange_1.TextRange.contains(stringToken, offset)
                 ? stringToken
-                : stringToken.flags & 65536 /* Unterminated */
+                : stringToken.flags & 65536 /* StringTokenFlags.Unterminated */
                     ? stringToken
                     : undefined;
         }
         else if (node) {
-            const fStringContainer = ParseTreeUtils.getParentNodeOfType(node, 27 /* FormatString */);
+            const fStringContainer = ParseTreeUtils.getParentNodeOfType(node, 27 /* ParseNodeType.FormatString */);
             if (fStringContainer) {
                 this._stringLiteralContainer = fStringContainer.token;
             }
@@ -757,7 +761,7 @@ class CompletionProvider {
         // node.
         const initialNode = node;
         const initialDepth = node ? ParseTreeUtils.getNodeDepth(node) : 0;
-        if (!initialNode || initialNode.nodeType !== 38 /* Name */) {
+        if (!initialNode || initialNode.nodeType !== 38 /* ParseNodeType.Name */) {
             let curOffset = offset;
             let sawComma = false;
             while (curOffset >= 0) {
@@ -776,7 +780,7 @@ class CompletionProvider {
                         node = curNode;
                         // If we're at the end of a list with a hanging comma, handle the
                         // special case of "from x import y, ".
-                        if (sawComma && ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 23 /* ImportFromAs */) {
+                        if (sawComma && ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 23 /* ParseNodeType.ImportFromAs */) {
                             node = node.parent;
                         }
                     }
@@ -802,7 +806,7 @@ class CompletionProvider {
         // precedence.
         let errorNode = node;
         while (errorNode) {
-            if (errorNode.nodeType === 0 /* Error */) {
+            if (errorNode.nodeType === 0 /* ParseNodeType.Error */) {
                 break;
             }
             errorNode = errorNode.parent;
@@ -812,31 +816,31 @@ class CompletionProvider {
         let curNode = errorNode || node;
         while (true) {
             (0, cancellationUtils_1.throwIfCancellationRequested)(this.cancellationToken);
-            if (curNode.nodeType === 49 /* String */) {
+            if (curNode.nodeType === 49 /* ParseNodeType.String */) {
                 return this._getLiteralCompletions(curNode, offset, priorWord, priorText, postText);
             }
-            if (curNode.nodeType === 48 /* StringList */ || curNode.nodeType === 27 /* FormatString */) {
+            if (curNode.nodeType === 48 /* ParseNodeType.StringList */ || curNode.nodeType === 27 /* ParseNodeType.FormatString */) {
                 return undefined;
             }
-            if (curNode.nodeType === 37 /* ModuleName */) {
+            if (curNode.nodeType === 37 /* ParseNodeType.ModuleName */) {
                 return this._getImportModuleCompletions(curNode);
             }
-            if (curNode.nodeType === 0 /* Error */) {
+            if (curNode.nodeType === 0 /* ParseNodeType.Error */) {
                 return this._getExpressionErrorCompletions(curNode, offset, priorWord, priorText, postText);
             }
-            if (curNode.nodeType === 35 /* MemberAccess */) {
+            if (curNode.nodeType === 35 /* ParseNodeType.MemberAccess */) {
                 return this.getMemberAccessCompletions(curNode.leftExpression, priorWord);
             }
-            if (curNode.nodeType === 15 /* Dictionary */) {
+            if (curNode.nodeType === 15 /* ParseNodeType.Dictionary */) {
                 const completionMap = new CompletionMap();
                 if (this._tryAddTypedDictKeysFromDictionary(curNode, 
                 /* stringNode */ undefined, priorWord, priorText, postText, completionMap)) {
                     return completionMap;
                 }
             }
-            const dictionaryEntry = ParseTreeUtils.getFirstAncestorOrSelfOfKind(curNode, 17 /* DictionaryKeyEntry */);
+            const dictionaryEntry = ParseTreeUtils.getFirstAncestorOrSelfOfKind(curNode, 17 /* ParseNodeType.DictionaryKeyEntry */);
             if (dictionaryEntry) {
-                if (((_b = dictionaryEntry.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 15 /* Dictionary */) {
+                if (((_b = dictionaryEntry.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 15 /* ParseNodeType.Dictionary */) {
                     const dictionaryNode = dictionaryEntry.parent;
                     if (dictionaryNode.trailingCommaToken && dictionaryNode.trailingCommaToken.start < offset) {
                         const completionMap = new CompletionMap();
@@ -847,7 +851,7 @@ class CompletionProvider {
                     }
                 }
             }
-            if (curNode.nodeType === 38 /* Name */) {
+            if (curNode.nodeType === 38 /* ParseNodeType.Name */) {
                 // This condition is little different than others since it does its own
                 // tree walk up to find context and let outer tree walk up to proceed if it can't find
                 // one to show completion.
@@ -856,19 +860,19 @@ class CompletionProvider {
                     return result;
                 }
             }
-            if (curNode.nodeType === 31 /* List */ && this.options.triggerCharacter === '[') {
+            if (curNode.nodeType === 31 /* ParseNodeType.List */ && this.options.triggerCharacter === '[') {
                 // If this is an empty list, don't start putting completions up yet.
                 return undefined;
             }
-            if (curNode.nodeType === 22 /* ImportFrom */) {
+            if (curNode.nodeType === 22 /* ParseNodeType.ImportFrom */) {
                 return this._getImportFromCompletions(curNode, priorWord);
             }
             if ((0, parseNodes_1.isExpressionNode)(curNode)) {
                 return this._getExpressionCompletions(curNode, priorWord, priorText, postText);
             }
-            if (curNode.nodeType === 50 /* Suite */) {
+            if (curNode.nodeType === 50 /* ParseNodeType.Suite */) {
                 if (curNode.parent &&
-                    curNode.parent.nodeType === 25 /* Except */ &&
+                    curNode.parent.nodeType === 25 /* ParseNodeType.Except */ &&
                     !curNode.parent.name &&
                     curNode.parent.typeExpression &&
                     textRange_1.TextRange.getEnd(curNode.parent.typeExpression) < offset &&
@@ -877,7 +881,7 @@ class CompletionProvider {
                     return undefined;
                 }
                 if (curNode.parent &&
-                    curNode.parent.nodeType === 10 /* Class */ &&
+                    curNode.parent.nodeType === 10 /* ParseNodeType.Class */ &&
                     (!curNode.parent.name || !curNode.parent.name.value) &&
                     curNode.parent.arguments.length === 0 &&
                     offset <= curNode.parent.suite.start) {
@@ -886,13 +890,13 @@ class CompletionProvider {
                 }
                 return this._getStatementCompletions(curNode, priorWord, priorText, postText);
             }
-            if (curNode.nodeType === 36 /* Module */) {
+            if (curNode.nodeType === 36 /* ParseNodeType.Module */) {
                 return this._getStatementCompletions(curNode, priorWord, priorText, postText);
             }
-            if (curNode.nodeType === 41 /* Parameter */ &&
+            if (curNode.nodeType === 41 /* ParseNodeType.Parameter */ &&
                 curNode.length === 0 &&
                 curNode.parent &&
-                curNode.parent.nodeType === 30 /* Lambda */) {
+                curNode.parent.nodeType === 30 /* ParseNodeType.Lambda */) {
                 // lambda [<empty>] or lambda x, [<empty>]
                 return undefined;
             }
@@ -912,14 +916,14 @@ class CompletionProvider {
         if (!curNode.parent) {
             return false;
         }
-        if (curNode.parent.nodeType === 21 /* ImportAs */ && curNode.parent.alias === curNode) {
+        if (curNode.parent.nodeType === 21 /* ParseNodeType.ImportAs */ && curNode.parent.alias === curNode) {
             // Are we within a "import Y as [Z]"?
             return undefined;
         }
-        if (curNode.parent.nodeType === 37 /* ModuleName */) {
+        if (curNode.parent.nodeType === 37 /* ParseNodeType.ModuleName */) {
             // Are we within a "import Y as [<empty>]"?
             if (curNode.parent.parent &&
-                curNode.parent.parent.nodeType === 21 /* ImportAs */ &&
+                curNode.parent.parent.nodeType === 21 /* ParseNodeType.ImportAs */ &&
                 !curNode.parent.parent.alias &&
                 textRange_1.TextRange.getEnd(curNode.parent.parent) < offset) {
                 return undefined;
@@ -928,13 +932,13 @@ class CompletionProvider {
             // more specifically within the "Y"?
             return this._getImportModuleCompletions(curNode.parent);
         }
-        if (curNode.parent.nodeType === 23 /* ImportFromAs */) {
+        if (curNode.parent.nodeType === 23 /* ParseNodeType.ImportFromAs */) {
             if (curNode.parent.alias === curNode) {
                 // Are we within a "from X import Y as [Z]"?
                 return undefined;
             }
             const parentNode = curNode.parent.parent;
-            if (parentNode && parentNode.nodeType === 22 /* ImportFrom */) {
+            if (parentNode && parentNode.nodeType === 22 /* ParseNodeType.ImportFrom */) {
                 // Are we within a "from X import Y as [<empty>]"?
                 if (!curNode.parent.alias && textRange_1.TextRange.getEnd(curNode.parent) < offset) {
                     return undefined;
@@ -946,36 +950,36 @@ class CompletionProvider {
             }
             return false;
         }
-        if (curNode.parent.nodeType === 35 /* MemberAccess */ && curNode === curNode.parent.memberName) {
+        if (curNode.parent.nodeType === 35 /* ParseNodeType.MemberAccess */ && curNode === curNode.parent.memberName) {
             return this.getMemberAccessCompletions(curNode.parent.leftExpression, priorWord);
         }
-        if (curNode.parent.nodeType === 25 /* Except */ && curNode === curNode.parent.name) {
+        if (curNode.parent.nodeType === 25 /* ParseNodeType.Except */ && curNode === curNode.parent.name) {
             return undefined;
         }
-        if (curNode.parent.nodeType === 28 /* Function */ && curNode === curNode.parent.name) {
+        if (curNode.parent.nodeType === 28 /* ParseNodeType.Function */ && curNode === curNode.parent.name) {
             if ((_a = curNode.parent.decorators) === null || _a === void 0 ? void 0 : _a.some((d) => this._isOverload(d))) {
                 return this._getMethodOverloadsCompletions(priorWord, curNode);
             }
             return undefined;
         }
-        if (curNode.parent.nodeType === 41 /* Parameter */ && curNode === curNode.parent.name) {
+        if (curNode.parent.nodeType === 41 /* ParseNodeType.Parameter */ && curNode === curNode.parent.name) {
             return undefined;
         }
-        if (curNode.parent.nodeType === 10 /* Class */ && curNode === curNode.parent.name) {
+        if (curNode.parent.nodeType === 10 /* ParseNodeType.Class */ && curNode === curNode.parent.name) {
             return undefined;
         }
-        if (curNode.parent.nodeType === 26 /* For */ &&
+        if (curNode.parent.nodeType === 26 /* ParseNodeType.For */ &&
             textRange_1.TextRange.contains(curNode.parent.targetExpression, curNode.start)) {
             return undefined;
         }
-        if (curNode.parent.nodeType === 33 /* ListComprehensionFor */ &&
+        if (curNode.parent.nodeType === 33 /* ParseNodeType.ListComprehensionFor */ &&
             textRange_1.TextRange.contains(curNode.parent.targetExpression, curNode.start)) {
             return undefined;
         }
         // For assignments that implicitly declare variables, remove itself (var decl) from completion.
-        if (curNode.parent.nodeType === 3 /* Assignment */ ||
-            curNode.parent.nodeType === 4 /* AssignmentExpression */) {
-            const leftNode = curNode.parent.nodeType === 4 /* AssignmentExpression */
+        if (curNode.parent.nodeType === 3 /* ParseNodeType.Assignment */ ||
+            curNode.parent.nodeType === 4 /* ParseNodeType.AssignmentExpression */) {
+            const leftNode = curNode.parent.nodeType === 4 /* ParseNodeType.AssignmentExpression */
                 ? curNode.parent.name
                 : curNode.parent.leftExpression;
             if (leftNode !== curNode || priorWord.length === 0) {
@@ -994,9 +998,9 @@ class CompletionProvider {
         // Defining class variables.
         // ex) class A:
         //         variable = 1
-        if (curNode.parent.nodeType === 47 /* StatementList */ &&
-            ((_b = curNode.parent.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 50 /* Suite */ &&
-            ((_c = curNode.parent.parent.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 10 /* Class */) {
+        if (curNode.parent.nodeType === 47 /* ParseNodeType.StatementList */ &&
+            ((_b = curNode.parent.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 50 /* ParseNodeType.Suite */ &&
+            ((_c = curNode.parent.parent.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 10 /* ParseNodeType.Class */) {
             const completionList = this._getClassVariableCompletions(curNode);
             if (completionList) {
                 return completionList;
@@ -1047,23 +1051,23 @@ class CompletionProvider {
         // we can evaluate the left side of the member access expression
         // to determine its type and offer suggestions based on it.
         switch (node.category) {
-            case 0 /* MissingIn */: {
+            case 0 /* ErrorExpressionCategory.MissingIn */: {
                 return this._createSingleKeywordCompletion('in');
             }
-            case 1 /* MissingElse */: {
+            case 1 /* ErrorExpressionCategory.MissingElse */: {
                 return this._createSingleKeywordCompletion('else');
             }
-            case 7 /* MissingMemberAccessName */:
-            case 2 /* MissingExpression */: {
+            case 7 /* ErrorExpressionCategory.MissingMemberAccessName */:
+            case 2 /* ErrorExpressionCategory.MissingExpression */: {
                 // Don't show completion after random dots.
                 const tokenizerOutput = this.parseResults.tokenizerOutput;
                 const offset = (0, positionUtils_1.convertPositionToOffset)(this.position, tokenizerOutput.lines);
                 const index = ParseTreeUtils.getTokenIndexAtLeft(tokenizerOutput.tokens, offset);
                 const token = ParseTreeUtils.getTokenAtIndex(tokenizerOutput.tokens, index);
                 const prevToken = ParseTreeUtils.getTokenAtIndex(tokenizerOutput.tokens, index - 1);
-                if (node.category === 2 /* MissingExpression */) {
+                if (node.category === 2 /* ErrorExpressionCategory.MissingExpression */) {
                     // Skip dots on expressions.
-                    if ((token === null || token === void 0 ? void 0 : token.type) === 20 /* Dot */ || (token === null || token === void 0 ? void 0 : token.type) === 19 /* Ellipsis */) {
+                    if ((token === null || token === void 0 ? void 0 : token.type) === 20 /* TokenType.Dot */ || (token === null || token === void 0 ? void 0 : token.type) === 19 /* TokenType.Ellipsis */) {
                         break;
                     }
                     // ex) class MyType:
@@ -1075,16 +1079,16 @@ class CompletionProvider {
                     // since parser won't see "is" as partially written member name instead it will see it as
                     // expression statement with missing expression after "is" keyword.
                     // In such case, use "MyType." to get completion.
-                    if ((token === null || token === void 0 ? void 0 : token.type) !== 8 /* Keyword */ || textRange_1.TextRange.getEnd(token) !== offset) {
+                    if ((token === null || token === void 0 ? void 0 : token.type) !== 8 /* TokenType.Keyword */ || textRange_1.TextRange.getEnd(token) !== offset) {
                         return this._getExpressionCompletions(node, priorWord, priorText, postText);
                     }
-                    if ((prevToken === null || prevToken === void 0 ? void 0 : prevToken.type) !== 20 /* Dot */) {
+                    if ((prevToken === null || prevToken === void 0 ? void 0 : prevToken.type) !== 20 /* TokenType.Dot */) {
                         return this._getExpressionCompletions(node, priorWord, priorText, postText);
                     }
                     const previousOffset = textRange_1.TextRange.getEnd(prevToken);
                     const previousNode = ParseTreeUtils.findNodeByOffset(this.parseResults.parseTree, previousOffset);
-                    if ((previousNode === null || previousNode === void 0 ? void 0 : previousNode.nodeType) !== 0 /* Error */ ||
-                        previousNode.category !== 7 /* MissingMemberAccessName */) {
+                    if ((previousNode === null || previousNode === void 0 ? void 0 : previousNode.nodeType) !== 0 /* ParseNodeType.Error */ ||
+                        previousNode.category !== 7 /* ErrorExpressionCategory.MissingMemberAccessName */) {
                         return this._getExpressionCompletions(node, priorWord, priorText, postText);
                     }
                     else {
@@ -1092,28 +1096,28 @@ class CompletionProvider {
                         node = previousNode;
                     }
                 }
-                else if (node.category === 7 /* MissingMemberAccessName */) {
+                else if (node.category === 7 /* ErrorExpressionCategory.MissingMemberAccessName */) {
                     // Skip double dots on member access.
-                    if (((token === null || token === void 0 ? void 0 : token.type) === 20 /* Dot */ || (token === null || token === void 0 ? void 0 : token.type) === 19 /* Ellipsis */) &&
-                        ((prevToken === null || prevToken === void 0 ? void 0 : prevToken.type) === 20 /* Dot */ || (prevToken === null || prevToken === void 0 ? void 0 : prevToken.type) === 19 /* Ellipsis */)) {
+                    if (((token === null || token === void 0 ? void 0 : token.type) === 20 /* TokenType.Dot */ || (token === null || token === void 0 ? void 0 : token.type) === 19 /* TokenType.Ellipsis */) &&
+                        ((prevToken === null || prevToken === void 0 ? void 0 : prevToken.type) === 20 /* TokenType.Dot */ || (prevToken === null || prevToken === void 0 ? void 0 : prevToken.type) === 19 /* TokenType.Ellipsis */)) {
                         return undefined;
                     }
                 }
                 return this._getMissingMemberAccessNameCompletions(node, priorWord);
             }
-            case 4 /* MissingDecoratorCallName */: {
+            case 4 /* ErrorExpressionCategory.MissingDecoratorCallName */: {
                 return this._getExpressionCompletions(node, priorWord, priorText, postText);
             }
-            case 11 /* MissingPattern */:
-            case 3 /* MissingIndexOrSlice */: {
+            case 11 /* ErrorExpressionCategory.MissingPattern */:
+            case 3 /* ErrorExpressionCategory.MissingIndexOrSlice */: {
                 let completionResults = this._getLiteralCompletions(node, offset, priorWord, priorText, postText);
                 if (!completionResults) {
                     completionResults = this._getExpressionCompletions(node, priorWord, priorText, postText);
                 }
                 return completionResults;
             }
-            case 10 /* MissingFunctionParameterList */: {
-                if (node.child && node.child.nodeType === 38 /* Name */) {
+            case 10 /* ErrorExpressionCategory.MissingFunctionParameterList */: {
+                if (node.child && node.child.nodeType === 38 /* ParseNodeType.Name */) {
                     if ((_a = node.decorators) === null || _a === void 0 ? void 0 : _a.some((d) => this._isOverload(d))) {
                         return this._getMethodOverloadsCompletions(priorWord, node.child);
                     }
@@ -1147,12 +1151,12 @@ class CompletionProvider {
         var _a, _b, _c, _d;
         // class T:
         //    f: |<= here
-        const isTypeAnnotationOfClassVariable = ((_a = parseNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 54 /* TypeAnnotation */ &&
-            parseNode.parent.valueExpression.nodeType === 38 /* Name */ &&
+        const isTypeAnnotationOfClassVariable = ((_a = parseNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 54 /* ParseNodeType.TypeAnnotation */ &&
+            parseNode.parent.valueExpression.nodeType === 38 /* ParseNodeType.Name */ &&
             parseNode.parent.typeAnnotation === parseNode &&
-            ((_b = parseNode.parent.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 47 /* StatementList */ &&
-            ((_c = parseNode.parent.parent.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 50 /* Suite */ &&
-            ((_d = parseNode.parent.parent.parent.parent) === null || _d === void 0 ? void 0 : _d.nodeType) === 10 /* Class */;
+            ((_b = parseNode.parent.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 47 /* ParseNodeType.StatementList */ &&
+            ((_c = parseNode.parent.parent.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 50 /* ParseNodeType.Suite */ &&
+            ((_d = parseNode.parent.parent.parent.parent) === null || _d === void 0 ? void 0 : _d.nodeType) === 10 /* ParseNodeType.Class */;
         if (!isTypeAnnotationOfClassVariable) {
             return;
         }
@@ -1165,7 +1169,7 @@ class CompletionProvider {
             return undefined;
         }
         const classVariableName = parseNode.parent.valueExpression.value;
-        const classMember = (0, typeUtils_1.lookUpClassMember)(classResults.classType, classVariableName, 16 /* SkipInstanceMembers */ | 1 /* SkipOriginalClass */);
+        const classMember = (0, typeUtils_1.lookUpClassMember)(classResults.classType, classVariableName, 16 /* MemberAccessFlags.SkipInstanceMembers */ | 1 /* MemberAccessFlags.SkipOriginalClass */);
         // First, see whether we can use semantic info to get variable type.
         if (classMember) {
             const memberType = this.evaluator.getTypeOfMember(classMember);
@@ -1206,9 +1210,9 @@ class CompletionProvider {
             return;
         }
         const printFlags = (0, sourceMapper_1.isStubFile)(this.filePath)
-            ? 1 /* ForwardDeclarations */ |
-                2 /* DoNotLimitStringLength */
-            : 2 /* DoNotLimitStringLength */;
+            ? 1 /* ParseTreeUtils.PrintExpressionFlags.ForwardDeclarations */ |
+                2 /* ParseTreeUtils.PrintExpressionFlags.DoNotLimitStringLength */
+            : 2 /* ParseTreeUtils.PrintExpressionFlags.DoNotLimitStringLength */;
         const text = `${ParseTreeUtils.printExpression(declWithTypeAnnotations[declWithTypeAnnotations.length - 1].typeAnnotationNode, printFlags)}`;
         this.addNameToCompletions(text, vscode_languageserver_1.CompletionItemKind.Reference, priorWord, completionMap, {
             sortText: this._makeSortText(SortCategory.LikelyKeyword, text),
@@ -1255,12 +1259,12 @@ class CompletionProvider {
         if (!symbolTable) {
             return undefined;
         }
-        const funcParensDisabled = ((_a = partialName.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 28 /* Function */ ? true : undefined;
+        const funcParensDisabled = ((_a = partialName.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 28 /* ParseNodeType.Function */ ? true : undefined;
         const completionMap = new CompletionMap();
         const enclosingFunc = ParseTreeUtils.getEnclosingFunction(partialName);
         symbolTable.forEach((symbol, name) => {
             const decl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(symbol);
-            if (!decl || decl.type !== 5 /* Function */) {
+            if (!decl || decl.type !== 5 /* DeclarationType.Function */) {
                 return;
             }
             if (!decl.node.decorators.some((d) => this._isOverload(d))) {
@@ -1317,16 +1321,16 @@ class CompletionProvider {
             ellipsisForDefault = false;
         }
         const printFlags = (0, sourceMapper_1.isStubFile)(this.filePath)
-            ? 1 /* ForwardDeclarations */ |
-                2 /* DoNotLimitStringLength */
-            : 2 /* DoNotLimitStringLength */;
+            ? 1 /* ParseTreeUtils.PrintExpressionFlags.ForwardDeclarations */ |
+                2 /* ParseTreeUtils.PrintExpressionFlags.DoNotLimitStringLength */
+            : 2 /* ParseTreeUtils.PrintExpressionFlags.DoNotLimitStringLength */;
         const paramList = node.parameters
             .map((param, index) => {
             let paramString = '';
-            if (param.category === 1 /* ArgsList */) {
+            if (param.category === 1 /* ParameterCategory.ArgsList */) {
                 paramString += '*';
             }
-            else if (param.category === 2 /* KwargsDict */) {
+            else if (param.category === 2 /* ParameterCategory.KwargsDict */) {
                 paramString += '**';
             }
             if (param.name) {
@@ -1343,7 +1347,7 @@ class CompletionProvider {
                 const useEllipsis = ellipsisForDefault !== null && ellipsisForDefault !== void 0 ? ellipsisForDefault : !this.isSimpleDefault(param.defaultValue);
                 paramString += useEllipsis ? '...' : ParseTreeUtils.printExpression(param.defaultValue, printFlags);
             }
-            if (!paramString && !param.name && param.category === 0 /* Simple */) {
+            if (!paramString && !param.name && param.category === 0 /* ParameterCategory.Simple */) {
                 return '/';
             }
             return paramString;
@@ -1369,12 +1373,12 @@ class CompletionProvider {
         const isIndexArgument = this._isIndexArgument(parseNode);
         // If the user typed a "." as part of a number, don't present
         // any completion options.
-        if (!isIndexArgument && parseNode.nodeType === 40 /* Number */) {
+        if (!isIndexArgument && parseNode.nodeType === 40 /* ParseNodeType.Number */) {
             return undefined;
         }
         // Are we within a "with Y as []"?
         // Don't add any completion options.
-        if (((_a = parseNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 59 /* WithItem */ &&
+        if (((_a = parseNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 59 /* ParseNodeType.WithItem */ &&
             parseNode.parent === ((_b = parseNode.parent.target) === null || _b === void 0 ? void 0 : _b.parent)) {
             return undefined;
         }
@@ -1414,12 +1418,12 @@ class CompletionProvider {
     _isIndexArgument(node) {
         const currentNode = node.parent;
         return (currentNode &&
-            currentNode.nodeType === 1 /* Argument */ &&
-            currentNode.argumentCategory === 0 /* Simple */ &&
+            currentNode.nodeType === 1 /* ParseNodeType.Argument */ &&
+            currentNode.argumentCategory === 0 /* ArgumentCategory.Simple */ &&
             currentNode.parent &&
-            currentNode.parent.nodeType === 24 /* Index */ &&
+            currentNode.parent.nodeType === 24 /* ParseNodeType.Index */ &&
             currentNode.parent.baseExpression &&
-            currentNode.parent.baseExpression.nodeType === 38 /* Name */);
+            currentNode.parent.baseExpression.nodeType === 38 /* ParseNodeType.Name */);
     }
     _addCallArgumentCompletions(parseNode, priorWord, priorText, postText, atArgument, completionMap) {
         // If we're within the argument list of a call, add parameter names.
@@ -1478,21 +1482,21 @@ class CompletionProvider {
             return [];
         }
         return node.entries.flatMap((entry) => {
-            if (entry.nodeType !== 17 /* DictionaryKeyEntry */ || (excludeIds === null || excludeIds === void 0 ? void 0 : excludeIds.has(entry.keyExpression.id))) {
+            if (entry.nodeType !== 17 /* ParseNodeType.DictionaryKeyEntry */ || (excludeIds === null || excludeIds === void 0 ? void 0 : excludeIds.has(entry.keyExpression.id))) {
                 return [];
             }
-            if (entry.keyExpression.nodeType === 48 /* StringList */) {
+            if (entry.keyExpression.nodeType === 48 /* ParseNodeType.StringList */) {
                 return [entry.keyExpression.strings.map((s) => s.value).join('')];
             }
             return [];
         });
         function getDictionaryLikeNode(parseNode) {
             // this method assumes the given parseNode is either a child of a dictionary or a dictionary itself
-            if (parseNode.nodeType === 15 /* Dictionary */) {
+            if (parseNode.nodeType === 15 /* ParseNodeType.Dictionary */) {
                 return parseNode;
             }
             let curNode = parseNode;
-            while (curNode && curNode.nodeType !== 15 /* Dictionary */ && curNode.nodeType !== 45 /* Set */) {
+            while (curNode && curNode.nodeType !== 15 /* ParseNodeType.Dictionary */ && curNode.nodeType !== 45 /* ParseNodeType.Set */) {
                 curNode = curNode.parent;
                 if (!curNode) {
                     return;
@@ -1518,7 +1522,7 @@ class CompletionProvider {
             // Handle both overloaded and non-overloaded functions.
             (0, typeUtils_1.doForEachSignature)(getItemType, (signature) => {
                 if (signature.details.parameters.length >= 1 &&
-                    signature.details.parameters[0].category === 0 /* Simple */) {
+                    signature.details.parameters[0].category === 0 /* ParameterCategory.Simple */) {
                     typesToCombine.push(types_1.FunctionType.getEffectiveParameterType(signature, 0));
                 }
             });
@@ -1552,7 +1556,7 @@ class CompletionProvider {
                 return keys;
             }
         }
-        if (indexNode.baseExpression.nodeType !== 38 /* Name */) {
+        if (indexNode.baseExpression.nodeType !== 38 /* ParseNodeType.Name */) {
             // This completion only supports simple name case
             return [];
         }
@@ -1560,7 +1564,7 @@ class CompletionProvider {
         const declarations = (_a = this.evaluator.getDeclarationsForNameNode(indexNode.baseExpression)) !== null && _a !== void 0 ? _a : [];
         const declaration = declarations.length > 0 ? declarations[0] : undefined;
         if (!declaration ||
-            (declaration.type !== 1 /* Variable */ && declaration.type !== 2 /* Parameter */)) {
+            (declaration.type !== 1 /* DeclarationType.Variable */ && declaration.type !== 2 /* DeclarationType.Parameter */)) {
             return [];
         }
         if (declaration.path !== this.filePath) {
@@ -1578,12 +1582,12 @@ class CompletionProvider {
         const results = documentSymbolCollector_1.DocumentSymbolCollector.collectFromNode(this.program, indexNode.baseExpression, this.cancellationToken, startingNode);
         const keys = new Set();
         for (const result of results) {
-            const node = ((_d = result.node.parent) === null || _d === void 0 ? void 0 : _d.nodeType) === 54 /* TypeAnnotation */ ? result.node.parent : result.node;
-            if (((_e = node.parent) === null || _e === void 0 ? void 0 : _e.nodeType) === 3 /* Assignment */ ||
-                ((_f = node.parent) === null || _f === void 0 ? void 0 : _f.nodeType) === 4 /* AssignmentExpression */) {
-                if (node.parent.rightExpression.nodeType === 15 /* Dictionary */) {
+            const node = ((_d = result.node.parent) === null || _d === void 0 ? void 0 : _d.nodeType) === 54 /* ParseNodeType.TypeAnnotation */ ? result.node.parent : result.node;
+            if (((_e = node.parent) === null || _e === void 0 ? void 0 : _e.nodeType) === 3 /* ParseNodeType.Assignment */ ||
+                ((_f = node.parent) === null || _f === void 0 ? void 0 : _f.nodeType) === 4 /* ParseNodeType.AssignmentExpression */) {
+                if (node.parent.rightExpression.nodeType === 15 /* ParseNodeType.Dictionary */) {
                     const dictionary = node.parent.rightExpression;
-                    for (const entry of dictionary.entries.filter((e) => e.nodeType === 17 /* DictionaryKeyEntry */)) {
+                    for (const entry of dictionary.entries.filter((e) => e.nodeType === 17 /* ParseNodeType.DictionaryKeyEntry */)) {
                         const key = this.parseResults.text
                             .substr(entry.keyExpression.start, entry.keyExpression.length)
                             .trim();
@@ -1591,7 +1595,7 @@ class CompletionProvider {
                             keys.add(key);
                     }
                 }
-                if (node.parent.rightExpression.nodeType === 9 /* Call */) {
+                if (node.parent.rightExpression.nodeType === 9 /* ParseNodeType.Call */) {
                     const call = node.parent.rightExpression;
                     const type = this.evaluator.getType(call.leftExpression);
                     if (!type || !(0, types_1.isInstantiableClass)(type) || !types_1.ClassType.isBuiltIn(type, 'dict')) {
@@ -1606,9 +1610,9 @@ class CompletionProvider {
                     }
                 }
             }
-            if (((_j = node.parent) === null || _j === void 0 ? void 0 : _j.nodeType) === 24 /* Index */ &&
+            if (((_j = node.parent) === null || _j === void 0 ? void 0 : _j.nodeType) === 24 /* ParseNodeType.Index */ &&
                 node.parent.items.length === 1 &&
-                node.parent.items[0].valueExpression.nodeType !== 0 /* Error */ &&
+                node.parent.items[0].valueExpression.nodeType !== 0 /* ParseNodeType.Error */ &&
                 !textRange_1.TextRange.containsRange(node.parent, invocationNode)) {
                 const indexArgument = node.parent.items[0];
                 const key = this.parseResults.text
@@ -1642,7 +1646,7 @@ class CompletionProvider {
         }
         // See if the type evaluator can determine the expected type for this node.
         // ex) a: Literal["str"] = /* here */
-        const nodeForExpectedType = parentAndChild.parent.nodeType === 3 /* Assignment */
+        const nodeForExpectedType = parentAndChild.parent.nodeType === 3 /* ParseNodeType.Assignment */
             ? parentAndChild.parent.rightExpression === parentAndChild.child
                 ? parentAndChild.child
                 : undefined
@@ -1662,16 +1666,16 @@ class CompletionProvider {
             // If the dictionary is not yet filled in, it will appear as though it's
             // a set initially.
             let dictOrSet;
-            if (nodeForKey.nodeType === 17 /* DictionaryKeyEntry */ &&
+            if (nodeForKey.nodeType === 17 /* ParseNodeType.DictionaryKeyEntry */ &&
                 nodeForKey.keyExpression === parentAndChild.child &&
-                ((_a = nodeForKey.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 15 /* Dictionary */) {
+                ((_a = nodeForKey.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 15 /* ParseNodeType.Dictionary */) {
                 dictOrSet = nodeForKey.parent;
             }
-            else if ((nodeForKey === null || nodeForKey === void 0 ? void 0 : nodeForKey.nodeType) === 45 /* Set */) {
+            else if ((nodeForKey === null || nodeForKey === void 0 ? void 0 : nodeForKey.nodeType) === 45 /* ParseNodeType.Set */) {
                 dictOrSet = nodeForKey;
             }
             if (dictOrSet) {
-                if (this._tryAddTypedDictKeysFromDictionary(dictOrSet, parseNode.nodeType === 49 /* String */ ? parseNode : undefined, priorWord, priorText, postText, completionMap)) {
+                if (this._tryAddTypedDictKeysFromDictionary(dictOrSet, parseNode.nodeType === 49 /* ParseNodeType.String */ ? parseNode : undefined, priorWord, priorText, postText, completionMap)) {
                     return true;
                 }
             }
@@ -1679,8 +1683,8 @@ class CompletionProvider {
         // a: DictType = { .... }
         // a[/* here */] or a['/* here */'] or a[variable/*here*/]
         const argument = parentAndChild.parent;
-        if (argument.nodeType === 1 /* Argument */ && ((_b = argument.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 24 /* Index */) {
-            const priorTextInString = parseNode.nodeType === 49 /* String */ ? priorText : '';
+        if (argument.nodeType === 1 /* ParseNodeType.Argument */ && ((_b = argument.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 24 /* ParseNodeType.Index */) {
+            const priorTextInString = parseNode.nodeType === 49 /* ParseNodeType.String */ ? priorText : '';
             if (this._tryAddTypedDictKeysFromIndexer(argument.parent, priorWord, priorTextInString, postText, completionMap)) {
                 return true;
             }
@@ -1696,7 +1700,7 @@ class CompletionProvider {
                     continue;
                 }
                 const stringLiteral = /^["|'].*["|']$/.test(key);
-                if (parseNode.nodeType === 49 /* String */ && !stringLiteral) {
+                if (parseNode.nodeType === 49 /* ParseNodeType.String */ && !stringLiteral) {
                     continue;
                 }
                 keyFound = true;
@@ -1717,8 +1721,8 @@ class CompletionProvider {
         }
         // if c == "/* here */"
         const comparison = parentAndChild.parent;
-        const supportedOperators = [2 /* Assign */, 12 /* Equals */, 28 /* NotEquals */];
-        if (comparison.nodeType === 7 /* BinaryOperation */ && supportedOperators.includes(comparison.operator)) {
+        const supportedOperators = [2 /* OperatorType.Assign */, 12 /* OperatorType.Equals */, 28 /* OperatorType.NotEquals */];
+        if (comparison.nodeType === 7 /* ParseNodeType.BinaryOperation */ && supportedOperators.includes(comparison.operator)) {
             const type = this.evaluator.getType(comparison.leftExpression);
             if (type && (0, typeUtils_1.containsLiteralType)(type)) {
                 this._addLiteralValuesForTargetType(type, priorWord, priorText, postText, completionMap);
@@ -1727,7 +1731,7 @@ class CompletionProvider {
         }
         // if c := "/* here */"
         const assignmentExpression = parentAndChild.parent;
-        if (assignmentExpression.nodeType === 4 /* AssignmentExpression */ &&
+        if (assignmentExpression.nodeType === 4 /* ParseNodeType.AssignmentExpression */ &&
             assignmentExpression.rightExpression === parentAndChild.child) {
             const type = this.evaluator.getType(assignmentExpression.name);
             if (type && (0, typeUtils_1.containsLiteralType)(type)) {
@@ -1739,11 +1743,11 @@ class CompletionProvider {
         // match c:
         //     case /* here */
         const caseNode = parentAndChild.parent;
-        if (caseNode.nodeType === 64 /* Case */ &&
-            caseNode.pattern.nodeType === 0 /* Error */ &&
-            caseNode.pattern.category === 11 /* MissingPattern */ &&
+        if (caseNode.nodeType === 64 /* ParseNodeType.Case */ &&
+            caseNode.pattern.nodeType === 0 /* ParseNodeType.Error */ &&
+            caseNode.pattern.category === 11 /* ErrorExpressionCategory.MissingPattern */ &&
             caseNode.suite === parentAndChild.child &&
-            ((_c = caseNode.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 63 /* Match */) {
+            ((_c = caseNode.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 63 /* ParseNodeType.Match */) {
             const type = this.evaluator.getType(caseNode.parent.subjectExpression);
             if (type && (0, typeUtils_1.containsLiteralType)(type)) {
                 this._addLiteralValuesForTargetType(type, priorWord, priorText, postText, completionMap);
@@ -1754,18 +1758,18 @@ class CompletionProvider {
         //     case "/* here */"
         //     case Sym/*here*/
         const patternLiteral = parentAndChild.parent;
-        if ((patternLiteral.nodeType === 67 /* PatternLiteral */ ||
-            patternLiteral.nodeType === 69 /* PatternCapture */) &&
-            ((_d = patternLiteral.parent) === null || _d === void 0 ? void 0 : _d.nodeType) === 66 /* PatternAs */ &&
-            ((_e = patternLiteral.parent.parent) === null || _e === void 0 ? void 0 : _e.nodeType) === 64 /* Case */ &&
-            ((_f = patternLiteral.parent.parent.parent) === null || _f === void 0 ? void 0 : _f.nodeType) === 63 /* Match */) {
+        if ((patternLiteral.nodeType === 67 /* ParseNodeType.PatternLiteral */ ||
+            patternLiteral.nodeType === 69 /* ParseNodeType.PatternCapture */) &&
+            ((_d = patternLiteral.parent) === null || _d === void 0 ? void 0 : _d.nodeType) === 66 /* ParseNodeType.PatternAs */ &&
+            ((_e = patternLiteral.parent.parent) === null || _e === void 0 ? void 0 : _e.nodeType) === 64 /* ParseNodeType.Case */ &&
+            ((_f = patternLiteral.parent.parent.parent) === null || _f === void 0 ? void 0 : _f.nodeType) === 63 /* ParseNodeType.Match */) {
             const type = this.evaluator.getType(patternLiteral.parent.parent.parent.subjectExpression);
             if (type && (0, typeUtils_1.containsLiteralType)(type)) {
                 this._addLiteralValuesForTargetType(type, priorWord, priorText, postText, completionMap);
                 return true;
             }
         }
-        if (parseNode.nodeType === 49 /* String */) {
+        if (parseNode.nodeType === 49 /* ParseNodeType.String */) {
             const offset = (0, positionUtils_1.convertPositionToOffset)(this.position, this.parseResults.tokenizerOutput.lines);
             const atArgument = parseNode.parent.start < offset && offset < textRange_1.TextRange.getEnd(parseNode);
             this._addCallArgumentCompletions(parseNode, priorWord, priorText, postText, atArgument, completionMap);
@@ -1777,13 +1781,13 @@ class CompletionProvider {
             if (!node.parent) {
                 return undefined;
             }
-            if (node.nodeType !== 49 /* String */) {
+            if (node.nodeType !== 49 /* ParseNodeType.String */) {
                 return { parent: node.parent, child: node };
             }
             if (!node.parent.parent) {
                 return undefined;
             }
-            if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 48 /* StringList */ || node.parent.strings.length > 1) {
+            if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 48 /* ParseNodeType.StringList */ || node.parent.strings.length > 1) {
                 return undefined;
             }
             return { parent: node.parent.parent, child: node.parent };
@@ -1879,9 +1883,9 @@ class CompletionProvider {
         // permitted. For example, f"..{typedDict[|<= here ]}", we need to use
         // single quotes. Note that this doesn't account for deeper nested
         // f-strings.
-        if (this._stringLiteralContainer.flags & 64 /* Format */) {
+        if (this._stringLiteralContainer.flags & 64 /* StringTokenFlags.Format */) {
             quoteCharacter =
-                this._stringLiteralContainer.flags & 1 /* SingleQuote */ ? doubleQuote : singleQuote;
+                this._stringLiteralContainer.flags & 1 /* StringTokenFlags.SingleQuote */ ? doubleQuote : singleQuote;
         }
         if (stringValue) {
             filterText = stringValue;
@@ -2041,7 +2045,7 @@ class CompletionProvider {
                     scope = scope.parent;
                 }
                 // If this is a class scope, add symbols from parent classes.
-                if (curNode.nodeType === 10 /* Class */) {
+                if (curNode.nodeType === 10 /* ParseNodeType.Class */) {
                     const classType = this.evaluator.getTypeOfClass(curNode);
                     if (classType && (0, types_1.isInstantiableClass)(classType.classType)) {
                         classType.classType.details.mro.forEach((baseClass, index) => {
@@ -2053,7 +2057,7 @@ class CompletionProvider {
                                     // Return only variables, not methods or classes.
                                     return symbol
                                         .getDeclarations()
-                                        .some((decl) => decl.type === 1 /* Variable */);
+                                        .some((decl) => decl.type === 1 /* DeclarationType.Variable */);
                                 }, priorWord, node, 
                                 /* isInImport */ false, 
                                 /* boundObject */ undefined, completionMap);
@@ -2092,20 +2096,20 @@ class CompletionProvider {
     }
     _shouldShowAutoParensForClass(symbol, node) {
         var _a, _b;
-        if (symbol.getDeclarations().every((d) => d.type !== 6 /* Class */)) {
+        if (symbol.getDeclarations().every((d) => d.type !== 6 /* DeclarationType.Class */)) {
             // Not actually a class, so yes show parens.
             return true;
         }
         // If an argument then show parens for classes if not a class argument.
-        if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 1 /* Argument */ && ((_b = node.parent.parent) === null || _b === void 0 ? void 0 : _b.nodeType) !== 10 /* Class */) {
+        if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 1 /* ParseNodeType.Argument */ && ((_b = node.parent.parent) === null || _b === void 0 ? void 0 : _b.nodeType) !== 10 /* ParseNodeType.Class */) {
             return true;
         }
         // Otherwise only show when the class is being assigned to a variable.
         const nodeIndex = ParseTreeUtils.getTokenIndexAtLeft(this.parseResults.tokenizerOutput.tokens, node.start);
         const prevToken = ParseTreeUtils.getTokenAtIndex(this.parseResults.tokenizerOutput.tokens, nodeIndex);
         return (prevToken &&
-            prevToken.type === 9 /* Operator */ &&
-            prevToken.operatorType === 2 /* Assign */);
+            prevToken.type === 9 /* TokenType.Operator */ &&
+            prevToken.operatorType === 2 /* OperatorType.Assign */);
     }
     _getAutoImportText(importName, importFrom, importAlias) {
         const autoImportText = (0, tooltipUtils_1.getAutoImportText)(importName, importFrom, importAlias);
@@ -2171,21 +2175,21 @@ class CompletionProvider {
             return vscode_languageserver_1.CompletionItemKind.Variable;
         }
         switch (resolvedDeclaration.type) {
-            case 0 /* Intrinsic */:
+            case 0 /* DeclarationType.Intrinsic */:
                 return resolvedDeclaration.intrinsicType === 'class'
                     ? vscode_languageserver_1.CompletionItemKind.Class
                     : vscode_languageserver_1.CompletionItemKind.Variable;
-            case 2 /* Parameter */:
+            case 2 /* DeclarationType.Parameter */:
                 return vscode_languageserver_1.CompletionItemKind.Variable;
-            case 3 /* TypeParameter */:
+            case 3 /* DeclarationType.TypeParameter */:
                 return vscode_languageserver_1.CompletionItemKind.TypeParameter;
-            case 1 /* Variable */:
+            case 1 /* DeclarationType.Variable */:
                 return resolvedDeclaration.isConstant || resolvedDeclaration.isFinal
                     ? vscode_languageserver_1.CompletionItemKind.Constant
                     : vscode_languageserver_1.CompletionItemKind.Variable;
-            case 4 /* TypeAlias */:
+            case 4 /* DeclarationType.TypeAlias */:
                 return vscode_languageserver_1.CompletionItemKind.Variable;
-            case 5 /* Function */: {
+            case 5 /* DeclarationType.Function */: {
                 if (this._isPossiblePropertyDeclaration(resolvedDeclaration)) {
                     const functionType = this.evaluator.getTypeOfFunction(resolvedDeclaration.node);
                     if (functionType &&
@@ -2195,26 +2199,26 @@ class CompletionProvider {
                 }
                 return resolvedDeclaration.isMethod ? vscode_languageserver_1.CompletionItemKind.Method : vscode_languageserver_1.CompletionItemKind.Function;
             }
-            case 6 /* Class */:
-            case 7 /* SpecialBuiltInClass */:
+            case 6 /* DeclarationType.Class */:
+            case 7 /* DeclarationType.SpecialBuiltInClass */:
                 return vscode_languageserver_1.CompletionItemKind.Class;
-            case 8 /* Alias */:
+            case 8 /* DeclarationType.Alias */:
                 return vscode_languageserver_1.CompletionItemKind.Module;
         }
     }
     _convertTypeToItemKind(type) {
         switch (type.category) {
-            case 7 /* Module */:
+            case 7 /* TypeCategory.Module */:
                 return vscode_languageserver_1.CompletionItemKind.Module;
-            case 6 /* Class */:
+            case 6 /* TypeCategory.Class */:
                 return vscode_languageserver_1.CompletionItemKind.Class;
-            case 4 /* Function */:
-            case 5 /* OverloadedFunction */:
+            case 4 /* TypeCategory.Function */:
+            case 5 /* TypeCategory.OverloadedFunction */:
                 if ((0, typeUtils_1.isMaybeDescriptorInstance)(type, /* requireSetter */ false)) {
                     return vscode_languageserver_1.CompletionItemKind.Property;
                 }
                 return vscode_languageserver_1.CompletionItemKind.Function;
-            case 9 /* TypeVar */:
+            case 9 /* TypeCategory.TypeVar */:
                 return vscode_languageserver_1.CompletionItemKind.TypeParameter;
             default:
                 return vscode_languageserver_1.CompletionItemKind.Variable;
@@ -2233,7 +2237,7 @@ class CompletionProvider {
         // the "import" keyword as a completion.
         if (!node.hasTrailingDot &&
             node.parent &&
-            node.parent.nodeType === 22 /* ImportFrom */ &&
+            node.parent.nodeType === 22 /* ParseNodeType.ImportFrom */ &&
             node.parent.missingImportKeyword) {
             const keyword = 'import';
             const completionItem = vscode_languageserver_1.CompletionItem.create(keyword);