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

package/dist/analyzer/parseTreeUtils.js

@@ -9,7 +9,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];
@@ -46,7 +50,7 @@ var PrintExpressionFlags;
     // By default, strings are truncated. If this flag
     // is specified, the full original string is used.
     PrintExpressionFlags[PrintExpressionFlags["DoNotLimitStringLength"] = 2] = "DoNotLimitStringLength";
-})(PrintExpressionFlags = exports.PrintExpressionFlags || (exports.PrintExpressionFlags = {}));
+})(PrintExpressionFlags || (exports.PrintExpressionFlags = PrintExpressionFlags = {}));
 // Returns the depth of the node as measured from the root
 // of the parse tree.
 function getNodeDepth(node) {
@@ -94,7 +98,7 @@ function findNodeByOffset(node, offset) {
         if (containingChild) {
             // For augmented assignments, prefer the dest expression, which is a clone
             // of the left expression but is used to hold the type of the operation result.
-            if (node.nodeType === 5 /* AugmentedAssignment */ && containingChild === node.leftExpression) {
+            if (node.nodeType === 5 /* ParseNodeType.AugmentedAssignment */ && containingChild === node.leftExpression) {
                 return node.destExpression;
             }
             return containingChild;
@@ -108,7 +112,7 @@ function isCompliantWithNodeRangeRules(node) {
     // 1. Children are all contained within the parent.
     // 2. Children have non-overlapping ranges.
     // 3. Children are listed in increasing order.
-    return node.nodeType !== 3 /* Assignment */ && node.nodeType !== 48 /* StringList */;
+    return node.nodeType !== 3 /* ParseNodeType.Assignment */ && node.nodeType !== 48 /* ParseNodeType.StringList */;
 }
 exports.isCompliantWithNodeRangeRules = isCompliantWithNodeRangeRules;
 function getClassFullName(classNode, moduleName, className) {
@@ -135,10 +139,10 @@ function getTypeSourceId(node) {
 exports.getTypeSourceId = getTypeSourceId;
 function printArgument(node, flags) {
     let argStr = '';
-    if (node.argumentCategory === 1 /* UnpackedList */) {
+    if (node.argumentCategory === 1 /* ArgumentCategory.UnpackedList */) {
         argStr = '*';
     }
-    else if (node.argumentCategory === 2 /* UnpackedDictionary */) {
+    else if (node.argumentCategory === 2 /* ArgumentCategory.UnpackedDictionary */) {
         argStr = '**';
     }
     if (node.name) {
@@ -148,37 +152,37 @@ function printArgument(node, flags) {
     return argStr;
 }
 exports.printArgument = printArgument;
-function printExpression(node, flags = 0 /* None */) {
+function printExpression(node, flags = 0 /* PrintExpressionFlags.None */) {
     switch (node.nodeType) {
-        case 38 /* Name */: {
+        case 38 /* ParseNodeType.Name */: {
             return node.value;
         }
-        case 35 /* MemberAccess */: {
+        case 35 /* ParseNodeType.MemberAccess */: {
             return printExpression(node.leftExpression, flags) + '.' + node.memberName.value;
         }
-        case 9 /* Call */: {
+        case 9 /* ParseNodeType.Call */: {
             let lhs = printExpression(node.leftExpression, flags);
             // Some left-hand expressions must be parenthesized.
-            if (node.leftExpression.nodeType !== 35 /* MemberAccess */ &&
-                node.leftExpression.nodeType !== 38 /* Name */ &&
-                node.leftExpression.nodeType !== 24 /* Index */ &&
-                node.leftExpression.nodeType !== 9 /* Call */) {
+            if (node.leftExpression.nodeType !== 35 /* ParseNodeType.MemberAccess */ &&
+                node.leftExpression.nodeType !== 38 /* ParseNodeType.Name */ &&
+                node.leftExpression.nodeType !== 24 /* ParseNodeType.Index */ &&
+                node.leftExpression.nodeType !== 9 /* ParseNodeType.Call */) {
                 lhs = `(${lhs})`;
             }
             return lhs + '(' + node.arguments.map((arg) => printArgument(arg, flags)).join(', ') + ')';
         }
-        case 24 /* Index */: {
+        case 24 /* ParseNodeType.Index */: {
             return (printExpression(node.baseExpression, flags) +
                 '[' +
                 node.items.map((item) => printArgument(item, flags)).join(', ') +
                 (node.trailingComma ? ',' : '') +
                 ']');
         }
-        case 55 /* UnaryOperation */: {
+        case 55 /* ParseNodeType.UnaryOperation */: {
             const exprStr = printOperator(node.operator) + printExpression(node.expression, flags);
             return node.parenthesized ? `(${exprStr})` : exprStr;
         }
-        case 7 /* BinaryOperation */: {
+        case 7 /* ParseNodeType.BinaryOperation */: {
             const exprStr = printExpression(node.leftExpression, flags) +
                 ' ' +
                 printOperator(node.operator) +
@@ -186,7 +190,7 @@ function printExpression(node, flags = 0 /* None */) {
                 printExpression(node.rightExpression, flags);
             return node.parenthesized ? `(${exprStr})` : exprStr;
         }
-        case 40 /* Number */: {
+        case 40 /* ParseNodeType.Number */: {
             let value = node.value.toString();
             // If it's stored as a bigint, strip off the "n".
             if (value.endsWith('n')) {
@@ -197,8 +201,8 @@ function printExpression(node, flags = 0 /* None */) {
             }
             return value;
         }
-        case 48 /* StringList */: {
-            if (flags & 1 /* ForwardDeclarations */ && node.typeAnnotation) {
+        case 48 /* ParseNodeType.StringList */: {
+            if (flags & 1 /* PrintExpressionFlags.ForwardDeclarations */ && node.typeAnnotation) {
                 return printExpression(node.typeAnnotation, flags);
             }
             else {
@@ -209,27 +213,27 @@ function printExpression(node, flags = 0 /* None */) {
                     .join(' ');
             }
         }
-        case 49 /* String */: {
+        case 49 /* ParseNodeType.String */: {
             let exprString = '';
-            if (node.token.flags & 8 /* Raw */) {
+            if (node.token.flags & 8 /* StringTokenFlags.Raw */) {
                 exprString += 'r';
             }
-            if (node.token.flags & 16 /* Unicode */) {
+            if (node.token.flags & 16 /* StringTokenFlags.Unicode */) {
                 exprString += 'u';
             }
-            if (node.token.flags & 32 /* Bytes */) {
+            if (node.token.flags & 32 /* StringTokenFlags.Bytes */) {
                 exprString += 'b';
             }
-            if (node.token.flags & 64 /* Format */) {
+            if (node.token.flags & 64 /* StringTokenFlags.Format */) {
                 exprString += 'f';
             }
             let escapedString = node.token.escapedValue;
-            if ((flags & 2 /* DoNotLimitStringLength */) === 0) {
+            if ((flags & 2 /* PrintExpressionFlags.DoNotLimitStringLength */) === 0) {
                 const maxStringLength = 32;
                 escapedString = escapedString.substring(0, maxStringLength);
             }
-            if (node.token.flags & 4 /* Triplicate */) {
-                if (node.token.flags & 1 /* SingleQuote */) {
+            if (node.token.flags & 4 /* StringTokenFlags.Triplicate */) {
+                if (node.token.flags & 1 /* StringTokenFlags.SingleQuote */) {
                     exprString += `'''${escapedString}'''`;
                 }
                 else {
@@ -237,7 +241,7 @@ function printExpression(node, flags = 0 /* None */) {
                 }
             }
             else {
-                if (node.token.flags & 1 /* SingleQuote */) {
+                if (node.token.flags & 1 /* StringTokenFlags.SingleQuote */) {
                     exprString += `'${escapedString}'`;
                 }
                 else {
@@ -246,43 +250,43 @@ function printExpression(node, flags = 0 /* None */) {
             }
             return exprString;
         }
-        case 3 /* Assignment */: {
+        case 3 /* ParseNodeType.Assignment */: {
             return printExpression(node.leftExpression, flags) + ' = ' + printExpression(node.rightExpression, flags);
         }
-        case 4 /* AssignmentExpression */: {
+        case 4 /* ParseNodeType.AssignmentExpression */: {
             return printExpression(node.name, flags) + ' := ' + printExpression(node.rightExpression, flags);
         }
-        case 54 /* TypeAnnotation */: {
+        case 54 /* ParseNodeType.TypeAnnotation */: {
             return printExpression(node.valueExpression, flags) + ': ' + printExpression(node.typeAnnotation, flags);
         }
-        case 5 /* AugmentedAssignment */: {
+        case 5 /* ParseNodeType.AugmentedAssignment */: {
             return (printExpression(node.leftExpression, flags) +
                 ' ' +
                 printOperator(node.operator) +
                 ' ' +
                 printExpression(node.rightExpression, flags));
         }
-        case 6 /* Await */: {
+        case 6 /* ParseNodeType.Await */: {
             const exprStr = 'await ' + printExpression(node.expression, flags);
             return node.parenthesized ? `(${exprStr})` : exprStr;
         }
-        case 51 /* Ternary */: {
+        case 51 /* ParseNodeType.Ternary */: {
             return (printExpression(node.ifExpression, flags) +
                 ' if ' +
                 printExpression(node.testExpression, flags) +
                 ' else ' +
                 printExpression(node.elseExpression, flags));
         }
-        case 31 /* List */: {
+        case 31 /* ParseNodeType.List */: {
             const expressions = node.entries.map((expr) => {
                 return printExpression(expr, flags);
             });
             return `[${expressions.join(', ')}]`;
         }
-        case 56 /* Unpack */: {
+        case 56 /* ParseNodeType.Unpack */: {
             return '*' + printExpression(node.expression, flags);
         }
-        case 52 /* Tuple */: {
+        case 52 /* ParseNodeType.Tuple */: {
             const expressions = node.expressions.map((expr) => {
                 return printExpression(expr, flags);
             });
@@ -291,7 +295,7 @@ function printExpression(node, flags = 0 /* None */) {
             }
             return `(${expressions.join(', ')})`;
         }
-        case 60 /* Yield */: {
+        case 60 /* ParseNodeType.Yield */: {
             if (node.expression) {
                 return 'yield ' + printExpression(node.expression, flags);
             }
@@ -299,18 +303,18 @@ function printExpression(node, flags = 0 /* None */) {
                 return 'yield';
             }
         }
-        case 61 /* YieldFrom */: {
+        case 61 /* ParseNodeType.YieldFrom */: {
             return 'yield from ' + printExpression(node.expression, flags);
         }
-        case 18 /* Ellipsis */: {
+        case 18 /* ParseNodeType.Ellipsis */: {
             return '...';
         }
-        case 32 /* ListComprehension */: {
+        case 32 /* ParseNodeType.ListComprehension */: {
             let listStr = '<ListExpression>';
             if ((0, parseNodes_1.isExpressionNode)(node.expression)) {
                 listStr = printExpression(node.expression, flags);
             }
-            else if (node.expression.nodeType === 17 /* DictionaryKeyEntry */) {
+            else if (node.expression.nodeType === 17 /* ParseNodeType.DictionaryKeyEntry */) {
                 const keyStr = printExpression(node.expression.keyExpression, flags);
                 const valueStr = printExpression(node.expression.valueExpression, flags);
                 listStr = `${keyStr}: ${valueStr}`;
@@ -320,7 +324,7 @@ function printExpression(node, flags = 0 /* None */) {
                     ' ' +
                     node.forIfNodes
                         .map((expr) => {
-                        if (expr.nodeType === 33 /* ListComprehensionFor */) {
+                        if (expr.nodeType === 33 /* ParseNodeType.ListComprehensionFor */) {
                             return (`${expr.isAsync ? 'async ' : ''}for ` +
                                 printExpression(expr.targetExpression, flags) +
                                 ` in ${printExpression(expr.iterableExpression, flags)}`);
@@ -332,7 +336,7 @@ function printExpression(node, flags = 0 /* None */) {
                         .join(' ');
             return node.isParenthesized ? `(${listStr}})` : listStr;
         }
-        case 46 /* Slice */: {
+        case 46 /* ParseNodeType.Slice */: {
             let result = '';
             if (node.startValue || node.endValue || node.stepValue) {
                 if (node.startValue) {
@@ -350,21 +354,21 @@ function printExpression(node, flags = 0 /* None */) {
             }
             return result;
         }
-        case 30 /* Lambda */: {
+        case 30 /* ParseNodeType.Lambda */: {
             return ('lambda ' +
                 node.parameters
                     .map((param) => {
                     let paramStr = '';
-                    if (param.category === 1 /* ArgsList */) {
+                    if (param.category === 1 /* ParameterCategory.ArgsList */) {
                         paramStr += '*';
                     }
-                    else if (param.category === 2 /* KwargsDict */) {
+                    else if (param.category === 2 /* ParameterCategory.KwargsDict */) {
                         paramStr += '**';
                     }
                     if (param.name) {
                         paramStr += param.name.value;
                     }
-                    else if (param.category === 0 /* Simple */) {
+                    else if (param.category === 0 /* ParameterCategory.Simple */) {
                         paramStr += '/';
                     }
                     if (param.defaultValue) {
@@ -376,28 +380,28 @@ function printExpression(node, flags = 0 /* None */) {
                 ': ' +
                 printExpression(node.expression, flags));
         }
-        case 11 /* Constant */: {
-            if (node.constType === 33 /* True */) {
+        case 11 /* ParseNodeType.Constant */: {
+            if (node.constType === 33 /* KeywordType.True */) {
                 return 'True';
             }
-            else if (node.constType === 15 /* False */) {
+            else if (node.constType === 15 /* KeywordType.False */) {
                 return 'False';
             }
-            else if (node.constType === 9 /* Debug */) {
+            else if (node.constType === 9 /* KeywordType.Debug */) {
                 return '__debug__';
             }
-            else if (node.constType === 26 /* None */) {
+            else if (node.constType === 26 /* KeywordType.None */) {
                 return 'None';
             }
             break;
         }
-        case 15 /* Dictionary */: {
+        case 15 /* ParseNodeType.Dictionary */: {
             const dictContents = `${node.entries.map((entry) => {
-                if (entry.nodeType === 17 /* DictionaryKeyEntry */) {
+                if (entry.nodeType === 17 /* ParseNodeType.DictionaryKeyEntry */) {
                     return (`${printExpression(entry.keyExpression, flags)}: ` +
                         `${printExpression(entry.valueExpression, flags)}`);
                 }
-                else if (entry.nodeType === 16 /* DictionaryExpandEntry */) {
+                else if (entry.nodeType === 16 /* ParseNodeType.DictionaryExpandEntry */) {
                     return `**${printExpression(entry.expandExpression, flags)}`;
                 }
                 else {
@@ -409,7 +413,7 @@ function printExpression(node, flags = 0 /* None */) {
             }
             return '{}';
         }
-        case 45 /* Set */: {
+        case 45 /* ParseNodeType.Set */: {
             return node.entries.map((entry) => printExpression(entry, flags)).join(', ');
         }
     }
@@ -418,48 +422,48 @@ function printExpression(node, flags = 0 /* None */) {
 exports.printExpression = printExpression;
 function printOperator(operator) {
     const operatorMap = {
-        [0 /* Add */]: '+',
-        [1 /* AddEqual */]: '+=',
-        [2 /* Assign */]: '=',
-        [3 /* BitwiseAnd */]: '&',
-        [4 /* BitwiseAndEqual */]: '&=',
-        [5 /* BitwiseInvert */]: '~',
-        [6 /* BitwiseOr */]: '|',
-        [7 /* BitwiseOrEqual */]: '|=',
-        [8 /* BitwiseXor */]: '^',
-        [9 /* BitwiseXorEqual */]: '^=',
-        [10 /* Divide */]: '/',
-        [11 /* DivideEqual */]: '/=',
-        [12 /* Equals */]: '==',
-        [13 /* FloorDivide */]: '//',
-        [14 /* FloorDivideEqual */]: '//=',
-        [15 /* GreaterThan */]: '>',
-        [16 /* GreaterThanOrEqual */]: '>=',
-        [17 /* LeftShift */]: '<<',
-        [18 /* LeftShiftEqual */]: '<<=',
-        [19 /* LessOrGreaterThan */]: '<>',
-        [20 /* LessThan */]: '<',
-        [21 /* LessThanOrEqual */]: '<=',
-        [22 /* MatrixMultiply */]: '@',
-        [23 /* MatrixMultiplyEqual */]: '@=',
-        [24 /* Mod */]: '%',
-        [25 /* ModEqual */]: '%=',
-        [26 /* Multiply */]: '*',
-        [27 /* MultiplyEqual */]: '*=',
-        [28 /* NotEquals */]: '!=',
-        [29 /* Power */]: '**',
-        [30 /* PowerEqual */]: '**=',
-        [31 /* RightShift */]: '>>',
-        [32 /* RightShiftEqual */]: '>>=',
-        [33 /* Subtract */]: '-',
-        [34 /* SubtractEqual */]: '-=',
-        [36 /* And */]: 'and',
-        [37 /* Or */]: 'or',
-        [38 /* Not */]: 'not ',
-        [39 /* Is */]: 'is',
-        [40 /* IsNot */]: 'is not',
-        [41 /* In */]: 'in',
-        [42 /* NotIn */]: 'not in',
+        [0 /* OperatorType.Add */]: '+',
+        [1 /* OperatorType.AddEqual */]: '+=',
+        [2 /* OperatorType.Assign */]: '=',
+        [3 /* OperatorType.BitwiseAnd */]: '&',
+        [4 /* OperatorType.BitwiseAndEqual */]: '&=',
+        [5 /* OperatorType.BitwiseInvert */]: '~',
+        [6 /* OperatorType.BitwiseOr */]: '|',
+        [7 /* OperatorType.BitwiseOrEqual */]: '|=',
+        [8 /* OperatorType.BitwiseXor */]: '^',
+        [9 /* OperatorType.BitwiseXorEqual */]: '^=',
+        [10 /* OperatorType.Divide */]: '/',
+        [11 /* OperatorType.DivideEqual */]: '/=',
+        [12 /* OperatorType.Equals */]: '==',
+        [13 /* OperatorType.FloorDivide */]: '//',
+        [14 /* OperatorType.FloorDivideEqual */]: '//=',
+        [15 /* OperatorType.GreaterThan */]: '>',
+        [16 /* OperatorType.GreaterThanOrEqual */]: '>=',
+        [17 /* OperatorType.LeftShift */]: '<<',
+        [18 /* OperatorType.LeftShiftEqual */]: '<<=',
+        [19 /* OperatorType.LessOrGreaterThan */]: '<>',
+        [20 /* OperatorType.LessThan */]: '<',
+        [21 /* OperatorType.LessThanOrEqual */]: '<=',
+        [22 /* OperatorType.MatrixMultiply */]: '@',
+        [23 /* OperatorType.MatrixMultiplyEqual */]: '@=',
+        [24 /* OperatorType.Mod */]: '%',
+        [25 /* OperatorType.ModEqual */]: '%=',
+        [26 /* OperatorType.Multiply */]: '*',
+        [27 /* OperatorType.MultiplyEqual */]: '*=',
+        [28 /* OperatorType.NotEquals */]: '!=',
+        [29 /* OperatorType.Power */]: '**',
+        [30 /* OperatorType.PowerEqual */]: '**=',
+        [31 /* OperatorType.RightShift */]: '>>',
+        [32 /* OperatorType.RightShiftEqual */]: '>>=',
+        [33 /* OperatorType.Subtract */]: '-',
+        [34 /* OperatorType.SubtractEqual */]: '-=',
+        [36 /* OperatorType.And */]: 'and',
+        [37 /* OperatorType.Or */]: 'or',
+        [38 /* OperatorType.Not */]: 'not ',
+        [39 /* OperatorType.Is */]: 'is',
+        [40 /* OperatorType.IsNot */]: 'is not',
+        [41 /* OperatorType.In */]: 'in',
+        [42 /* OperatorType.NotIn */]: 'not in',
     };
     if (operatorMap[operator]) {
         return operatorMap[operator];
@@ -471,12 +475,12 @@ exports.printOperator = printOperator;
 // name in the LHS of a call expression, returns the call node.
 function getCallForName(node) {
     var _a, _b, _c;
-    if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 9 /* Call */ && node.parent.leftExpression === node) {
+    if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 9 /* ParseNodeType.Call */ && node.parent.leftExpression === node) {
         return node.parent;
     }
-    if (((_b = node.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 35 /* MemberAccess */ &&
+    if (((_b = node.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 35 /* ParseNodeType.MemberAccess */ &&
         node.parent.memberName === node &&
-        ((_c = node.parent.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 9 /* Call */ &&
+        ((_c = node.parent.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 9 /* ParseNodeType.Call */ &&
         node.parent.parent.leftExpression === node.parent) {
         return node.parent.parent;
     }
@@ -485,12 +489,12 @@ function getCallForName(node) {
 exports.getCallForName = getCallForName;
 function getDecoratorForName(node) {
     var _a, _b, _c;
-    if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 13 /* Decorator */ && node.parent.expression === node) {
+    if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 13 /* ParseNodeType.Decorator */ && node.parent.expression === node) {
         return node.parent;
     }
-    if (((_b = node.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 35 /* MemberAccess */ &&
+    if (((_b = node.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 35 /* ParseNodeType.MemberAccess */ &&
         node.parent.memberName === node &&
-        ((_c = node.parent.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 13 /* Decorator */ &&
+        ((_c = node.parent.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 13 /* ParseNodeType.Decorator */ &&
         node.parent.parent.expression === node.parent) {
         return node.parent.parent;
     }
@@ -500,7 +504,7 @@ exports.getDecoratorForName = getDecoratorForName;
 function getEnclosingSuite(node) {
     let curNode = node.parent;
     while (curNode) {
-        if (curNode.nodeType === 50 /* Suite */) {
+        if (curNode.nodeType === 50 /* ParseNodeType.Suite */) {
             return curNode;
         }
         curNode = curNode.parent;
@@ -511,13 +515,13 @@ exports.getEnclosingSuite = getEnclosingSuite;
 function getEnclosingClass(node, stopAtFunction = false) {
     let curNode = node.parent;
     while (curNode) {
-        if (curNode.nodeType === 10 /* Class */) {
+        if (curNode.nodeType === 10 /* ParseNodeType.Class */) {
             return curNode;
         }
-        if (curNode.nodeType === 36 /* Module */) {
+        if (curNode.nodeType === 36 /* ParseNodeType.Module */) {
             return undefined;
         }
-        if (curNode.nodeType === 28 /* Function */) {
+        if (curNode.nodeType === 28 /* ParseNodeType.Function */) {
             if (stopAtFunction) {
                 return undefined;
             }
@@ -530,7 +534,7 @@ exports.getEnclosingClass = getEnclosingClass;
 function getEnclosingModule(node) {
     let curNode = node.parent;
     while (curNode) {
-        if (curNode.nodeType === 36 /* Module */) {
+        if (curNode.nodeType === 36 /* ParseNodeType.Module */) {
             return curNode;
         }
         curNode = curNode.parent;
@@ -542,13 +546,13 @@ exports.getEnclosingModule = getEnclosingModule;
 function getEnclosingClassOrModule(node, stopAtFunction = false) {
     let curNode = node.parent;
     while (curNode) {
-        if (curNode.nodeType === 10 /* Class */) {
+        if (curNode.nodeType === 10 /* ParseNodeType.Class */) {
             return curNode;
         }
-        if (curNode.nodeType === 36 /* Module */) {
+        if (curNode.nodeType === 36 /* ParseNodeType.Module */) {
             return curNode;
         }
-        if (curNode.nodeType === 28 /* Function */) {
+        if (curNode.nodeType === 28 /* ParseNodeType.Function */) {
             if (stopAtFunction) {
                 return undefined;
             }
@@ -562,13 +566,13 @@ function getEnclosingFunction(node) {
     let curNode = node.parent;
     let prevNode;
     while (curNode) {
-        if (curNode.nodeType === 28 /* Function */) {
+        if (curNode.nodeType === 28 /* ParseNodeType.Function */) {
             // Don't treat a decorator as being "enclosed" in the function.
             if (!curNode.decorators.some((decorator) => decorator === prevNode)) {
                 return curNode;
             }
         }
-        if (curNode.nodeType === 10 /* Class */) {
+        if (curNode.nodeType === 10 /* ParseNodeType.Class */) {
             return undefined;
         }
         prevNode = curNode;
@@ -585,10 +589,10 @@ exports.getEnclosingFunction = getEnclosingFunction;
 function getEnclosingFunctionEvaluationScope(node) {
     let curNode = getEvaluationScopeNode(node);
     while (curNode) {
-        if (curNode.nodeType === 28 /* Function */) {
+        if (curNode.nodeType === 28 /* ParseNodeType.Function */) {
             return curNode;
         }
-        if (curNode.nodeType === 10 /* Class */ || !curNode.parent) {
+        if (curNode.nodeType === 10 /* ParseNodeType.Class */ || !curNode.parent) {
             return undefined;
         }
         curNode = getEvaluationScopeNode(curNode.parent);
@@ -599,10 +603,10 @@ exports.getEnclosingFunctionEvaluationScope = getEnclosingFunctionEvaluationScop
 function getEnclosingLambda(node) {
     let curNode = node.parent;
     while (curNode) {
-        if (curNode.nodeType === 30 /* Lambda */) {
+        if (curNode.nodeType === 30 /* ParseNodeType.Lambda */) {
             return curNode;
         }
-        if (curNode.nodeType === 50 /* Suite */) {
+        if (curNode.nodeType === 50 /* ParseNodeType.Suite */) {
             return undefined;
         }
         curNode = curNode.parent;
@@ -613,10 +617,10 @@ exports.getEnclosingLambda = getEnclosingLambda;
 function getEnclosingClassOrFunction(node) {
     let curNode = node.parent;
     while (curNode) {
-        if (curNode.nodeType === 28 /* Function */) {
+        if (curNode.nodeType === 28 /* ParseNodeType.Function */) {
             return curNode;
         }
-        if (curNode.nodeType === 10 /* Class */) {
+        if (curNode.nodeType === 10 /* ParseNodeType.Class */) {
             return curNode;
         }
         curNode = curNode.parent;
@@ -627,18 +631,18 @@ exports.getEnclosingClassOrFunction = getEnclosingClassOrFunction;
 function getEnclosingSuiteOrModule(node, stopAtFunction = false, stopAtLambda = true) {
     let curNode = node.parent;
     while (curNode) {
-        if (curNode.nodeType === 50 /* Suite */) {
+        if (curNode.nodeType === 50 /* ParseNodeType.Suite */) {
             return curNode;
         }
-        if (curNode.nodeType === 36 /* Module */) {
+        if (curNode.nodeType === 36 /* ParseNodeType.Module */) {
             return curNode;
         }
-        if (curNode.nodeType === 30 /* Lambda */) {
+        if (curNode.nodeType === 30 /* ParseNodeType.Lambda */) {
             if (stopAtLambda) {
                 return undefined;
             }
         }
-        if (curNode.nodeType === 28 /* Function */) {
+        if (curNode.nodeType === 28 /* ParseNodeType.Function */) {
             if (stopAtFunction) {
                 return undefined;
             }
@@ -656,13 +660,13 @@ function getEvaluationNodeForAssignmentExpression(node) {
     let curNode = getEvaluationScopeNode(node);
     while (curNode !== undefined) {
         switch (curNode.nodeType) {
-            case 28 /* Function */:
-            case 30 /* Lambda */:
-            case 36 /* Module */:
+            case 28 /* ParseNodeType.Function */:
+            case 30 /* ParseNodeType.Lambda */:
+            case 36 /* ParseNodeType.Module */:
                 return curNode;
-            case 10 /* Class */:
+            case 10 /* ParseNodeType.Class */:
                 return sawListComprehension ? undefined : curNode;
-            case 32 /* ListComprehension */:
+            case 32 /* ParseNodeType.ListComprehension */:
                 sawListComprehension = true;
                 curNode = getEvaluationScopeNode(curNode.parent);
                 break;
@@ -681,7 +685,7 @@ function getEvaluationScopeNode(node) {
     let curNode = node;
     let isParamNameNode = false;
     while (curNode) {
-        if (curNode.nodeType === 41 /* Parameter */ && prevNode === curNode.name) {
+        if (curNode.nodeType === 41 /* ParseNodeType.Parameter */ && prevNode === curNode.name) {
             // Note that we passed through a parameter name node.
             isParamNameNode = true;
         }
@@ -689,7 +693,7 @@ function getEvaluationScopeNode(node) {
         // we'll return this scope, but in a few cases we need to return
         // the enclosing scope instead.
         switch (curNode.nodeType) {
-            case 28 /* Function */: {
+            case 28 /* ParseNodeType.Function */: {
                 if (curNode.parameters.some((param) => param === prevNode)) {
                     if (isParamNameNode) {
                         if ((0, analyzerNodeInfo_1.getScope)(curNode) !== undefined) {
@@ -704,7 +708,7 @@ function getEvaluationScopeNode(node) {
                 }
                 break;
             }
-            case 30 /* Lambda */: {
+            case 30 /* ParseNodeType.Lambda */: {
                 if (curNode.parameters.some((param) => param === prevNode)) {
                     if (isParamNameNode) {
                         if ((0, analyzerNodeInfo_1.getScope)(curNode) !== undefined) {
@@ -719,7 +723,7 @@ function getEvaluationScopeNode(node) {
                 }
                 break;
             }
-            case 10 /* Class */: {
+            case 10 /* ParseNodeType.Class */: {
                 if (prevNode === curNode.suite) {
                     if ((0, analyzerNodeInfo_1.getScope)(curNode) !== undefined) {
                         return curNode;
@@ -727,12 +731,12 @@ function getEvaluationScopeNode(node) {
                 }
                 break;
             }
-            case 32 /* ListComprehension */: {
+            case 32 /* ParseNodeType.ListComprehension */: {
                 if ((0, analyzerNodeInfo_1.getScope)(curNode) !== undefined) {
                     // The iterable expression of the first subnode of a list comprehension
                     // is evaluated within the scope of its parent.
                     const isFirstIterableExpr = prevNode === curNode.forIfNodes[0] &&
-                        curNode.forIfNodes[0].nodeType === 33 /* ListComprehensionFor */ &&
+                        curNode.forIfNodes[0].nodeType === 33 /* ParseNodeType.ListComprehensionFor */ &&
                         curNode.forIfNodes[0].iterableExpression === prevPrevNode;
                     if (!isFirstIterableExpr) {
                         return curNode;
@@ -740,7 +744,7 @@ function getEvaluationScopeNode(node) {
                 }
                 break;
             }
-            case 36 /* Module */: {
+            case 36 /* ParseNodeType.Module */: {
                 if ((0, analyzerNodeInfo_1.getScope)(curNode) !== undefined) {
                     return curNode;
                 }
@@ -762,19 +766,19 @@ function getTypeVarScopeNode(node) {
     let curNode = node;
     while (curNode) {
         switch (curNode.nodeType) {
-            case 28 /* Function */: {
+            case 28 /* ParseNodeType.Function */: {
                 if (!curNode.decorators.some((decorator) => decorator === prevNode)) {
                     return curNode;
                 }
                 break;
             }
-            case 10 /* Class */: {
+            case 10 /* ParseNodeType.Class */: {
                 if (!curNode.decorators.some((decorator) => decorator === prevNode)) {
                     return curNode;
                 }
                 break;
             }
-            case 77 /* TypeAlias */: {
+            case 77 /* ParseNodeType.TypeAlias */: {
                 return curNode;
             }
         }
@@ -791,8 +795,8 @@ function getExecutionScopeNode(node) {
     // Classes are not considered execution scope because they are executed
     // within the context of their containing module or function. Likewise, list
     // comprehensions are executed within their container.
-    while (evaluationScope.nodeType === 10 /* Class */ ||
-        evaluationScope.nodeType === 32 /* ListComprehension */) {
+    while (evaluationScope.nodeType === 10 /* ParseNodeType.Class */ ||
+        evaluationScope.nodeType === 32 /* ParseNodeType.ListComprehension */) {
         evaluationScope = getEvaluationScopeNode(evaluationScope.parent);
     }
     return evaluationScope;
@@ -804,7 +808,7 @@ function getTypeAnnotationNode(node) {
     let prevNode = node;
     let curNode = node.parent;
     while (curNode) {
-        if (curNode.nodeType === 54 /* TypeAnnotation */) {
+        if (curNode.nodeType === 54 /* ParseNodeType.TypeAnnotation */) {
             if (curNode.typeAnnotation === prevNode) {
                 return curNode;
             }
@@ -820,8 +824,8 @@ exports.getTypeAnnotationNode = getTypeAnnotationNode;
 // left-to-right order. There is one exception, however, when an unpacked
 // iterable is used after a keyword argument.
 function getArgumentsByRuntimeOrder(node) {
-    const positionalArgs = node.arguments.filter((arg) => !arg.name && arg.argumentCategory !== 2 /* UnpackedDictionary */);
-    const keywordArgs = node.arguments.filter((arg) => !!arg.name || arg.argumentCategory === 2 /* UnpackedDictionary */);
+    const positionalArgs = node.arguments.filter((arg) => !arg.name && arg.argumentCategory !== 2 /* ArgumentCategory.UnpackedDictionary */);
+    const keywordArgs = node.arguments.filter((arg) => !!arg.name || arg.argumentCategory === 2 /* ArgumentCategory.UnpackedDictionary */);
     return positionalArgs.concat(keywordArgs);
 }
 exports.getArgumentsByRuntimeOrder = getArgumentsByRuntimeOrder;
@@ -830,13 +834,13 @@ exports.getArgumentsByRuntimeOrder = getArgumentsByRuntimeOrder;
 // whether Final is allowed for the specified node.
 function isFinalAllowedForAssignmentTarget(targetNode) {
     // Simple names always support Final.
-    if (targetNode.nodeType === 38 /* Name */) {
+    if (targetNode.nodeType === 38 /* ParseNodeType.Name */) {
         return true;
     }
     // Member access expressions like "self.x" are permitted only
     // within __init__ methods.
-    if (targetNode.nodeType === 35 /* MemberAccess */) {
-        if (targetNode.leftExpression.nodeType !== 38 /* Name */) {
+    if (targetNode.nodeType === 35 /* ParseNodeType.MemberAccess */) {
+        if (targetNode.leftExpression.nodeType !== 38 /* ParseNodeType.Name */) {
             return false;
         }
         const classNode = getEnclosingClass(targetNode);
@@ -899,31 +903,31 @@ function getParentAnnotationNode(node) {
     let curNode = node;
     let prevNode;
     while (curNode) {
-        if (curNode.nodeType === 28 /* Function */) {
+        if (curNode.nodeType === 28 /* ParseNodeType.Function */) {
             if (prevNode === curNode.returnTypeAnnotation) {
                 return prevNode;
             }
             return undefined;
         }
-        if (curNode.nodeType === 41 /* Parameter */) {
+        if (curNode.nodeType === 41 /* ParseNodeType.Parameter */) {
             if (prevNode === curNode.typeAnnotation || prevNode === curNode.typeAnnotationComment) {
                 return prevNode;
             }
             return undefined;
         }
-        if (curNode.nodeType === 3 /* Assignment */) {
+        if (curNode.nodeType === 3 /* ParseNodeType.Assignment */) {
             if (prevNode === curNode.typeAnnotationComment) {
                 return prevNode;
             }
             return undefined;
         }
-        if (curNode.nodeType === 54 /* TypeAnnotation */) {
+        if (curNode.nodeType === 54 /* ParseNodeType.TypeAnnotation */) {
             if (prevNode === curNode.typeAnnotation) {
                 return prevNode;
             }
             return undefined;
         }
-        if (curNode.nodeType === 62 /* FunctionAnnotation */) {
+        if (curNode.nodeType === 62 /* ParseNodeType.FunctionAnnotation */) {
             if (prevNode === curNode.returnTypeAnnotation || curNode.paramTypeAnnotations.some((p) => p === prevNode)) {
                 (0, debug_1.assert)(!prevNode || (0, parseNodes_1.isExpressionNode)(prevNode));
                 return prevNode;
@@ -943,13 +947,13 @@ exports.isNodeContainedWithinNodeType = isNodeContainedWithinNodeType;
 function isSuiteEmpty(node) {
     let sawEllipsis = false;
     for (const statement of node.statements) {
-        if (statement.nodeType === 47 /* StatementList */) {
+        if (statement.nodeType === 47 /* ParseNodeType.StatementList */) {
             for (const substatement of statement.statements) {
-                if (substatement.nodeType === 18 /* Ellipsis */) {
+                if (substatement.nodeType === 18 /* ParseNodeType.Ellipsis */) {
                     // Allow an ellipsis
                     sawEllipsis = true;
                 }
-                else if (substatement.nodeType === 48 /* StringList */) {
+                else if (substatement.nodeType === 48 /* ParseNodeType.StringList */) {
                     // Allow doc strings
                 }
                 else {
@@ -978,61 +982,61 @@ function containsAwaitNode(node) {
 }
 exports.containsAwaitNode = containsAwaitNode;
 function isMatchingExpression(reference, expression) {
-    if (reference.nodeType === 38 /* Name */) {
-        if (expression.nodeType === 38 /* Name */) {
+    if (reference.nodeType === 38 /* ParseNodeType.Name */) {
+        if (expression.nodeType === 38 /* ParseNodeType.Name */) {
             return reference.value === expression.value;
         }
-        else if (expression.nodeType === 4 /* AssignmentExpression */) {
+        else if (expression.nodeType === 4 /* ParseNodeType.AssignmentExpression */) {
             return reference.value === expression.name.value;
         }
         return false;
     }
-    else if (reference.nodeType === 35 /* MemberAccess */ &&
-        expression.nodeType === 35 /* MemberAccess */) {
+    else if (reference.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
+        expression.nodeType === 35 /* ParseNodeType.MemberAccess */) {
         return (isMatchingExpression(reference.leftExpression, expression.leftExpression) &&
             reference.memberName.value === expression.memberName.value);
     }
-    else if (reference.nodeType === 24 /* Index */ && expression.nodeType === 24 /* Index */) {
+    else if (reference.nodeType === 24 /* ParseNodeType.Index */ && expression.nodeType === 24 /* ParseNodeType.Index */) {
         if (!isMatchingExpression(reference.baseExpression, expression.baseExpression)) {
             return false;
         }
         if (expression.items.length !== 1 ||
             expression.trailingComma ||
             expression.items[0].name ||
-            expression.items[0].argumentCategory !== 0 /* Simple */) {
+            expression.items[0].argumentCategory !== 0 /* ArgumentCategory.Simple */) {
             return false;
         }
         const expr = reference.items[0].valueExpression;
-        if (expr.nodeType === 40 /* Number */) {
+        if (expr.nodeType === 40 /* ParseNodeType.Number */) {
             const subscriptNode = expression.items[0].valueExpression;
-            if (subscriptNode.nodeType !== 40 /* Number */ ||
+            if (subscriptNode.nodeType !== 40 /* ParseNodeType.Number */ ||
                 subscriptNode.isImaginary ||
                 !subscriptNode.isInteger) {
                 return false;
             }
             return expr.value === subscriptNode.value;
         }
-        if (expr.nodeType === 55 /* UnaryOperation */ &&
-            expr.operator === 33 /* Subtract */ &&
-            expr.expression.nodeType === 40 /* Number */) {
+        if (expr.nodeType === 55 /* ParseNodeType.UnaryOperation */ &&
+            expr.operator === 33 /* OperatorType.Subtract */ &&
+            expr.expression.nodeType === 40 /* ParseNodeType.Number */) {
             const subscriptNode = expression.items[0].valueExpression;
-            if (subscriptNode.nodeType !== 55 /* UnaryOperation */ ||
-                subscriptNode.operator !== 33 /* Subtract */ ||
-                subscriptNode.expression.nodeType !== 40 /* Number */ ||
+            if (subscriptNode.nodeType !== 55 /* ParseNodeType.UnaryOperation */ ||
+                subscriptNode.operator !== 33 /* OperatorType.Subtract */ ||
+                subscriptNode.expression.nodeType !== 40 /* ParseNodeType.Number */ ||
                 subscriptNode.expression.isImaginary ||
                 !subscriptNode.expression.isInteger) {
                 return false;
             }
             return expr.expression.value === subscriptNode.expression.value;
         }
-        if (expr.nodeType === 48 /* StringList */) {
+        if (expr.nodeType === 48 /* ParseNodeType.StringList */) {
             const referenceStringListNode = expr;
             const subscriptNode = expression.items[0].valueExpression;
             if (referenceStringListNode.strings.length === 1 &&
-                referenceStringListNode.strings[0].nodeType === 49 /* String */ &&
-                subscriptNode.nodeType === 48 /* StringList */ &&
+                referenceStringListNode.strings[0].nodeType === 49 /* ParseNodeType.String */ &&
+                subscriptNode.nodeType === 48 /* ParseNodeType.StringList */ &&
                 subscriptNode.strings.length === 1 &&
-                subscriptNode.strings[0].nodeType === 49 /* String */) {
+                subscriptNode.strings[0].nodeType === 49 /* ParseNodeType.String */) {
                 return referenceStringListNode.strings[0].value === subscriptNode.strings[0].value;
             }
         }
@@ -1042,11 +1046,11 @@ function isMatchingExpression(reference, expression) {
 }
 exports.isMatchingExpression = isMatchingExpression;
 function isPartialMatchingExpression(reference, expression) {
-    if (reference.nodeType === 35 /* MemberAccess */) {
+    if (reference.nodeType === 35 /* ParseNodeType.MemberAccess */) {
         return (isMatchingExpression(reference.leftExpression, expression) ||
             isPartialMatchingExpression(reference.leftExpression, expression));
     }
-    else if (reference.nodeType === 24 /* Index */) {
+    else if (reference.nodeType === 24 /* ParseNodeType.Index */) {
         return (isMatchingExpression(reference.baseExpression, expression) ||
             isPartialMatchingExpression(reference.baseExpression, expression));
     }
@@ -1057,13 +1061,13 @@ function isWithinDefaultParamInitializer(node) {
     let curNode = node;
     let prevNode;
     while (curNode) {
-        if (curNode.nodeType === 41 /* Parameter */ && prevNode === curNode.defaultValue) {
+        if (curNode.nodeType === 41 /* ParseNodeType.Parameter */ && prevNode === curNode.defaultValue) {
             return true;
         }
-        if (curNode.nodeType === 30 /* Lambda */ ||
-            curNode.nodeType === 28 /* Function */ ||
-            curNode.nodeType === 10 /* Class */ ||
-            curNode.nodeType === 36 /* Module */) {
+        if (curNode.nodeType === 30 /* ParseNodeType.Lambda */ ||
+            curNode.nodeType === 28 /* ParseNodeType.Function */ ||
+            curNode.nodeType === 10 /* ParseNodeType.Class */ ||
+            curNode.nodeType === 36 /* ParseNodeType.Module */) {
             return false;
         }
         prevNode = curNode;
@@ -1077,33 +1081,33 @@ function isWithinTypeAnnotation(node, requireQuotedAnnotation) {
     let prevNode;
     let isQuoted = false;
     while (curNode) {
-        if (curNode.nodeType === 41 /* Parameter */ &&
+        if (curNode.nodeType === 41 /* ParseNodeType.Parameter */ &&
             (prevNode === curNode.typeAnnotation || prevNode === curNode.typeAnnotationComment)) {
             return isQuoted || !requireQuotedAnnotation;
         }
-        if (curNode.nodeType === 28 /* Function */ && prevNode === curNode.returnTypeAnnotation) {
+        if (curNode.nodeType === 28 /* ParseNodeType.Function */ && prevNode === curNode.returnTypeAnnotation) {
             return isQuoted || !requireQuotedAnnotation;
         }
-        if (curNode.nodeType === 28 /* Function */ && prevNode === curNode.functionAnnotationComment) {
+        if (curNode.nodeType === 28 /* ParseNodeType.Function */ && prevNode === curNode.functionAnnotationComment) {
             // Type comments are always considered forward declarations even though
             // they're not "quoted".
             return true;
         }
-        if (curNode.nodeType === 54 /* TypeAnnotation */ && prevNode === curNode.typeAnnotation) {
+        if (curNode.nodeType === 54 /* ParseNodeType.TypeAnnotation */ && prevNode === curNode.typeAnnotation) {
             return isQuoted || !requireQuotedAnnotation;
         }
-        if (curNode.nodeType === 3 /* Assignment */ && prevNode === curNode.typeAnnotationComment) {
+        if (curNode.nodeType === 3 /* ParseNodeType.Assignment */ && prevNode === curNode.typeAnnotationComment) {
             // Type comments are always considered forward declarations even though
             // they're not "quoted".
             return true;
         }
-        if (curNode.nodeType === 48 /* StringList */ && prevNode === curNode.typeAnnotation) {
+        if (curNode.nodeType === 48 /* ParseNodeType.StringList */ && prevNode === curNode.typeAnnotation) {
             isQuoted = true;
         }
-        if (curNode.nodeType === 30 /* Lambda */ ||
-            curNode.nodeType === 28 /* Function */ ||
-            curNode.nodeType === 10 /* Class */ ||
-            curNode.nodeType === 36 /* Module */) {
+        if (curNode.nodeType === 30 /* ParseNodeType.Lambda */ ||
+            curNode.nodeType === 28 /* ParseNodeType.Function */ ||
+            curNode.nodeType === 10 /* ParseNodeType.Class */ ||
+            curNode.nodeType === 36 /* ParseNodeType.Module */) {
             return false;
         }
         prevNode = curNode;
@@ -1116,20 +1120,20 @@ function isWithinAnnotationComment(node) {
     let curNode = node;
     let prevNode;
     while (curNode) {
-        if (curNode.nodeType === 28 /* Function */ && prevNode === curNode.functionAnnotationComment) {
+        if (curNode.nodeType === 28 /* ParseNodeType.Function */ && prevNode === curNode.functionAnnotationComment) {
             // Type comments are always considered forward declarations even though
             // they're not "quoted".
             return true;
         }
-        if (curNode.nodeType === 3 /* Assignment */ && prevNode === curNode.typeAnnotationComment) {
+        if (curNode.nodeType === 3 /* ParseNodeType.Assignment */ && prevNode === curNode.typeAnnotationComment) {
             // Type comments are always considered forward declarations even though
             // they're not "quoted".
             return true;
         }
-        if (curNode.nodeType === 30 /* Lambda */ ||
-            curNode.nodeType === 28 /* Function */ ||
-            curNode.nodeType === 10 /* Class */ ||
-            curNode.nodeType === 36 /* Module */) {
+        if (curNode.nodeType === 30 /* ParseNodeType.Lambda */ ||
+            curNode.nodeType === 28 /* ParseNodeType.Function */ ||
+            curNode.nodeType === 10 /* ParseNodeType.Class */ ||
+            curNode.nodeType === 36 /* ParseNodeType.Module */) {
             return false;
         }
         prevNode = curNode;
@@ -1142,11 +1146,11 @@ function isWithinLoop(node) {
     let curNode = node;
     while (curNode) {
         switch (curNode.nodeType) {
-            case 26 /* For */:
-            case 57 /* While */: {
+            case 26 /* ParseNodeType.For */:
+            case 57 /* ParseNodeType.While */: {
                 return true;
             }
-            case 36 /* Module */: {
+            case 36 /* ParseNodeType.Module */: {
                 break;
             }
         }
@@ -1160,18 +1164,18 @@ function isWithinTryBlock(node, treatWithAsTryBlock = false) {
     let prevNode;
     while (curNode) {
         switch (curNode.nodeType) {
-            case 53 /* Try */: {
+            case 53 /* ParseNodeType.Try */: {
                 return curNode.trySuite === prevNode;
             }
-            case 58 /* With */: {
+            case 58 /* ParseNodeType.With */: {
                 if (treatWithAsTryBlock && curNode.suite === prevNode) {
                     return true;
                 }
                 break;
             }
-            case 28 /* Function */:
-            case 36 /* Module */:
-            case 10 /* Class */: {
+            case 28 /* ParseNodeType.Function */:
+            case 36 /* ParseNodeType.Module */:
+            case 10 /* ParseNodeType.Class */: {
                 return false;
             }
         }
@@ -1186,7 +1190,7 @@ function isWithinAssertExpression(node) {
     let prevNode;
     while (curNode) {
         switch (curNode.nodeType) {
-            case 2 /* Assert */: {
+            case 2 /* ParseNodeType.Assert */: {
                 return curNode.testExpression === prevNode;
             }
         }
@@ -1201,7 +1205,7 @@ function getDocString(statements) {
     if (statements.length === 0) {
         return undefined;
     }
-    if (statements[0].nodeType !== 47 /* StatementList */) {
+    if (statements[0].nodeType !== 47 /* ParseNodeType.StatementList */) {
         return undefined;
     }
     if (!isDocString(statements[0])) {
@@ -1218,7 +1222,7 @@ exports.getDocString = getDocString;
 function isDocString(statementList) {
     // If the first statement in the suite isn't a StringNode,
     // assume there is no docString.
-    if (statementList.statements.length === 0 || statementList.statements[0].nodeType !== 48 /* StringList */) {
+    if (statementList.statements.length === 0 || statementList.statements[0].nodeType !== 48 /* ParseNodeType.StringList */) {
         return false;
     }
     // A docstring can consist of multiple joined strings in a single expression.
@@ -1227,7 +1231,7 @@ function isDocString(statementList) {
         return false;
     }
     // Any f-strings invalidate the entire docstring.
-    if (strings.some((n) => n.nodeType === 27 /* FormatString */)) {
+    if (strings.some((n) => n.nodeType === 27 /* ParseNodeType.FormatString */)) {
         return false;
     }
     // It's up to the user to convert normalize/convert this as needed.
@@ -1241,20 +1245,20 @@ exports.isDocString = isDocString;
 // not specified in the original list.
 function isAssignmentToDefaultsFollowingNamedTuple(callNode) {
     var _a, _b;
-    if (callNode.nodeType !== 9 /* Call */ ||
+    if (callNode.nodeType !== 9 /* ParseNodeType.Call */ ||
         !callNode.parent ||
-        callNode.parent.nodeType !== 3 /* Assignment */ ||
-        callNode.parent.leftExpression.nodeType !== 38 /* Name */ ||
+        callNode.parent.nodeType !== 3 /* ParseNodeType.Assignment */ ||
+        callNode.parent.leftExpression.nodeType !== 38 /* ParseNodeType.Name */ ||
         !callNode.parent.parent ||
-        callNode.parent.parent.nodeType !== 47 /* StatementList */) {
+        callNode.parent.parent.nodeType !== 47 /* ParseNodeType.StatementList */) {
         return false;
     }
     const namedTupleAssignedName = callNode.parent.leftExpression.value;
     const statementList = callNode.parent.parent;
     if (statementList.statements[0] !== callNode.parent ||
         !statementList.parent ||
-        !(statementList.parent.nodeType === 36 /* Module */ ||
-            statementList.parent.nodeType === 50 /* Suite */)) {
+        !(statementList.parent.nodeType === 36 /* ParseNodeType.Module */ ||
+            statementList.parent.nodeType === 50 /* ParseNodeType.Suite */)) {
         return false;
     }
     const moduleOrSuite = statementList.parent;
@@ -1265,22 +1269,22 @@ function isAssignmentToDefaultsFollowingNamedTuple(callNode) {
     statementIndex++;
     while (statementIndex < moduleOrSuite.statements.length) {
         const nextStatement = moduleOrSuite.statements[statementIndex];
-        if (nextStatement.nodeType !== 47 /* StatementList */) {
+        if (nextStatement.nodeType !== 47 /* ParseNodeType.StatementList */) {
             break;
         }
-        if (((_a = nextStatement.statements[0]) === null || _a === void 0 ? void 0 : _a.nodeType) === 48 /* StringList */) {
+        if (((_a = nextStatement.statements[0]) === null || _a === void 0 ? void 0 : _a.nodeType) === 48 /* ParseNodeType.StringList */) {
             // Skip over comments
             statementIndex++;
             continue;
         }
-        if (((_b = nextStatement.statements[0]) === null || _b === void 0 ? void 0 : _b.nodeType) === 3 /* Assignment */) {
+        if (((_b = nextStatement.statements[0]) === null || _b === void 0 ? void 0 : _b.nodeType) === 3 /* ParseNodeType.Assignment */) {
             const assignNode = nextStatement.statements[0];
-            if (assignNode.leftExpression.nodeType === 35 /* MemberAccess */ &&
+            if (assignNode.leftExpression.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
                 assignNode.leftExpression.memberName.value === '__defaults__') {
                 const defaultTarget = assignNode.leftExpression.leftExpression;
-                if (defaultTarget.nodeType === 35 /* MemberAccess */ &&
+                if (defaultTarget.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
                     defaultTarget.memberName.value === '__new__' &&
-                    defaultTarget.leftExpression.nodeType === 38 /* Name */ &&
+                    defaultTarget.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
                     defaultTarget.leftExpression.value === namedTupleAssignedName) {
                     return true;
                 }
@@ -1331,10 +1335,10 @@ exports.CallNodeWalker = CallNodeWalker;
 function getEnclosingParameter(node) {
     let curNode = node;
     while (curNode) {
-        if (curNode.nodeType === 41 /* Parameter */) {
+        if (curNode.nodeType === 41 /* ParseNodeType.Parameter */) {
             return curNode;
         }
-        if (curNode.nodeType === 28 /* Function */) {
+        if (curNode.nodeType === 28 /* ParseNodeType.Function */) {
             return undefined;
         }
         curNode = curNode.parent;
@@ -1348,7 +1352,7 @@ function getCallNodeAndActiveParameterIndex(node, insertionOffset, tokens) {
     let callNode;
     while (curNode !== undefined) {
         // make sure we only look at callNodes when we are inside their arguments
-        if (curNode.nodeType === 9 /* Call */) {
+        if (curNode.nodeType === 9 /* ParseNodeType.Call */) {
             if (isOffsetInsideCallArgs(tokens, curNode, insertionOffset)) {
                 callNode = curNode;
                 break;
@@ -1364,7 +1368,7 @@ function getCallNodeAndActiveParameterIndex(node, insertionOffset, tokens) {
         return undefined;
     }
     const tokenAtEnd = getTokenAt(tokens, endPosition - 1);
-    if (insertionOffset === endPosition && (tokenAtEnd === null || tokenAtEnd === void 0 ? void 0 : tokenAtEnd.type) === 14 /* CloseParenthesis */) {
+    if (insertionOffset === endPosition && (tokenAtEnd === null || tokenAtEnd === void 0 ? void 0 : tokenAtEnd.type) === 14 /* TokenType.CloseParenthesis */) {
         return undefined;
     }
     let addedActive = false;
@@ -1388,8 +1392,8 @@ function getCallNodeAndActiveParameterIndex(node, insertionOffset, tokens) {
             for (let i = endTokenIndex; i < tokens.count; i++) {
                 const tok = tokens.getItemAt(i);
                 switch (tok.type) {
-                    case 12 /* Comma */:
-                    case 14 /* CloseParenthesis */:
+                    case 12 /* TokenType.Comma */:
+                    case 14 /* TokenType.CloseParenthesis */:
                         break;
                     default:
                         continue;
@@ -1431,7 +1435,7 @@ function getCallNodeAndActiveParameterIndex(node, insertionOffset, tokens) {
             return true;
         }
         const nextToken = tokens.getItemAt(index + 1);
-        if (nextToken.type === 13 /* OpenParenthesis */ && offset < textRange_1.TextRange.getEnd(nextToken)) {
+        if (nextToken.type === 13 /* TokenType.OpenParenthesis */ && offset < textRange_1.TextRange.getEnd(nextToken)) {
             // Position must be after '('.
             return false;
         }
@@ -1468,7 +1472,7 @@ function getTokenAtLeft(tokens, position, includeWhitespace = false, includeZero
 }
 exports.getTokenAtLeft = getTokenAtLeft;
 function isWhitespace(token) {
-    return token.type === 2 /* NewLine */ || token.type === 3 /* Indent */ || token.type === 4 /* Dedent */;
+    return token.type === 2 /* TokenType.NewLine */ || token.type === 3 /* TokenType.Indent */ || token.type === 4 /* TokenType.Dedent */;
 }
 exports.isWhitespace = isWhitespace;
 function getTokenAtIndex(tokens, index) {
@@ -1508,161 +1512,161 @@ function findTokenAfter(parseResults, offset, predicate) {
 exports.findTokenAfter = findTokenAfter;
 function printParseNodeType(type) {
     switch (type) {
-        case 0 /* Error */:
+        case 0 /* ParseNodeType.Error */:
             return 'Error';
-        case 1 /* Argument */:
+        case 1 /* ParseNodeType.Argument */:
             return 'Argument';
-        case 2 /* Assert */:
+        case 2 /* ParseNodeType.Assert */:
             return 'Assert';
-        case 3 /* Assignment */:
+        case 3 /* ParseNodeType.Assignment */:
             return 'Assignment';
-        case 4 /* AssignmentExpression */:
+        case 4 /* ParseNodeType.AssignmentExpression */:
             return 'AssignmentExpression';
-        case 5 /* AugmentedAssignment */:
+        case 5 /* ParseNodeType.AugmentedAssignment */:
             return 'AugmentedAssignment';
-        case 6 /* Await */:
+        case 6 /* ParseNodeType.Await */:
             return 'Await';
-        case 7 /* BinaryOperation */:
+        case 7 /* ParseNodeType.BinaryOperation */:
             return 'BinaryOperation';
-        case 8 /* Break */:
+        case 8 /* ParseNodeType.Break */:
             return 'Break';
-        case 9 /* Call */:
+        case 9 /* ParseNodeType.Call */:
             return 'Call';
-        case 10 /* Class */:
+        case 10 /* ParseNodeType.Class */:
             return 'Class';
-        case 11 /* Constant */:
+        case 11 /* ParseNodeType.Constant */:
             return 'Constant';
-        case 12 /* Continue */:
+        case 12 /* ParseNodeType.Continue */:
             return 'Continue';
-        case 13 /* Decorator */:
+        case 13 /* ParseNodeType.Decorator */:
             return 'Decorator';
-        case 14 /* Del */:
+        case 14 /* ParseNodeType.Del */:
             return 'Del';
-        case 15 /* Dictionary */:
+        case 15 /* ParseNodeType.Dictionary */:
             return 'Dictionary';
-        case 16 /* DictionaryExpandEntry */:
+        case 16 /* ParseNodeType.DictionaryExpandEntry */:
             return 'DictionaryExpandEntry';
-        case 17 /* DictionaryKeyEntry */:
+        case 17 /* ParseNodeType.DictionaryKeyEntry */:
             return 'DictionaryKeyEntry';
-        case 18 /* Ellipsis */:
+        case 18 /* ParseNodeType.Ellipsis */:
             return 'Ellipsis';
-        case 19 /* If */:
+        case 19 /* ParseNodeType.If */:
             return 'If';
-        case 20 /* Import */:
+        case 20 /* ParseNodeType.Import */:
             return 'Import';
-        case 21 /* ImportAs */:
+        case 21 /* ParseNodeType.ImportAs */:
             return 'ImportAs';
-        case 22 /* ImportFrom */:
+        case 22 /* ParseNodeType.ImportFrom */:
             return 'ImportFrom';
-        case 23 /* ImportFromAs */:
+        case 23 /* ParseNodeType.ImportFromAs */:
             return 'ImportFromAs';
-        case 24 /* Index */:
+        case 24 /* ParseNodeType.Index */:
             return 'Index';
-        case 25 /* Except */:
+        case 25 /* ParseNodeType.Except */:
             return 'Except';
-        case 26 /* For */:
+        case 26 /* ParseNodeType.For */:
             return 'For';
-        case 27 /* FormatString */:
+        case 27 /* ParseNodeType.FormatString */:
             return 'FormatString';
-        case 28 /* Function */:
+        case 28 /* ParseNodeType.Function */:
             return 'Function';
-        case 29 /* Global */:
+        case 29 /* ParseNodeType.Global */:
             return 'Global';
-        case 30 /* Lambda */:
+        case 30 /* ParseNodeType.Lambda */:
             return 'Lambda';
-        case 31 /* List */:
+        case 31 /* ParseNodeType.List */:
             return 'List';
-        case 32 /* ListComprehension */:
+        case 32 /* ParseNodeType.ListComprehension */:
             return 'ListComprehension';
-        case 33 /* ListComprehensionFor */:
+        case 33 /* ParseNodeType.ListComprehensionFor */:
             return 'ListComprehensionFor';
-        case 34 /* ListComprehensionIf */:
+        case 34 /* ParseNodeType.ListComprehensionIf */:
             return 'ListComprehensionIf';
-        case 35 /* MemberAccess */:
+        case 35 /* ParseNodeType.MemberAccess */:
             return 'MemberAccess';
-        case 36 /* Module */:
+        case 36 /* ParseNodeType.Module */:
             return 'Module';
-        case 37 /* ModuleName */:
+        case 37 /* ParseNodeType.ModuleName */:
             return 'ModuleName';
-        case 38 /* Name */:
+        case 38 /* ParseNodeType.Name */:
             return 'Name';
-        case 39 /* Nonlocal */:
+        case 39 /* ParseNodeType.Nonlocal */:
             return 'Nonlocal';
-        case 40 /* Number */:
+        case 40 /* ParseNodeType.Number */:
             return 'Number';
-        case 41 /* Parameter */:
+        case 41 /* ParseNodeType.Parameter */:
             return 'Parameter';
-        case 42 /* Pass */:
+        case 42 /* ParseNodeType.Pass */:
             return 'Pass';
-        case 43 /* Raise */:
+        case 43 /* ParseNodeType.Raise */:
             return 'Raise';
-        case 44 /* Return */:
+        case 44 /* ParseNodeType.Return */:
             return 'Return';
-        case 45 /* Set */:
+        case 45 /* ParseNodeType.Set */:
             return 'Set';
-        case 46 /* Slice */:
+        case 46 /* ParseNodeType.Slice */:
             return 'Slice';
-        case 47 /* StatementList */:
+        case 47 /* ParseNodeType.StatementList */:
             return 'StatementList';
-        case 48 /* StringList */:
+        case 48 /* ParseNodeType.StringList */:
             return 'StringList';
-        case 49 /* String */:
+        case 49 /* ParseNodeType.String */:
             return 'String';
-        case 50 /* Suite */:
+        case 50 /* ParseNodeType.Suite */:
             return 'Suite';
-        case 51 /* Ternary */:
+        case 51 /* ParseNodeType.Ternary */:
             return 'Ternary';
-        case 52 /* Tuple */:
+        case 52 /* ParseNodeType.Tuple */:
             return 'Tuple';
-        case 53 /* Try */:
+        case 53 /* ParseNodeType.Try */:
             return 'Try';
-        case 54 /* TypeAnnotation */:
+        case 54 /* ParseNodeType.TypeAnnotation */:
             return 'TypeAnnotation';
-        case 55 /* UnaryOperation */:
+        case 55 /* ParseNodeType.UnaryOperation */:
             return 'UnaryOperation';
-        case 56 /* Unpack */:
+        case 56 /* ParseNodeType.Unpack */:
             return 'Unpack';
-        case 57 /* While */:
+        case 57 /* ParseNodeType.While */:
             return 'While';
-        case 58 /* With */:
+        case 58 /* ParseNodeType.With */:
             return 'With';
-        case 59 /* WithItem */:
+        case 59 /* ParseNodeType.WithItem */:
             return 'WithItem';
-        case 60 /* Yield */:
+        case 60 /* ParseNodeType.Yield */:
             return 'Yield';
-        case 61 /* YieldFrom */:
+        case 61 /* ParseNodeType.YieldFrom */:
             return 'YieldFrom';
-        case 62 /* FunctionAnnotation */:
+        case 62 /* ParseNodeType.FunctionAnnotation */:
             return 'FunctionAnnotation';
-        case 63 /* Match */:
+        case 63 /* ParseNodeType.Match */:
             return 'Match';
-        case 64 /* Case */:
+        case 64 /* ParseNodeType.Case */:
             return 'Case';
-        case 65 /* PatternSequence */:
+        case 65 /* ParseNodeType.PatternSequence */:
             return 'PatternSequence';
-        case 66 /* PatternAs */:
+        case 66 /* ParseNodeType.PatternAs */:
             return 'PatternAs';
-        case 67 /* PatternLiteral */:
+        case 67 /* ParseNodeType.PatternLiteral */:
             return 'PatternLiteral';
-        case 68 /* PatternClass */:
+        case 68 /* ParseNodeType.PatternClass */:
             return 'PatternClass';
-        case 69 /* PatternCapture */:
+        case 69 /* ParseNodeType.PatternCapture */:
             return 'PatternCapture';
-        case 70 /* PatternMapping */:
+        case 70 /* ParseNodeType.PatternMapping */:
             return 'PatternMapping';
-        case 71 /* PatternMappingKeyEntry */:
+        case 71 /* ParseNodeType.PatternMappingKeyEntry */:
             return 'PatternMappingKeyEntry';
-        case 72 /* PatternMappingExpandEntry */:
+        case 72 /* ParseNodeType.PatternMappingExpandEntry */:
             return 'PatternMappingExpandEntry';
-        case 73 /* PatternValue */:
+        case 73 /* ParseNodeType.PatternValue */:
             return 'PatternValue';
-        case 74 /* PatternClassArgument */:
+        case 74 /* ParseNodeType.PatternClassArgument */:
             return 'PatternClassArgument';
-        case 75 /* TypeParameter */:
+        case 75 /* ParseNodeType.TypeParameter */:
             return 'TypeParameter';
-        case 76 /* TypeParameterList */:
+        case 76 /* ParseNodeType.TypeParameterList */:
             return 'TypeParameterList';
-        case 77 /* TypeAlias */:
+        case 77 /* ParseNodeType.TypeAlias */:
             return 'TypeAlias';
     }
     (0, debug_1.assertNever)(type);
@@ -1673,52 +1677,52 @@ function isWriteAccess(node) {
     let curNode = prevNode.parent;
     while (curNode) {
         switch (curNode.nodeType) {
-            case 3 /* Assignment */: {
+            case 3 /* ParseNodeType.Assignment */: {
                 return prevNode === curNode.leftExpression;
             }
-            case 5 /* AugmentedAssignment */: {
+            case 5 /* ParseNodeType.AugmentedAssignment */: {
                 return prevNode === curNode.leftExpression;
             }
-            case 4 /* AssignmentExpression */: {
+            case 4 /* ParseNodeType.AssignmentExpression */: {
                 return prevNode === curNode.name;
             }
-            case 14 /* Del */: {
+            case 14 /* ParseNodeType.Del */: {
                 return true;
             }
-            case 26 /* For */: {
+            case 26 /* ParseNodeType.For */: {
                 return prevNode === curNode.targetExpression;
             }
-            case 21 /* ImportAs */: {
+            case 21 /* ParseNodeType.ImportAs */: {
                 return (prevNode === curNode.alias ||
                     (curNode.module.nameParts.length > 0 && prevNode === curNode.module.nameParts[0]));
             }
-            case 23 /* ImportFromAs */: {
+            case 23 /* ParseNodeType.ImportFromAs */: {
                 return prevNode === curNode.alias || (!curNode.alias && prevNode === curNode.name);
             }
-            case 35 /* MemberAccess */: {
+            case 35 /* ParseNodeType.MemberAccess */: {
                 if (prevNode !== curNode.memberName) {
                     return false;
                 }
                 break;
             }
-            case 25 /* Except */: {
+            case 25 /* ParseNodeType.Except */: {
                 return prevNode === curNode.name;
             }
-            case 58 /* With */: {
+            case 58 /* ParseNodeType.With */: {
                 return curNode.withItems.some((item) => item === prevNode);
             }
-            case 33 /* ListComprehensionFor */: {
+            case 33 /* ParseNodeType.ListComprehensionFor */: {
                 return prevNode === curNode.targetExpression;
             }
-            case 54 /* TypeAnnotation */: {
+            case 54 /* ParseNodeType.TypeAnnotation */: {
                 if (prevNode === curNode.typeAnnotation) {
                     return false;
                 }
                 break;
             }
-            case 28 /* Function */:
-            case 10 /* Class */:
-            case 36 /* Module */: {
+            case 28 /* ParseNodeType.Function */:
+            case 10 /* ParseNodeType.Class */:
+            case 36 /* ParseNodeType.Module */: {
                 return false;
             }
         }
@@ -1730,7 +1734,7 @@ function isWriteAccess(node) {
 exports.isWriteAccess = isWriteAccess;
 function getModuleNode(node) {
     let current = node;
-    while (current && current.nodeType !== 36 /* Module */) {
+    while (current && current.nodeType !== 36 /* ParseNodeType.Module */) {
         current = current.parent;
     }
     return current;
@@ -1744,15 +1748,15 @@ exports.getFileInfoFromNode = getFileInfoFromNode;
 function isFunctionSuiteEmpty(node) {
     let isEmpty = true;
     node.suite.statements.forEach((statement) => {
-        if (statement.nodeType === 0 /* Error */) {
+        if (statement.nodeType === 0 /* ParseNodeType.Error */) {
             return;
         }
-        else if (statement.nodeType === 47 /* StatementList */) {
+        else if (statement.nodeType === 47 /* ParseNodeType.StatementList */) {
             statement.statements.forEach((subStatement) => {
                 // Allow docstrings, ellipsis, and pass statements.
-                if (subStatement.nodeType !== 18 /* Ellipsis */ &&
-                    subStatement.nodeType !== 48 /* StringList */ &&
-                    subStatement.nodeType !== 42 /* Pass */) {
+                if (subStatement.nodeType !== 18 /* ParseNodeType.Ellipsis */ &&
+                    subStatement.nodeType !== 48 /* ParseNodeType.StringList */ &&
+                    subStatement.nodeType !== 42 /* ParseNodeType.Pass */) {
                     isEmpty = false;
                 }
             });
@@ -1792,32 +1796,32 @@ function getTypeAnnotationForParameter(node, paramIndex) {
 exports.getTypeAnnotationForParameter = getTypeAnnotationForParameter;
 function isImportModuleName(node) {
     var _a, _b;
-    return ((_b = (_a = getFirstAncestorOrSelfOfKind(node, 37 /* ModuleName */)) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 21 /* ImportAs */;
+    return ((_b = (_a = getFirstAncestorOrSelfOfKind(node, 37 /* ParseNodeType.ModuleName */)) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 21 /* ParseNodeType.ImportAs */;
 }
 exports.isImportModuleName = isImportModuleName;
 function isImportAlias(node) {
     var _a;
-    return ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 21 /* ImportAs */ && node.parent.alias === node;
+    return ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 21 /* ParseNodeType.ImportAs */ && node.parent.alias === node;
 }
 exports.isImportAlias = isImportAlias;
 function isFromImportModuleName(node) {
     var _a, _b;
-    return ((_b = (_a = getFirstAncestorOrSelfOfKind(node, 37 /* ModuleName */)) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 22 /* ImportFrom */;
+    return ((_b = (_a = getFirstAncestorOrSelfOfKind(node, 37 /* ParseNodeType.ModuleName */)) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 22 /* ParseNodeType.ImportFrom */;
 }
 exports.isFromImportModuleName = isFromImportModuleName;
 function isFromImportName(node) {
     var _a;
-    return ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 23 /* ImportFromAs */ && node.parent.name === node;
+    return ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 23 /* ParseNodeType.ImportFromAs */ && node.parent.name === node;
 }
 exports.isFromImportName = isFromImportName;
 function isFromImportAlias(node) {
     var _a;
-    return ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 23 /* ImportFromAs */ && node.parent.alias === node;
+    return ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 23 /* ParseNodeType.ImportFromAs */ && node.parent.alias === node;
 }
 exports.isFromImportAlias = isFromImportAlias;
 function isLastNameOfModuleName(node) {
     var _a;
-    if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 37 /* ModuleName */) {
+    if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 37 /* ParseNodeType.ModuleName */) {
         return false;
     }
     const module = node.parent;
@@ -1855,7 +1859,7 @@ function getDottedNameWithGivenNodeAsLastName(node) {
     //           MemberAccess (ex, a.b.c)
     //    MemberAccess     Name
     //  Name       Name
-    if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 35 /* MemberAccess */) {
+    if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 35 /* ParseNodeType.MemberAccess */) {
         return node;
     }
     if (node.parent.leftExpression === node) {
@@ -1875,10 +1879,10 @@ exports.getDottedNameWithGivenNodeAsLastName = getDottedNameWithGivenNodeAsLastN
 function getDecoratorName(decorator) {
     function getExpressionName(node) {
         var _a;
-        if (node.nodeType === 38 /* Name */ || node.nodeType === 35 /* MemberAccess */) {
+        if (node.nodeType === 38 /* ParseNodeType.Name */ || node.nodeType === 35 /* ParseNodeType.MemberAccess */) {
             return (_a = getDottedName(node)) === null || _a === void 0 ? void 0 : _a.map((n) => n.value).join('.');
         }
-        if (node.nodeType === 9 /* Call */) {
+        if (node.nodeType === 9 /* ParseNodeType.Call */) {
             return getExpressionName(node.leftExpression);
         }
         return undefined;
@@ -1889,7 +1893,7 @@ exports.getDecoratorName = getDecoratorName;
 function getDottedName(node) {
     // ex) [a] or [a].b
     // simple case, [a]
-    if (node.nodeType === 38 /* Name */) {
+    if (node.nodeType === 38 /* ParseNodeType.Name */) {
         return [node];
     }
     // dotted name case.
@@ -1899,13 +1903,13 @@ function getDottedName(node) {
     }
     return undefined;
     function _getDottedName(node, names) {
-        if (node.nodeType === 38 /* Name */) {
+        if (node.nodeType === 38 /* ParseNodeType.Name */) {
             names.push(node);
             return true;
         }
         names.push(node.memberName);
-        if (node.leftExpression.nodeType === 38 /* Name */ ||
-            node.leftExpression.nodeType === 35 /* MemberAccess */) {
+        if (node.leftExpression.nodeType === 38 /* ParseNodeType.Name */ ||
+            node.leftExpression.nodeType === 35 /* ParseNodeType.MemberAccess */) {
             return _getDottedName(node.leftExpression, names);
         }
         return false;
@@ -1914,11 +1918,11 @@ function getDottedName(node) {
 exports.getDottedName = getDottedName;
 function getFirstNameOfDottedName(node) {
     // ex) [a] or [a].b
-    if (node.nodeType === 38 /* Name */) {
+    if (node.nodeType === 38 /* ParseNodeType.Name */) {
         return node;
     }
-    if (node.leftExpression.nodeType === 38 /* Name */ ||
-        node.leftExpression.nodeType === 35 /* MemberAccess */) {
+    if (node.leftExpression.nodeType === 38 /* ParseNodeType.Name */ ||
+        node.leftExpression.nodeType === 35 /* ParseNodeType.MemberAccess */) {
         return getFirstNameOfDottedName(node.leftExpression);
     }
     return undefined;
@@ -1927,7 +1931,7 @@ exports.getFirstNameOfDottedName = getFirstNameOfDottedName;
 function isFirstNameOfDottedName(node) {
     var _a;
     // ex) [A] or [A].B.C.D
-    if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 35 /* MemberAccess */) {
+    if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 35 /* ParseNodeType.MemberAccess */) {
         return true;
     }
     if (node.parent.leftExpression === node) {
@@ -1939,17 +1943,17 @@ exports.isFirstNameOfDottedName = isFirstNameOfDottedName;
 function isLastNameOfDottedName(node) {
     var _a, _b;
     // ex) A or D.C.B.[A]
-    if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 35 /* MemberAccess */) {
+    if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 35 /* ParseNodeType.MemberAccess */) {
         return true;
     }
-    if (node.parent.leftExpression.nodeType !== 38 /* Name */ &&
-        node.parent.leftExpression.nodeType !== 35 /* MemberAccess */) {
+    if (node.parent.leftExpression.nodeType !== 38 /* ParseNodeType.Name */ &&
+        node.parent.leftExpression.nodeType !== 35 /* ParseNodeType.MemberAccess */) {
         return false;
     }
     if (node.parent.leftExpression === node) {
         return false;
     }
-    return ((_b = node.parent.parent) === null || _b === void 0 ? void 0 : _b.nodeType) !== 35 /* MemberAccess */;
+    return ((_b = node.parent.parent) === null || _b === void 0 ? void 0 : _b.nodeType) !== 35 /* ParseNodeType.MemberAccess */;
 }
 exports.isLastNameOfDottedName = isLastNameOfDottedName;
 function getStringNodeValueRange(node) {
@@ -1958,7 +1962,7 @@ function getStringNodeValueRange(node) {
 exports.getStringNodeValueRange = getStringNodeValueRange;
 function getStringValueRange(token) {
     const length = token.quoteMarkLength;
-    const hasEnding = !(token.flags & 65536 /* Unterminated */);
+    const hasEnding = !(token.flags & 65536 /* StringTokenFlags.Unterminated */);
     return textRange_1.TextRange.create(token.start + length, token.length - length - (hasEnding ? length : 0));
 }
 exports.getStringValueRange = getStringValueRange;
@@ -2011,20 +2015,20 @@ function isValidLocationForFutureImport(node) {
     (0, debug_1.assert)(module);
     let sawDocString = false;
     for (const statement of module.statements) {
-        if (statement.nodeType !== 47 /* StatementList */) {
+        if (statement.nodeType !== 47 /* ParseNodeType.StatementList */) {
             return false;
         }
         for (const simpleStatement of statement.statements) {
             if (simpleStatement === node) {
                 return true;
             }
-            if (simpleStatement.nodeType === 48 /* StringList */) {
+            if (simpleStatement.nodeType === 48 /* ParseNodeType.StringList */) {
                 if (sawDocString) {
                     return false;
                 }
                 sawDocString = true;
             }
-            else if (simpleStatement.nodeType === 22 /* ImportFrom */) {
+            else if (simpleStatement.nodeType === 22 /* ParseNodeType.ImportFrom */) {
                 if (simpleStatement.module.leadingDots !== 0 ||
                     simpleStatement.module.nameParts.length !== 1 ||
                     simpleStatement.module.nameParts[0].value !== '__future__') {
@@ -2044,16 +2048,16 @@ exports.isValidLocationForFutureImport = isValidLocationForFutureImport;
 // "a < b and b < c".
 function operatorSupportsChaining(op) {
     switch (op) {
-        case 12 /* Equals */:
-        case 28 /* NotEquals */:
-        case 20 /* LessThan */:
-        case 21 /* LessThanOrEqual */:
-        case 15 /* GreaterThan */:
-        case 16 /* GreaterThanOrEqual */:
-        case 39 /* Is */:
-        case 40 /* IsNot */:
-        case 41 /* In */:
-        case 42 /* NotIn */:
+        case 12 /* OperatorType.Equals */:
+        case 28 /* OperatorType.NotEquals */:
+        case 20 /* OperatorType.LessThan */:
+        case 21 /* OperatorType.LessThanOrEqual */:
+        case 15 /* OperatorType.GreaterThan */:
+        case 16 /* OperatorType.GreaterThanOrEqual */:
+        case 39 /* OperatorType.Is */:
+        case 40 /* OperatorType.IsNot */:
+        case 41 /* OperatorType.In */:
+        case 42 /* OperatorType.NotIn */:
             return true;
     }
     return false;
@@ -2081,11 +2085,11 @@ function _getStartPositionIfMultipleStatementsAreOnSameLine(range, tokenPosition
     for (let index = tokenIndex - 1; index > currentIndex; index--) {
         const token = tokenizerOutput.tokens.getItemAt(index);
         // Eat up indentation
-        if (token.type === 3 /* Indent */ || token.type === 4 /* Dedent */) {
+        if (token.type === 3 /* TokenType.Indent */ || token.type === 4 /* TokenType.Dedent */) {
             continue;
         }
         // If previous token is new line, use default.
-        if (token.type === 2 /* NewLine */) {
+        if (token.type === 2 /* TokenType.NewLine */) {
             return undefined;
         }
         // Anything else (ex, semicolon), use statement start as it is.
@@ -2116,7 +2120,7 @@ function _getEndPositionIfMultipleStatementsAreOnSameLine(range, tokenPosition,
     for (let index = tokenIndex; index < currentIndex; index++) {
         const token = tokenizerOutput.tokens.getItemAt(index);
         // Eat up semicolon or new line.
-        if (token.type === 11 /* Semicolon */ || token.type === 2 /* NewLine */) {
+        if (token.type === 11 /* TokenType.Semicolon */ || token.type === 2 /* TokenType.NewLine */) {
             foundStatementEnd = true;
             continue;
         }
@@ -2134,15 +2138,15 @@ function getVariableDocStringNode(node) {
     let curNode = node;
     let annotationNode;
     while (curNode) {
-        if (curNode.nodeType === 3 /* Assignment */) {
+        if (curNode.nodeType === 3 /* ParseNodeType.Assignment */) {
             break;
         }
-        if (curNode.nodeType === 54 /* TypeAnnotation */ && !annotationNode) {
+        if (curNode.nodeType === 54 /* ParseNodeType.TypeAnnotation */ && !annotationNode) {
             annotationNode = curNode;
         }
         curNode = curNode.parent;
     }
-    if ((curNode === null || curNode === void 0 ? void 0 : curNode.nodeType) !== 3 /* Assignment */) {
+    if ((curNode === null || curNode === void 0 ? void 0 : curNode.nodeType) !== 3 /* ParseNodeType.Assignment */) {
         // Allow a simple annotation statement to have a docstring even
         // though PEP 258 doesn't mention this case. This PEP pre-dated
         // PEP 526, so it didn't contemplate this situation.
@@ -2154,12 +2158,12 @@ function getVariableDocStringNode(node) {
         }
     }
     const parentNode = curNode.parent;
-    if ((parentNode === null || parentNode === void 0 ? void 0 : parentNode.nodeType) !== 47 /* StatementList */) {
+    if ((parentNode === null || parentNode === void 0 ? void 0 : parentNode.nodeType) !== 47 /* ParseNodeType.StatementList */) {
         return undefined;
     }
     const suiteOrModule = parentNode.parent;
     if (!suiteOrModule ||
-        (suiteOrModule.nodeType !== 36 /* Module */ && suiteOrModule.nodeType !== 50 /* Suite */)) {
+        (suiteOrModule.nodeType !== 36 /* ParseNodeType.Module */ && suiteOrModule.nodeType !== 50 /* ParseNodeType.Suite */)) {
         return undefined;
     }
     const assignmentIndex = suiteOrModule.statements.findIndex((node) => node === parentNode);
@@ -2167,17 +2171,17 @@ function getVariableDocStringNode(node) {
         return undefined;
     }
     const nextStatement = suiteOrModule.statements[assignmentIndex + 1];
-    if (nextStatement.nodeType !== 47 /* StatementList */ || !isDocString(nextStatement)) {
+    if (nextStatement.nodeType !== 47 /* ParseNodeType.StatementList */ || !isDocString(nextStatement)) {
         return undefined;
     }
     // See if the assignment is within one of the contexts specified in PEP 258.
     let isValidContext = false;
-    if (((_a = parentNode === null || parentNode === void 0 ? void 0 : parentNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 36 /* Module */) {
+    if (((_a = parentNode === null || parentNode === void 0 ? void 0 : parentNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 36 /* ParseNodeType.Module */) {
         // If we're at the top level of a module, the attribute docstring is valid.
         isValidContext = true;
     }
-    else if (((_b = parentNode === null || parentNode === void 0 ? void 0 : parentNode.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 50 /* Suite */ &&
-        ((_d = (_c = parentNode === null || parentNode === void 0 ? void 0 : parentNode.parent) === null || _c === void 0 ? void 0 : _c.parent) === null || _d === void 0 ? void 0 : _d.nodeType) === 10 /* Class */) {
+    else if (((_b = parentNode === null || parentNode === void 0 ? void 0 : parentNode.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 50 /* ParseNodeType.Suite */ &&
+        ((_d = (_c = parentNode === null || parentNode === void 0 ? void 0 : parentNode.parent) === null || _c === void 0 ? void 0 : _c.parent) === null || _d === void 0 ? void 0 : _d.nodeType) === 10 /* ParseNodeType.Class */) {
         // If we're at the top level of a class, the attribute docstring is valid.
         isValidContext = true;
     }
@@ -2200,10 +2204,10 @@ exports.getVariableDocStringNode = getVariableDocStringNode;
 // file contents change).
 function getScopeIdForNode(node) {
     let name = '';
-    if (node.nodeType === 10 /* Class */) {
+    if (node.nodeType === 10 /* ParseNodeType.Class */) {
         name = node.name.value;
     }
-    else if (node.nodeType === 28 /* Function */) {
+    else if (node.nodeType === 28 /* ParseNodeType.Function */) {
         name = node.name.value;
     }
     const fileInfo = AnalyzerNodeInfo.getFileInfo(node);