@zzzen/pyright-internal 1.2.0-dev.20231112 → 1.2.0-dev.20231126

package/dist/parser/parser.js

@@ -13,7 +13,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];
@@ -91,10 +95,10 @@ class Parser {
         const moduleNode = parseNodes_1.ModuleNode.create({ start: 0, length: fileContents.length });
         timing_1.timingStats.parseFileTime.timeOperation(() => {
             while (!this._atEof()) {
-                if (!this._consumeTokenIfType(2 /* NewLine */)) {
+                if (!this._consumeTokenIfType(2 /* TokenType.NewLine */)) {
                     // Handle a common error case and try to recover.
                     const nextToken = this._peekToken();
-                    if (nextToken.type === 3 /* Indent */) {
+                    if (nextToken.type === 3 /* TokenType.Indent */) {
                         this._getNextToken();
                         const indentToken = nextToken;
                         if (indentToken.isIndentAmbiguous) {
@@ -107,7 +111,7 @@ class Parser {
                     const statement = this._parseStatement();
                     if (!statement) {
                         // Perform basic error recovery to get to the next line.
-                        this._consumeTokensUntilType([2 /* NewLine */]);
+                        this._consumeTokensUntilType([2 /* TokenType.NewLine */]);
                     }
                     else {
                         statement.parent = moduleNode;
@@ -127,18 +131,18 @@ class Parser {
             typingSymbolAliases: this._typingSymbolAliases,
         };
     }
-    parseTextExpression(fileContents, textOffset, textLength, parseOptions, parseTextMode = 0 /* Expression */, initialParenDepth = 0, typingSymbolAliases) {
+    parseTextExpression(fileContents, textOffset, textLength, parseOptions, parseTextMode = 0 /* ParseTextMode.Expression */, initialParenDepth = 0, typingSymbolAliases) {
         const diagSink = new diagnosticSink_1.DiagnosticSink();
         this._startNewParse(fileContents, textOffset, textLength, parseOptions, diagSink, initialParenDepth);
         if (typingSymbolAliases) {
             this._typingSymbolAliases = new Map(typingSymbolAliases);
         }
         let parseTree;
-        if (parseTextMode === 1 /* VariableAnnotation */) {
+        if (parseTextMode === 1 /* ParseTextMode.VariableAnnotation */) {
             this._isParsingQuotedText = true;
             parseTree = this._parseTypeAnnotation();
         }
-        else if (parseTextMode === 2 /* FunctionAnnotation */) {
+        else if (parseTextMode === 2 /* ParseTextMode.FunctionAnnotation */) {
             this._isParsingQuotedText = true;
             parseTree = this._parseFunctionTypeAnnotation();
         }
@@ -156,7 +160,7 @@ class Parser {
                 parseTree = this._makeExpressionOrTuple(exprListResult, /* enclosedInParens */ false);
             }
         }
-        if (this._peekTokenType() === 2 /* NewLine */) {
+        if (this._peekTokenType() === 2 /* TokenType.NewLine */) {
             this._getNextToken();
         }
         if (!this._atEof()) {
@@ -183,46 +187,46 @@ class Parser {
     _parseStatement() {
         // Handle the errant condition of a dedent token here to provide
         // better recovery.
-        if (this._consumeTokenIfType(4 /* Dedent */)) {
+        if (this._consumeTokenIfType(4 /* TokenType.Dedent */)) {
             this._addError(localize_1.Localizer.Diagnostic.unexpectedUnindent(), this._peekToken());
         }
         switch (this._peekKeywordType()) {
-            case 20 /* If */:
+            case 20 /* KeywordType.If */:
                 return this._parseIfStatement();
-            case 36 /* While */:
+            case 36 /* KeywordType.While */:
                 return this._parseWhileStatement();
-            case 17 /* For */:
+            case 17 /* KeywordType.For */:
                 return this._parseForStatement();
-            case 34 /* Try */:
+            case 34 /* KeywordType.Try */:
                 return this._parseTryStatement();
-            case 37 /* With */:
+            case 37 /* KeywordType.With */:
                 return this._parseWithStatement();
-            case 10 /* Def */:
+            case 10 /* KeywordType.Def */:
                 return this._parseFunctionDef();
-            case 7 /* Class */:
+            case 7 /* KeywordType.Class */:
                 return this._parseClassDef();
-            case 3 /* Async */:
+            case 3 /* KeywordType.Async */:
                 return this._parseAsyncStatement();
-            case 25 /* Match */: {
+            case 25 /* KeywordType.Match */: {
                 // Match is considered a "soft" keyword, so we will treat
                 // it as an identifier if it is followed by an unexpected
                 // token.
                 const peekToken = this._peekToken(1);
                 let isInvalidMatchToken = false;
-                if (peekToken.type === 10 /* Colon */ ||
-                    peekToken.type === 11 /* Semicolon */ ||
-                    peekToken.type === 12 /* Comma */ ||
-                    peekToken.type === 20 /* Dot */ ||
-                    peekToken.type === 2 /* NewLine */ ||
-                    peekToken.type === 1 /* EndOfStream */) {
+                if (peekToken.type === 10 /* TokenType.Colon */ ||
+                    peekToken.type === 11 /* TokenType.Semicolon */ ||
+                    peekToken.type === 12 /* TokenType.Comma */ ||
+                    peekToken.type === 20 /* TokenType.Dot */ ||
+                    peekToken.type === 2 /* TokenType.NewLine */ ||
+                    peekToken.type === 1 /* TokenType.EndOfStream */) {
                     isInvalidMatchToken = true;
                 }
-                else if (peekToken.type === 9 /* Operator */) {
+                else if (peekToken.type === 9 /* TokenType.Operator */) {
                     const operatorToken = peekToken;
-                    if (operatorToken.operatorType !== 26 /* Multiply */ &&
-                        operatorToken.operatorType !== 0 /* Add */ &&
-                        operatorToken.operatorType !== 5 /* BitwiseInvert */ &&
-                        operatorToken.operatorType !== 33 /* Subtract */) {
+                    if (operatorToken.operatorType !== 26 /* OperatorType.Multiply */ &&
+                        operatorToken.operatorType !== 0 /* OperatorType.Add */ &&
+                        operatorToken.operatorType !== 5 /* OperatorType.BitwiseInvert */ &&
+                        operatorToken.operatorType !== 33 /* OperatorType.Subtract */) {
                         isInvalidMatchToken = true;
                     }
                 }
@@ -237,20 +241,20 @@ class Parser {
                 break;
             }
         }
-        if (this._peekOperatorType() === 22 /* MatrixMultiply */) {
+        if (this._peekOperatorType() === 22 /* OperatorType.MatrixMultiply */) {
             return this._parseDecorated();
         }
         return this._parseSimpleStatement();
     }
     // async_stmt: 'async' (funcdef | with_stmt | for_stmt)
     _parseAsyncStatement() {
-        const asyncToken = this._getKeywordToken(3 /* Async */);
+        const asyncToken = this._getKeywordToken(3 /* KeywordType.Async */);
         switch (this._peekKeywordType()) {
-            case 10 /* Def */:
+            case 10 /* KeywordType.Def */:
                 return this._parseFunctionDef(asyncToken);
-            case 37 /* With */:
+            case 37 /* KeywordType.With */:
                 return this._parseWithStatement(asyncToken);
-            case 17 /* For */:
+            case 17 /* KeywordType.For */:
                 return this._parseForStatement(asyncToken);
         }
         this._addError(localize_1.Localizer.Diagnostic.unexpectedAsyncToken(), asyncToken);
@@ -258,7 +262,7 @@ class Parser {
     }
     // type_alias_stmt: "type" name [type_param_seq] = expr
     _parseTypeAliasStatement() {
-        const typeToken = this._getKeywordToken(35 /* Type */);
+        const typeToken = this._getKeywordToken(35 /* KeywordType.Type */);
         if (!this._parseOptions.isStubFile && this._getLanguageVersion() < pythonVersion_1.PythonVersion.V3_12) {
             this._addError(localize_1.Localizer.Diagnostic.typeAliasStatementIllegal(), typeToken);
         }
@@ -266,12 +270,12 @@ class Parser {
         (0, debug_1.assert)(nameToken !== undefined);
         const name = parseNodes_1.NameNode.create(nameToken);
         let typeParameters;
-        if (this._peekToken().type === 15 /* OpenBracket */) {
+        if (this._peekToken().type === 15 /* TokenType.OpenBracket */) {
             typeParameters = this._parseTypeParameterList();
         }
         const assignToken = this._peekToken();
-        if (assignToken.type !== 9 /* Operator */ ||
-            assignToken.operatorType !== 2 /* Assign */) {
+        if (assignToken.type !== 9 /* TokenType.Operator */ ||
+            assignToken.operatorType !== 2 /* OperatorType.Assign */) {
             this._addError(localize_1.Localizer.Diagnostic.expectedEquals(), assignToken);
         }
         else {
@@ -284,10 +288,10 @@ class Parser {
     _parseTypeParameterList() {
         const typeVariableNodes = [];
         const openBracketToken = this._getNextToken();
-        (0, debug_1.assert)(openBracketToken.type === 15 /* OpenBracket */);
+        (0, debug_1.assert)(openBracketToken.type === 15 /* TokenType.OpenBracket */);
         while (true) {
             const firstToken = this._peekToken();
-            if (firstToken.type === 16 /* CloseBracket */) {
+            if (firstToken.type === 16 /* TokenType.CloseBracket */) {
                 if (typeVariableNodes.length === 0) {
                     this._addError(localize_1.Localizer.Diagnostic.typeParametersMissing(), this._peekToken());
                 }
@@ -298,14 +302,14 @@ class Parser {
                 break;
             }
             typeVariableNodes.push(typeVarNode);
-            if (!this._consumeTokenIfType(12 /* Comma */)) {
+            if (!this._consumeTokenIfType(12 /* TokenType.Comma */)) {
                 break;
             }
         }
         const closingToken = this._peekToken();
-        if (closingToken.type !== 16 /* CloseBracket */) {
+        if (closingToken.type !== 16 /* TokenType.CloseBracket */) {
             this._addError(localize_1.Localizer.Diagnostic.expectedCloseBracket(), this._peekToken());
-            this._consumeTokensUntilType([2 /* NewLine */, 16 /* CloseBracket */, 10 /* Colon */]);
+            this._consumeTokensUntilType([2 /* TokenType.NewLine */, 16 /* TokenType.CloseBracket */, 10 /* TokenType.Colon */]);
         }
         else {
             this._getNextToken();
@@ -315,10 +319,10 @@ class Parser {
     // type_param: ['*' | '**'] NAME [':' bound_expr] ['=' default_expr]
     _parseTypeParameter() {
         let typeParamCategory = parseNodes_1.TypeParameterCategory.TypeVar;
-        if (this._consumeTokenIfOperator(26 /* Multiply */)) {
+        if (this._consumeTokenIfOperator(26 /* OperatorType.Multiply */)) {
             typeParamCategory = parseNodes_1.TypeParameterCategory.TypeVarTuple;
         }
-        else if (this._consumeTokenIfOperator(29 /* Power */)) {
+        else if (this._consumeTokenIfOperator(29 /* OperatorType.Power */)) {
             typeParamCategory = parseNodes_1.TypeParameterCategory.ParamSpec;
         }
         const nameToken = this._getTokenIfIdentifier();
@@ -328,14 +332,14 @@ class Parser {
         }
         const name = parseNodes_1.NameNode.create(nameToken);
         let boundExpression;
-        if (this._consumeTokenIfType(10 /* Colon */)) {
+        if (this._consumeTokenIfType(10 /* TokenType.Colon */)) {
             boundExpression = this._parseExpression(/* allowUnpack */ false);
             if (typeParamCategory !== parseNodes_1.TypeParameterCategory.TypeVar) {
                 this._addError(localize_1.Localizer.Diagnostic.typeParameterBoundNotAllowed(), boundExpression);
             }
         }
         let defaultExpression;
-        if (this._consumeTokenIfOperator(2 /* Assign */)) {
+        if (this._consumeTokenIfOperator(2 /* OperatorType.Assign */)) {
             defaultExpression = this._parseExpression(
             /* allowUnpack */ typeParamCategory === parseNodes_1.TypeParameterCategory.TypeVarTuple);
             if (!this._parseOptions.isStubFile && this._getLanguageVersion() < pythonVersion_1.PythonVersion.V3_13) {
@@ -357,40 +361,40 @@ class Parser {
         let smellsLikeMatchStatement = false;
         this._suppressErrors(() => {
             const curTokenIndex = this._tokenIndex;
-            this._getKeywordToken(25 /* Match */);
+            this._getKeywordToken(25 /* KeywordType.Match */);
             const expression = this._parseTestOrStarListAsExpression(
             /* allowAssignmentExpression */ true, 
-            /* allowMultipleUnpack */ true, 12 /* MissingPatternSubject */, () => localize_1.Localizer.Diagnostic.expectedReturnExpr());
+            /* allowMultipleUnpack */ true, 12 /* ErrorExpressionCategory.MissingPatternSubject */, () => localize_1.Localizer.Diagnostic.expectedReturnExpr());
             smellsLikeMatchStatement =
-                expression.nodeType !== 0 /* Error */ && this._peekToken().type === 10 /* Colon */;
+                expression.nodeType !== 0 /* ParseNodeType.Error */ && this._peekToken().type === 10 /* TokenType.Colon */;
             // Set the token index back to the start.
             this._tokenIndex = curTokenIndex;
         });
         if (!smellsLikeMatchStatement) {
             return undefined;
         }
-        const matchToken = this._getKeywordToken(25 /* Match */);
+        const matchToken = this._getKeywordToken(25 /* KeywordType.Match */);
         const subjectExpression = this._parseTestOrStarListAsExpression(
         /* allowAssignmentExpression */ true, 
-        /* allowMultipleUnpack */ true, 12 /* MissingPatternSubject */, () => localize_1.Localizer.Diagnostic.expectedReturnExpr());
+        /* allowMultipleUnpack */ true, 12 /* ErrorExpressionCategory.MissingPatternSubject */, () => localize_1.Localizer.Diagnostic.expectedReturnExpr());
         const matchNode = parseNodes_1.MatchNode.create(matchToken, subjectExpression);
         const nextToken = this._peekToken();
-        if (!this._consumeTokenIfType(10 /* Colon */)) {
+        if (!this._consumeTokenIfType(10 /* TokenType.Colon */)) {
             this._addError(localize_1.Localizer.Diagnostic.expectedColon(), nextToken);
             // Try to perform parse recovery by consuming tokens until
             // we find the end of the line.
-            if (this._consumeTokensUntilType([2 /* NewLine */, 10 /* Colon */])) {
+            if (this._consumeTokensUntilType([2 /* TokenType.NewLine */, 10 /* TokenType.Colon */])) {
                 this._getNextToken();
             }
         }
         else {
             (0, parseNodes_1.extendRange)(matchNode, nextToken);
-            if (!this._consumeTokenIfType(2 /* NewLine */)) {
+            if (!this._consumeTokenIfType(2 /* TokenType.NewLine */)) {
                 this._addError(localize_1.Localizer.Diagnostic.expectedNewline(), nextToken);
             }
             else {
                 const possibleIndent = this._peekToken();
-                if (!this._consumeTokenIfType(3 /* Indent */)) {
+                if (!this._consumeTokenIfType(3 /* TokenType.Indent */)) {
                     this._addError(localize_1.Localizer.Diagnostic.expectedIndentedBlock(), this._peekToken());
                 }
                 else {
@@ -402,7 +406,7 @@ class Parser {
                 while (true) {
                     // Handle a common error here and see if we can recover.
                     const possibleUnexpectedIndent = this._peekToken();
-                    if (possibleUnexpectedIndent.type === 3 /* Indent */) {
+                    if (possibleUnexpectedIndent.type === 3 /* TokenType.Indent */) {
                         this._getNextToken();
                         const indentToken = possibleUnexpectedIndent;
                         if (indentToken.isIndentAmbiguous) {
@@ -415,7 +419,7 @@ class Parser {
                     const caseStatement = this._parseCaseStatement();
                     if (!caseStatement) {
                         // Perform basic error recovery to get to the next line.
-                        if (this._consumeTokensUntilType([2 /* NewLine */, 10 /* Colon */])) {
+                        if (this._consumeTokensUntilType([2 /* TokenType.NewLine */, 10 /* TokenType.Colon */])) {
                             this._getNextToken();
                         }
                     }
@@ -424,7 +428,7 @@ class Parser {
                         matchNode.cases.push(caseStatement);
                     }
                     const dedentToken = this._peekToken();
-                    if (this._consumeTokenIfType(4 /* Dedent */)) {
+                    if (this._consumeTokenIfType(4 /* TokenType.Dedent */)) {
                         if (!dedentToken.matchesIndent) {
                             this._addError(localize_1.Localizer.Diagnostic.inconsistentIndent(), dedentToken);
                         }
@@ -433,7 +437,7 @@ class Parser {
                         }
                         break;
                     }
-                    if (this._peekTokenType() === 1 /* EndOfStream */) {
+                    if (this._peekTokenType() === 1 /* TokenType.EndOfStream */) {
                         break;
                     }
                 }
@@ -463,7 +467,7 @@ class Parser {
     // guard: 'if' named_expression
     _parseCaseStatement() {
         const caseToken = this._peekToken();
-        if (!this._consumeTokenIfKeyword(6 /* Case */)) {
+        if (!this._consumeTokenIfKeyword(6 /* KeywordType.Case */)) {
             this._addError(localize_1.Localizer.Diagnostic.expectedCase(), caseToken);
             return undefined;
         }
@@ -474,11 +478,11 @@ class Parser {
         }
         else if (patternList.list.length === 0) {
             this._addError(localize_1.Localizer.Diagnostic.expectedPatternExpr(), this._peekToken());
-            casePattern = parseNodes_1.ErrorNode.create(caseToken, 11 /* MissingPattern */);
+            casePattern = parseNodes_1.ErrorNode.create(caseToken, 11 /* ErrorExpressionCategory.MissingPattern */);
         }
         else if (patternList.list.length === 1 && !patternList.trailingComma) {
             const pattern = patternList.list[0].orPatterns[0];
-            if (pattern.nodeType === 69 /* PatternCapture */ && pattern.isStar) {
+            if (pattern.nodeType === 69 /* ParseNodeType.PatternCapture */ && pattern.isStar) {
                 casePattern = parseNodes_1.PatternSequenceNode.create(patternList.list[0], patternList.list);
             }
             else {
@@ -488,13 +492,13 @@ class Parser {
         else {
             casePattern = parseNodes_1.PatternSequenceNode.create(patternList.list[0], patternList.list);
         }
-        if (casePattern.nodeType !== 0 /* Error */) {
+        if (casePattern.nodeType !== 0 /* ParseNodeType.Error */) {
             const globalNameMap = new Map();
             const localNameMap = new Map();
             this._reportDuplicatePatternCaptureTargets(casePattern, globalNameMap, localNameMap);
         }
         let guardExpression;
-        if (this._consumeTokenIfKeyword(20 /* If */)) {
+        if (this._consumeTokenIfKeyword(20 /* KeywordType.If */)) {
             guardExpression = this._parseTestExpression(/* allowAssignmentExpression */ true);
         }
         const suite = this._parseSuite(this._isInFunction);
@@ -503,10 +507,10 @@ class Parser {
     // PEP 634 defines the concept of an "irrefutable" pattern - a pattern that
     // will always be matched.
     _isPatternIrrefutable(node) {
-        if (node.nodeType === 69 /* PatternCapture */) {
+        if (node.nodeType === 69 /* ParseNodeType.PatternCapture */) {
             return true;
         }
-        if (node.nodeType === 66 /* PatternAs */) {
+        if (node.nodeType === 66 /* ParseNodeType.PatternAs */) {
             return node.orPatterns.some((pattern) => this._isPatternIrrefutable(pattern));
         }
         return false;
@@ -527,19 +531,19 @@ class Parser {
             }
         };
         switch (node.nodeType) {
-            case 65 /* PatternSequence */: {
+            case 65 /* ParseNodeType.PatternSequence */: {
                 node.entries.forEach((subpattern) => {
                     this._reportDuplicatePatternCaptureTargets(subpattern, globalNameMap, localNameMap);
                 });
                 break;
             }
-            case 68 /* PatternClass */: {
+            case 68 /* ParseNodeType.PatternClass */: {
                 node.arguments.forEach((arg) => {
                     this._reportDuplicatePatternCaptureTargets(arg.pattern, globalNameMap, localNameMap);
                 });
                 break;
             }
-            case 66 /* PatternAs */: {
+            case 66 /* ParseNodeType.PatternAs */: {
                 if (node.target) {
                     reportTargetIfDuplicate(node.target);
                 }
@@ -559,15 +563,15 @@ class Parser {
                 });
                 break;
             }
-            case 69 /* PatternCapture */: {
+            case 69 /* ParseNodeType.PatternCapture */: {
                 if (!node.isWildcard) {
                     reportTargetIfDuplicate(node.target);
                 }
                 break;
             }
-            case 70 /* PatternMapping */: {
+            case 70 /* ParseNodeType.PatternMapping */: {
                 node.entries.forEach((mapEntry) => {
-                    if (mapEntry.nodeType === 72 /* PatternMappingExpandEntry */) {
+                    if (mapEntry.nodeType === 72 /* ParseNodeType.PatternMappingExpandEntry */) {
                         reportTargetIfDuplicate(mapEntry.target);
                     }
                     else {
@@ -577,28 +581,28 @@ class Parser {
                 });
                 break;
             }
-            case 67 /* PatternLiteral */:
-            case 73 /* PatternValue */:
-            case 0 /* Error */: {
+            case 67 /* ParseNodeType.PatternLiteral */:
+            case 73 /* ParseNodeType.PatternValue */:
+            case 0 /* ParseNodeType.Error */: {
                 break;
             }
         }
     }
     _getPatternTargetNames(node, nameSet) {
         switch (node.nodeType) {
-            case 65 /* PatternSequence */: {
+            case 65 /* ParseNodeType.PatternSequence */: {
                 node.entries.forEach((subpattern) => {
                     this._getPatternTargetNames(subpattern, nameSet);
                 });
                 break;
             }
-            case 68 /* PatternClass */: {
+            case 68 /* ParseNodeType.PatternClass */: {
                 node.arguments.forEach((arg) => {
                     this._getPatternTargetNames(arg.pattern, nameSet);
                 });
                 break;
             }
-            case 66 /* PatternAs */: {
+            case 66 /* ParseNodeType.PatternAs */: {
                 if (node.target) {
                     nameSet.add(node.target.value);
                 }
@@ -607,15 +611,15 @@ class Parser {
                 });
                 break;
             }
-            case 69 /* PatternCapture */: {
+            case 69 /* ParseNodeType.PatternCapture */: {
                 if (!node.isWildcard) {
                     nameSet.add(node.target.value);
                 }
                 break;
             }
-            case 70 /* PatternMapping */: {
+            case 70 /* ParseNodeType.PatternMapping */: {
                 node.entries.forEach((mapEntry) => {
-                    if (mapEntry.nodeType === 72 /* PatternMappingExpandEntry */) {
+                    if (mapEntry.nodeType === 72 /* ParseNodeType.PatternMappingExpandEntry */) {
                         nameSet.add(mapEntry.target.value);
                     }
                     else {
@@ -625,9 +629,9 @@ class Parser {
                 });
                 break;
             }
-            case 67 /* PatternLiteral */:
-            case 73 /* PatternValue */:
-            case 0 /* Error */: {
+            case 67 /* ParseNodeType.PatternLiteral */:
+            case 73 /* ParseNodeType.PatternValue */:
+            case 0 /* ParseNodeType.Error */: {
                 break;
             }
         }
@@ -636,7 +640,7 @@ class Parser {
         const patternList = this._parseExpressionListGeneric(() => this._parsePatternAs());
         // Check for more than one star entry.
         const starEntries = patternList.list.filter((entry) => entry.orPatterns.length === 1 &&
-            entry.orPatterns[0].nodeType === 69 /* PatternCapture */ &&
+            entry.orPatterns[0].nodeType === 69 /* ParseNodeType.PatternCapture */ &&
             entry.orPatterns[0].isStar);
         if (starEntries.length > 1) {
             this._addError(localize_1.Localizer.Diagnostic.duplicateStarPattern(), starEntries[1].orPatterns[0]);
@@ -650,20 +654,20 @@ class Parser {
         while (true) {
             const patternAtom = this._parsePatternAtom();
             orPatterns.push(patternAtom);
-            if (!this._consumeTokenIfOperator(6 /* BitwiseOr */)) {
+            if (!this._consumeTokenIfOperator(6 /* OperatorType.BitwiseOr */)) {
                 break;
             }
         }
         if (orPatterns.length > 1) {
             // Star patterns cannot be ORed with other patterns.
             orPatterns.forEach((patternAtom) => {
-                if (patternAtom.nodeType === 69 /* PatternCapture */ && patternAtom.isStar) {
+                if (patternAtom.nodeType === 69 /* ParseNodeType.PatternCapture */ && patternAtom.isStar) {
                     this._addError(localize_1.Localizer.Diagnostic.starPatternInOrPattern(), patternAtom);
                 }
             });
         }
         let target;
-        if (this._consumeTokenIfKeyword(1 /* As */)) {
+        if (this._consumeTokenIfKeyword(1 /* KeywordType.As */)) {
             const nameToken = this._getTokenIfIdentifier();
             if (nameToken) {
                 target = parseNodes_1.NameNode.create(nameToken);
@@ -675,7 +679,7 @@ class Parser {
         // Star patterns cannot be used with AS pattern.
         if (target &&
             orPatterns.length === 1 &&
-            orPatterns[0].nodeType === 69 /* PatternCapture */ &&
+            orPatterns[0].nodeType === 69 /* ParseNodeType.PatternCapture */ &&
             orPatterns[0].isStar) {
             this._addError(localize_1.Localizer.Diagnostic.starPatternInAsPattern(), orPatterns[0]);
         }
@@ -725,20 +729,20 @@ class Parser {
         const patternCaptureOrValue = this._parsePatternCaptureOrValue();
         if (patternCaptureOrValue) {
             const openParenToken = this._peekToken();
-            if (patternCaptureOrValue.nodeType === 0 /* Error */ ||
-                !this._consumeTokenIfType(13 /* OpenParenthesis */)) {
+            if (patternCaptureOrValue.nodeType === 0 /* ParseNodeType.Error */ ||
+                !this._consumeTokenIfType(13 /* TokenType.OpenParenthesis */)) {
                 return patternCaptureOrValue;
             }
             const args = this._parseClassPatternArgList();
-            const classNameExpr = patternCaptureOrValue.nodeType === 69 /* PatternCapture */
+            const classNameExpr = patternCaptureOrValue.nodeType === 69 /* ParseNodeType.PatternCapture */
                 ? patternCaptureOrValue.target
                 : patternCaptureOrValue.expression;
             const classPattern = parseNodes_1.PatternClassNode.create(classNameExpr, args);
-            if (!this._consumeTokenIfType(14 /* CloseParenthesis */)) {
+            if (!this._consumeTokenIfType(14 /* TokenType.CloseParenthesis */)) {
                 this._addError(localize_1.Localizer.Diagnostic.expectedCloseParen(), openParenToken);
                 // Consume the remainder of tokens on the line for error
                 // recovery.
-                this._consumeTokensUntilType([2 /* NewLine */]);
+                this._consumeTokensUntilType([2 /* TokenType.NewLine */]);
                 // Extend the node's range to include the rest of the line.
                 // This helps the signatureHelpProvider.
                 (0, parseNodes_1.extendRange)(classPattern, this._peekToken());
@@ -747,18 +751,18 @@ class Parser {
         }
         const nextToken = this._peekToken();
         const nextOperator = this._peekOperatorType();
-        if (nextOperator === 26 /* Multiply */) {
+        if (nextOperator === 26 /* OperatorType.Multiply */) {
             const starToken = this._getNextToken();
             const identifierToken = this._getTokenIfIdentifier();
             if (!identifierToken) {
                 this._addError(localize_1.Localizer.Diagnostic.expectedIdentifier(), this._peekToken());
-                return parseNodes_1.ErrorNode.create(starToken, 2 /* MissingExpression */);
+                return parseNodes_1.ErrorNode.create(starToken, 2 /* ErrorExpressionCategory.MissingExpression */);
             }
             else {
                 return parseNodes_1.PatternCaptureNode.create(parseNodes_1.NameNode.create(identifierToken), starToken);
             }
         }
-        if (nextToken.type === 13 /* OpenParenthesis */ || nextToken.type === 15 /* OpenBracket */) {
+        if (nextToken.type === 13 /* TokenType.OpenParenthesis */ || nextToken.type === 15 /* TokenType.OpenBracket */) {
             const startToken = this._getNextToken();
             const patternList = this._parsePatternSequence();
             let casePattern;
@@ -767,9 +771,9 @@ class Parser {
             }
             else if (patternList.list.length === 1 &&
                 !patternList.trailingComma &&
-                startToken.type === 13 /* OpenParenthesis */) {
+                startToken.type === 13 /* TokenType.OpenParenthesis */) {
                 const pattern = patternList.list[0].orPatterns[0];
-                if (pattern.nodeType === 69 /* PatternCapture */ && pattern.isStar) {
+                if (pattern.nodeType === 69 /* ParseNodeType.PatternCapture */ && pattern.isStar) {
                     casePattern = parseNodes_1.PatternSequenceNode.create(startToken, patternList.list);
                 }
                 else {
@@ -781,34 +785,34 @@ class Parser {
                 casePattern = parseNodes_1.PatternSequenceNode.create(startToken, patternList.list);
             }
             const endToken = this._peekToken();
-            if (this._consumeTokenIfType(nextToken.type === 13 /* OpenParenthesis */ ? 14 /* CloseParenthesis */ : 16 /* CloseBracket */)) {
+            if (this._consumeTokenIfType(nextToken.type === 13 /* TokenType.OpenParenthesis */ ? 14 /* TokenType.CloseParenthesis */ : 16 /* TokenType.CloseBracket */)) {
                 (0, parseNodes_1.extendRange)(casePattern, endToken);
             }
             else {
-                this._addError(nextToken.type === 13 /* OpenParenthesis */
+                this._addError(nextToken.type === 13 /* TokenType.OpenParenthesis */
                     ? localize_1.Localizer.Diagnostic.expectedCloseParen()
                     : localize_1.Localizer.Diagnostic.expectedCloseBracket(), nextToken);
                 this._consumeTokensUntilType([
-                    10 /* Colon */,
-                    nextToken.type === 13 /* OpenParenthesis */ ? 14 /* CloseParenthesis */ : 16 /* CloseBracket */,
+                    10 /* TokenType.Colon */,
+                    nextToken.type === 13 /* TokenType.OpenParenthesis */ ? 14 /* TokenType.CloseParenthesis */ : 16 /* TokenType.CloseBracket */,
                 ]);
             }
             return casePattern;
         }
-        else if (nextToken.type === 17 /* OpenCurlyBrace */) {
+        else if (nextToken.type === 17 /* TokenType.OpenCurlyBrace */) {
             const firstToken = this._getNextToken();
             const mappingPattern = this._parsePatternMapping(firstToken);
             const lastToken = this._peekToken();
-            if (this._consumeTokenIfType(18 /* CloseCurlyBrace */)) {
+            if (this._consumeTokenIfType(18 /* TokenType.CloseCurlyBrace */)) {
                 (0, parseNodes_1.extendRange)(mappingPattern, lastToken);
             }
             else {
                 this._addError(localize_1.Localizer.Diagnostic.expectedCloseBrace(), nextToken);
-                this._consumeTokensUntilType([10 /* Colon */, 18 /* CloseCurlyBrace */]);
+                this._consumeTokensUntilType([10 /* TokenType.Colon */, 18 /* TokenType.CloseCurlyBrace */]);
             }
             return mappingPattern;
         }
-        return this._handleExpressionParseError(11 /* MissingPattern */, localize_1.Localizer.Diagnostic.expectedPatternExpr());
+        return this._handleExpressionParseError(11 /* ErrorExpressionCategory.MissingPattern */, localize_1.Localizer.Diagnostic.expectedPatternExpr());
     }
     // pattern_arguments:
     //     | positional_patterns [',' keyword_patterns]
@@ -820,9 +824,9 @@ class Parser {
         let sawKeywordArg = false;
         while (true) {
             const nextTokenType = this._peekTokenType();
-            if (nextTokenType === 14 /* CloseParenthesis */ ||
-                nextTokenType === 2 /* NewLine */ ||
-                nextTokenType === 1 /* EndOfStream */) {
+            if (nextTokenType === 14 /* TokenType.CloseParenthesis */ ||
+                nextTokenType === 2 /* TokenType.NewLine */ ||
+                nextTokenType === 1 /* TokenType.EndOfStream */) {
                 break;
             }
             const arg = this._parseClassPatternArgument();
@@ -833,7 +837,7 @@ class Parser {
                 this._addError(localize_1.Localizer.Diagnostic.positionArgAfterNamedArg(), arg);
             }
             argList.push(arg);
-            if (!this._consumeTokenIfType(12 /* Comma */)) {
+            if (!this._consumeTokenIfType(12 /* TokenType.Comma */)) {
                 break;
             }
         }
@@ -844,9 +848,9 @@ class Parser {
         const firstToken = this._peekToken();
         const secondToken = this._peekToken(1);
         let keywordName;
-        if ((firstToken.type === 7 /* Identifier */ || firstToken.type === 8 /* Keyword */) &&
-            secondToken.type === 9 /* Operator */ &&
-            secondToken.operatorType === 2 /* Assign */) {
+        if ((firstToken.type === 7 /* TokenType.Identifier */ || firstToken.type === 8 /* TokenType.Keyword */) &&
+            secondToken.type === 9 /* TokenType.Operator */ &&
+            secondToken.operatorType === 2 /* OperatorType.Assign */) {
             const classNameToken = this._getTokenIfIdentifier();
             if (classNameToken !== undefined) {
                 keywordName = parseNodes_1.NameNode.create(classNameToken);
@@ -867,25 +871,25 @@ class Parser {
     _parsePatternLiteral() {
         const nextToken = this._peekToken();
         const nextOperator = this._peekOperatorType();
-        if (nextToken.type === 6 /* Number */ || nextOperator === 33 /* Subtract */) {
+        if (nextToken.type === 6 /* TokenType.Number */ || nextOperator === 33 /* OperatorType.Subtract */) {
             return this._parsePatternLiteralNumber();
         }
-        if (nextToken.type === 5 /* String */) {
+        if (nextToken.type === 5 /* TokenType.String */) {
             const stringList = this._parseAtom();
-            (0, debug_1.assert)(stringList.nodeType === 48 /* StringList */);
+            (0, debug_1.assert)(stringList.nodeType === 48 /* ParseNodeType.StringList */);
             // Check for f-strings, which are not allowed.
             stringList.strings.forEach((stringAtom) => {
-                if (stringAtom.nodeType === 27 /* FormatString */) {
+                if (stringAtom.nodeType === 27 /* ParseNodeType.FormatString */) {
                     this._addError(localize_1.Localizer.Diagnostic.formatStringInPattern(), stringAtom);
                 }
             });
             return parseNodes_1.PatternLiteralNode.create(stringList);
         }
-        if (nextToken.type === 8 /* Keyword */) {
+        if (nextToken.type === 8 /* TokenType.Keyword */) {
             const keywordToken = nextToken;
-            if (keywordToken.keywordType === 15 /* False */ ||
-                keywordToken.keywordType === 33 /* True */ ||
-                keywordToken.keywordType === 26 /* None */) {
+            if (keywordToken.keywordType === 15 /* KeywordType.False */ ||
+                keywordToken.keywordType === 33 /* KeywordType.True */ ||
+                keywordToken.keywordType === 26 /* KeywordType.None */) {
                 return parseNodes_1.PatternLiteralNode.create(this._parseAtom());
             }
         }
@@ -896,8 +900,8 @@ class Parser {
         const expression = this._parseArithmeticExpression();
         let realValue;
         let imagValue;
-        if (expression.nodeType === 7 /* BinaryOperation */) {
-            if (expression.operator === 33 /* Subtract */ || expression.operator === 0 /* Add */) {
+        if (expression.nodeType === 7 /* ParseNodeType.BinaryOperation */) {
+            if (expression.operator === 33 /* OperatorType.Subtract */ || expression.operator === 0 /* OperatorType.Add */) {
                 realValue = expression.leftExpression;
                 imagValue = expression.rightExpression;
             }
@@ -906,19 +910,19 @@ class Parser {
             realValue = expression;
         }
         if (realValue) {
-            if (realValue.nodeType === 55 /* UnaryOperation */ && realValue.operator === 33 /* Subtract */) {
+            if (realValue.nodeType === 55 /* ParseNodeType.UnaryOperation */ && realValue.operator === 33 /* OperatorType.Subtract */) {
                 realValue = realValue.expression;
             }
-            if (realValue.nodeType !== 40 /* Number */ || (imagValue !== undefined && realValue.isImaginary)) {
+            if (realValue.nodeType !== 40 /* ParseNodeType.Number */ || (imagValue !== undefined && realValue.isImaginary)) {
                 this._addError(localize_1.Localizer.Diagnostic.expectedComplexNumberLiteral(), expression);
                 imagValue = undefined;
             }
         }
         if (imagValue) {
-            if (imagValue.nodeType === 55 /* UnaryOperation */ && imagValue.operator === 33 /* Subtract */) {
+            if (imagValue.nodeType === 55 /* ParseNodeType.UnaryOperation */ && imagValue.operator === 33 /* OperatorType.Subtract */) {
                 imagValue = imagValue.expression;
             }
-            if (imagValue.nodeType !== 40 /* Number */ || !imagValue.isImaginary) {
+            if (imagValue.nodeType !== 40 /* ParseNodeType.Number */ || !imagValue.isImaginary) {
                 this._addError(localize_1.Localizer.Diagnostic.expectedComplexNumberLiteral(), expression);
             }
         }
@@ -928,13 +932,13 @@ class Parser {
         const itemList = this._parseExpressionListGeneric(() => this._parsePatternMappingItem());
         if (itemList.list.length > 0) {
             // Verify there's at most one ** entry.
-            const starStarEntries = itemList.list.filter((entry) => entry.nodeType === 72 /* PatternMappingExpandEntry */);
+            const starStarEntries = itemList.list.filter((entry) => entry.nodeType === 72 /* ParseNodeType.PatternMappingExpandEntry */);
             if (starStarEntries.length > 1) {
                 this._addError(localize_1.Localizer.Diagnostic.duplicateStarStarPattern(), starStarEntries[1]);
             }
             return parseNodes_1.PatternMappingNode.create(firstToken, itemList.list);
         }
-        return itemList.parseError || parseNodes_1.ErrorNode.create(this._peekToken(), 11 /* MissingPattern */);
+        return itemList.parseError || parseNodes_1.ErrorNode.create(this._peekToken(), 11 /* ErrorExpressionCategory.MissingPattern */);
     }
     // key_value_pattern:
     //     | (literal_pattern | attr) ':' as_pattern
@@ -942,11 +946,11 @@ class Parser {
     _parsePatternMappingItem() {
         let keyExpression;
         const doubleStar = this._peekToken();
-        if (this._consumeTokenIfOperator(29 /* Power */)) {
+        if (this._consumeTokenIfOperator(29 /* OperatorType.Power */)) {
             const identifierToken = this._getTokenIfIdentifier();
             if (!identifierToken) {
                 this._addError(localize_1.Localizer.Diagnostic.expectedIdentifier(), this._peekToken());
-                return parseNodes_1.ErrorNode.create(this._peekToken(), 11 /* MissingPattern */);
+                return parseNodes_1.ErrorNode.create(this._peekToken(), 11 /* ErrorExpressionCategory.MissingPattern */);
             }
             const nameNode = parseNodes_1.NameNode.create(identifierToken);
             if (identifierToken.value === '_') {
@@ -961,23 +965,23 @@ class Parser {
         else {
             const patternCaptureOrValue = this._parsePatternCaptureOrValue();
             if (patternCaptureOrValue) {
-                if (patternCaptureOrValue.nodeType === 73 /* PatternValue */) {
+                if (patternCaptureOrValue.nodeType === 73 /* ParseNodeType.PatternValue */) {
                     keyExpression = patternCaptureOrValue;
                 }
                 else {
                     this._addError(localize_1.Localizer.Diagnostic.expectedPatternValue(), patternCaptureOrValue);
-                    keyExpression = parseNodes_1.ErrorNode.create(this._peekToken(), 11 /* MissingPattern */);
+                    keyExpression = parseNodes_1.ErrorNode.create(this._peekToken(), 11 /* ErrorExpressionCategory.MissingPattern */);
                 }
             }
         }
         if (!keyExpression) {
             this._addError(localize_1.Localizer.Diagnostic.expectedPatternExpr(), this._peekToken());
-            keyExpression = parseNodes_1.ErrorNode.create(this._peekToken(), 11 /* MissingPattern */);
+            keyExpression = parseNodes_1.ErrorNode.create(this._peekToken(), 11 /* ErrorExpressionCategory.MissingPattern */);
         }
         let valuePattern;
-        if (!this._consumeTokenIfType(10 /* Colon */)) {
+        if (!this._consumeTokenIfType(10 /* TokenType.Colon */)) {
             this._addError(localize_1.Localizer.Diagnostic.expectedColon(), this._peekToken());
-            valuePattern = parseNodes_1.ErrorNode.create(this._peekToken(), 11 /* MissingPattern */);
+            valuePattern = parseNodes_1.ErrorNode.create(this._peekToken(), 11 /* ErrorExpressionCategory.MissingPattern */);
         }
         else {
             valuePattern = this._parsePatternAs();
@@ -986,7 +990,7 @@ class Parser {
     }
     _parsePatternCaptureOrValue() {
         const nextToken = this._peekToken();
-        if (nextToken.type === 7 /* Identifier */ || nextToken.type === 8 /* Keyword */) {
+        if (nextToken.type === 7 /* TokenType.Identifier */ || nextToken.type === 8 /* TokenType.Keyword */) {
             let nameOrMember;
             while (true) {
                 const identifierToken = this._getTokenIfIdentifier();
@@ -998,15 +1002,15 @@ class Parser {
                     this._addError(localize_1.Localizer.Diagnostic.expectedIdentifier(), this._peekToken());
                     break;
                 }
-                if (!this._consumeTokenIfType(20 /* Dot */)) {
+                if (!this._consumeTokenIfType(20 /* TokenType.Dot */)) {
                     break;
                 }
             }
             if (!nameOrMember) {
                 this._addError(localize_1.Localizer.Diagnostic.expectedIdentifier(), this._peekToken());
-                return parseNodes_1.ErrorNode.create(this._peekToken(), 11 /* MissingPattern */);
+                return parseNodes_1.ErrorNode.create(this._peekToken(), 11 /* ErrorExpressionCategory.MissingPattern */);
             }
-            if (nameOrMember.nodeType === 35 /* MemberAccess */) {
+            if (nameOrMember.nodeType === 35 /* ParseNodeType.MemberAccess */) {
                 return parseNodes_1.PatternValueNode.create(nameOrMember);
             }
             return parseNodes_1.PatternCaptureNode.create(nameOrMember);
@@ -1016,19 +1020,19 @@ class Parser {
     // if_stmt: 'if' test_suite ('elif' test_suite)* ['else' suite]
     // test_suite: test suite
     // test: or_test ['if' or_test 'else' test] | lambdef
-    _parseIfStatement(keywordType = 20 /* If */) {
+    _parseIfStatement(keywordType = 20 /* KeywordType.If */) {
         const ifOrElifToken = this._getKeywordToken(keywordType);
         const test = this._parseTestExpression(/* allowAssignmentExpression */ true);
         const suite = this._parseSuite(this._isInFunction);
         const ifNode = parseNodes_1.IfNode.create(ifOrElifToken, test, suite);
-        if (this._consumeTokenIfKeyword(13 /* Else */)) {
+        if (this._consumeTokenIfKeyword(13 /* KeywordType.Else */)) {
             ifNode.elseSuite = this._parseSuite(this._isInFunction);
             ifNode.elseSuite.parent = ifNode;
             (0, parseNodes_1.extendRange)(ifNode, ifNode.elseSuite);
         }
-        else if (this._peekKeywordType() === 12 /* Elif */) {
+        else if (this._peekKeywordType() === 12 /* KeywordType.Elif */) {
             // Recursively handle an "elif" statement.
-            ifNode.elseSuite = this._parseIfStatement(12 /* Elif */);
+            ifNode.elseSuite = this._parseIfStatement(12 /* KeywordType.Elif */);
             ifNode.elseSuite.parent = ifNode;
             (0, parseNodes_1.extendRange)(ifNode, ifNode.elseSuite);
         }
@@ -1057,14 +1061,14 @@ class Parser {
     _parseSuite(isFunction = false, skipBody = false, postColonCallback) {
         const nextToken = this._peekToken();
         const suite = parseNodes_1.SuiteNode.create(nextToken);
-        if (!this._consumeTokenIfType(10 /* Colon */)) {
+        if (!this._consumeTokenIfType(10 /* TokenType.Colon */)) {
             this._addError(localize_1.Localizer.Diagnostic.expectedColon(), nextToken);
             // Try to perform parse recovery by consuming tokens.
-            if (this._consumeTokensUntilType([2 /* NewLine */, 10 /* Colon */])) {
-                if (this._peekTokenType() === 10 /* Colon */) {
+            if (this._consumeTokensUntilType([2 /* TokenType.NewLine */, 10 /* TokenType.Colon */])) {
+                if (this._peekTokenType() === 10 /* TokenType.Colon */) {
                     this._getNextToken();
                 }
-                else if (this._peekToken(1).type !== 3 /* Indent */) {
+                else if (this._peekToken(1).type !== 3 /* TokenType.Indent */) {
                     // Bail so we resume the at the next statement.
                     // We can't parse as a simple statement as we've skipped all but the newline.
                     this._getNextToken();
@@ -1073,14 +1077,14 @@ class Parser {
             }
         }
         if (skipBody) {
-            if (this._consumeTokenIfType(2 /* NewLine */)) {
+            if (this._consumeTokenIfType(2 /* TokenType.NewLine */)) {
                 let indent = 0;
                 while (true) {
                     const nextToken = this._getNextToken();
-                    if (nextToken.type === 3 /* Indent */) {
+                    if (nextToken.type === 3 /* TokenType.Indent */) {
                         indent++;
                     }
-                    if (nextToken.type === 4 /* Dedent */) {
+                    if (nextToken.type === 4 /* TokenType.Dedent */) {
                         if (nextToken.isDedentAmbiguous) {
                             this._addError(localize_1.Localizer.Diagnostic.inconsistentTabs(), nextToken);
                         }
@@ -1089,7 +1093,7 @@ class Parser {
                             break;
                         }
                     }
-                    if (nextToken.type === 1 /* EndOfStream */) {
+                    if (nextToken.type === 1 /* TokenType.EndOfStream */) {
                         break;
                     }
                 }
@@ -1108,12 +1112,12 @@ class Parser {
         }
         const wasFunction = this._isInFunction;
         this._isInFunction = isFunction;
-        if (this._consumeTokenIfType(2 /* NewLine */)) {
+        if (this._consumeTokenIfType(2 /* TokenType.NewLine */)) {
             if (postColonCallback) {
                 postColonCallback();
             }
             const possibleIndent = this._peekToken();
-            if (!this._consumeTokenIfType(3 /* Indent */)) {
+            if (!this._consumeTokenIfType(3 /* TokenType.Indent */)) {
                 this._addError(localize_1.Localizer.Diagnostic.expectedIndentedBlock(), this._peekToken());
                 return suite;
             }
@@ -1124,7 +1128,7 @@ class Parser {
             while (true) {
                 // Handle a common error here and see if we can recover.
                 const nextToken = this._peekToken();
-                if (nextToken.type === 3 /* Indent */) {
+                if (nextToken.type === 3 /* TokenType.Indent */) {
                     this._getNextToken();
                     const indentToken = nextToken;
                     if (indentToken.isIndentAmbiguous) {
@@ -1134,7 +1138,7 @@ class Parser {
                         this._addError(localize_1.Localizer.Diagnostic.unexpectedIndent(), nextToken);
                     }
                 }
-                else if (nextToken.type === 4 /* Dedent */) {
+                else if (nextToken.type === 4 /* TokenType.Dedent */) {
                     // When we see a dedent, stop before parsing the dedented statement.
                     const dedentToken = nextToken;
                     if (!dedentToken.matchesIndent) {
@@ -1148,7 +1152,7 @@ class Parser {
                     // multiple levels of nested suites. Also extend the suite's range in this
                     // case so it is multi-line as this works better with indentationUtils.
                     if (suite.statements.length > 0) {
-                        this._consumeTokenIfType(4 /* Dedent */);
+                        this._consumeTokenIfType(4 /* TokenType.Dedent */);
                     }
                     else {
                         (0, parseNodes_1.extendRange)(suite, dedentToken);
@@ -1163,7 +1167,7 @@ class Parser {
                         // level to a less than the initial indent of the suite body, swallow
                         // the extra dedent to help recover the parse.
                         const nextToken = this._peekToken();
-                        if (this._consumeTokenIfType(4 /* Dedent */)) {
+                        if (this._consumeTokenIfType(4 /* TokenType.Dedent */)) {
                             (0, parseNodes_1.extendRange)(suite, nextToken);
                             break;
                         }
@@ -1172,13 +1176,13 @@ class Parser {
                 const statement = this._parseStatement();
                 if (!statement) {
                     // Perform basic error recovery to get to the next line.
-                    this._consumeTokensUntilType([2 /* NewLine */]);
+                    this._consumeTokensUntilType([2 /* TokenType.NewLine */]);
                 }
                 else {
                     statement.parent = suite;
                     suite.statements.push(statement);
                 }
-                if (this._peekTokenType() === 1 /* EndOfStream */) {
+                if (this._peekTokenType() === 1 /* TokenType.EndOfStream */) {
                     break;
                 }
             }
@@ -1196,34 +1200,34 @@ class Parser {
     }
     // for_stmt: [async] 'for' exprlist 'in' testlist suite ['else' suite]
     _parseForStatement(asyncToken) {
-        const forToken = this._getKeywordToken(17 /* For */);
-        const targetExpr = this._parseExpressionListAsPossibleTuple(2 /* MissingExpression */, () => localize_1.Localizer.Diagnostic.expectedExpr(), forToken);
+        const forToken = this._getKeywordToken(17 /* KeywordType.For */);
+        const targetExpr = this._parseExpressionListAsPossibleTuple(2 /* ErrorExpressionCategory.MissingExpression */, () => localize_1.Localizer.Diagnostic.expectedExpr(), forToken);
         let seqExpr;
         let forSuite;
         let elseSuite;
-        if (!this._consumeTokenIfKeyword(22 /* In */)) {
-            seqExpr = this._handleExpressionParseError(0 /* MissingIn */, localize_1.Localizer.Diagnostic.expectedIn());
+        if (!this._consumeTokenIfKeyword(22 /* KeywordType.In */)) {
+            seqExpr = this._handleExpressionParseError(0 /* ErrorExpressionCategory.MissingIn */, localize_1.Localizer.Diagnostic.expectedIn());
             forSuite = parseNodes_1.SuiteNode.create(this._peekToken());
         }
         else {
             seqExpr = this._parseTestOrStarListAsExpression(
             /* allowAssignmentExpression */ false, 
-            /* allowMultipleUnpack */ true, 2 /* MissingExpression */, () => localize_1.Localizer.Diagnostic.expectedInExpr());
+            /* allowMultipleUnpack */ true, 2 /* ErrorExpressionCategory.MissingExpression */, () => localize_1.Localizer.Diagnostic.expectedInExpr());
             forSuite = this._parseLoopSuite();
             // Versions of Python earlier than 3.9 didn't allow unpack operators if the
             // tuple wasn't enclosed in parentheses.
             if (this._getLanguageVersion() < pythonVersion_1.PythonVersion.V3_9 && !this._parseOptions.isStubFile) {
-                if (seqExpr.nodeType === 52 /* Tuple */ && !seqExpr.enclosedInParens) {
+                if (seqExpr.nodeType === 52 /* ParseNodeType.Tuple */ && !seqExpr.enclosedInParens) {
                     let sawStar = false;
                     seqExpr.expressions.forEach((expr) => {
-                        if (expr.nodeType === 56 /* Unpack */ && !sawStar) {
+                        if (expr.nodeType === 56 /* ParseNodeType.Unpack */ && !sawStar) {
                             this._addError(localize_1.Localizer.Diagnostic.unpackOperatorNotAllowed(), expr);
                             sawStar = true;
                         }
                     });
                 }
             }
-            if (this._consumeTokenIfKeyword(13 /* Else */)) {
+            if (this._consumeTokenIfKeyword(13 /* KeywordType.Else */)) {
                 elseSuite = this._parseSuite(this._isInFunction);
             }
         }
@@ -1249,10 +1253,10 @@ class Parser {
         if (!compFor) {
             return undefined;
         }
-        if (target.nodeType === 56 /* Unpack */) {
+        if (target.nodeType === 56 /* ParseNodeType.Unpack */) {
             this._addError(localize_1.Localizer.Diagnostic.unpackIllegalInComprehension(), target);
         }
-        else if (target.nodeType === 16 /* DictionaryExpandEntry */) {
+        else if (target.nodeType === 16 /* ParseNodeType.DictionaryExpandEntry */) {
             this._addError(localize_1.Localizer.Diagnostic.dictExpandIllegalInComprehension(), target);
         }
         const listCompNode = parseNodes_1.ListComprehensionNode.create(target, isGenerator);
@@ -1277,24 +1281,24 @@ class Parser {
     // comp_for: ['async'] 'for' exprlist 'in' or_test [comp_iter]
     _tryParseCompForStatement() {
         const startTokenKeywordType = this._peekKeywordType();
-        if (startTokenKeywordType === 3 /* Async */) {
+        if (startTokenKeywordType === 3 /* KeywordType.Async */) {
             const nextToken = this._peekToken(1);
-            if (nextToken.type !== 8 /* Keyword */ || nextToken.keywordType !== 17 /* For */) {
+            if (nextToken.type !== 8 /* TokenType.Keyword */ || nextToken.keywordType !== 17 /* KeywordType.For */) {
                 return undefined;
             }
         }
-        else if (startTokenKeywordType !== 17 /* For */) {
+        else if (startTokenKeywordType !== 17 /* KeywordType.For */) {
             return undefined;
         }
         let asyncToken;
-        if (this._peekKeywordType() === 3 /* Async */) {
-            asyncToken = this._getKeywordToken(3 /* Async */);
+        if (this._peekKeywordType() === 3 /* KeywordType.Async */) {
+            asyncToken = this._getKeywordToken(3 /* KeywordType.Async */);
         }
-        const forToken = this._getKeywordToken(17 /* For */);
-        const targetExpr = this._parseExpressionListAsPossibleTuple(2 /* MissingExpression */, () => localize_1.Localizer.Diagnostic.expectedExpr(), forToken);
+        const forToken = this._getKeywordToken(17 /* KeywordType.For */);
+        const targetExpr = this._parseExpressionListAsPossibleTuple(2 /* ErrorExpressionCategory.MissingExpression */, () => localize_1.Localizer.Diagnostic.expectedExpr(), forToken);
         let seqExpr;
-        if (!this._consumeTokenIfKeyword(22 /* In */)) {
-            seqExpr = this._handleExpressionParseError(0 /* MissingIn */, localize_1.Localizer.Diagnostic.expectedIn());
+        if (!this._consumeTokenIfKeyword(22 /* KeywordType.In */)) {
+            seqExpr = this._handleExpressionParseError(0 /* ErrorExpressionCategory.MissingIn */, localize_1.Localizer.Diagnostic.expectedIn());
         }
         else {
             this._disallowAssignmentExpression(() => {
@@ -1311,10 +1315,10 @@ class Parser {
     // comp_if: 'if' test_nocond [comp_iter]
     // comp_iter: comp_for | comp_if
     _tryParseCompIfStatement() {
-        if (this._peekKeywordType() !== 20 /* If */) {
+        if (this._peekKeywordType() !== 20 /* KeywordType.If */) {
             return undefined;
         }
-        const ifToken = this._getKeywordToken(20 /* If */);
+        const ifToken = this._getKeywordToken(20 /* KeywordType.If */);
         const ifExpr = this._tryParseLambdaExpression() ||
             this._parseAssignmentExpression(/* disallowAssignmentExpression */ true);
         const compIfNode = parseNodes_1.ListComprehensionIfNode.create(ifToken, ifExpr);
@@ -1322,9 +1326,9 @@ class Parser {
     }
     // while_stmt: 'while' test suite ['else' suite]
     _parseWhileStatement() {
-        const whileToken = this._getKeywordToken(36 /* While */);
+        const whileToken = this._getKeywordToken(36 /* KeywordType.While */);
         const whileNode = parseNodes_1.WhileNode.create(whileToken, this._parseTestExpression(/* allowAssignmentExpression */ true), this._parseLoopSuite());
-        if (this._consumeTokenIfKeyword(13 /* Else */)) {
+        if (this._consumeTokenIfKeyword(13 /* KeywordType.Else */)) {
             whileNode.elseSuite = this._parseSuite(this._isInFunction);
             whileNode.elseSuite.parent = whileNode;
             (0, parseNodes_1.extendRange)(whileNode, whileNode.elseSuite);
@@ -1338,19 +1342,19 @@ class Parser {
     //         'finally' suite))
     // except_clause: 'except' [test ['as' NAME]]
     _parseTryStatement() {
-        const tryToken = this._getKeywordToken(34 /* Try */);
+        const tryToken = this._getKeywordToken(34 /* KeywordType.Try */);
         const trySuite = this._parseSuite(this._isInFunction);
         const tryNode = parseNodes_1.TryNode.create(tryToken, trySuite);
         let sawCatchAllExcept = false;
         while (true) {
             const exceptToken = this._peekToken();
-            if (!this._consumeTokenIfKeyword(14 /* Except */)) {
+            if (!this._consumeTokenIfKeyword(14 /* KeywordType.Except */)) {
                 break;
             }
             // See if this is a Python 3.11 exception group.
             const possibleStarToken = this._peekToken();
             let isExceptGroup = false;
-            if (this._consumeTokenIfOperator(26 /* Multiply */)) {
+            if (this._consumeTokenIfOperator(26 /* OperatorType.Multiply */)) {
                 if (this._getLanguageVersion() < pythonVersion_1.PythonVersion.V3_11 && !this._parseOptions.isStubFile) {
                     this._addError(localize_1.Localizer.Diagnostic.exceptionGroupIncompatible(), possibleStarToken);
                 }
@@ -1358,9 +1362,9 @@ class Parser {
             }
             let typeExpr;
             let symbolName;
-            if (this._peekTokenType() !== 10 /* Colon */) {
+            if (this._peekTokenType() !== 10 /* TokenType.Colon */) {
                 typeExpr = this._parseTestExpression(/* allowAssignmentExpression */ true);
-                if (this._consumeTokenIfKeyword(1 /* As */)) {
+                if (this._consumeTokenIfKeyword(1 /* KeywordType.As */)) {
                     symbolName = this._getTokenIfIdentifier();
                     if (!symbolName) {
                         this._addError(localize_1.Localizer.Diagnostic.expectedNameAfterAs(), this._peekToken());
@@ -1369,7 +1373,7 @@ class Parser {
                 else {
                     // Handle the python 2.x syntax in a graceful manner.
                     const peekToken = this._peekToken();
-                    if (this._consumeTokenIfType(12 /* Comma */)) {
+                    if (this._consumeTokenIfType(12 /* TokenType.Comma */)) {
                         this._addError(localize_1.Localizer.Diagnostic.expectedAsAfterException(), peekToken);
                         // Parse the expression expected in python 2.x, but discard it.
                         this._parseTestExpression(/* allowAssignmentExpression */ false);
@@ -1402,13 +1406,13 @@ class Parser {
         }
         if (tryNode.exceptClauses.length > 0) {
             (0, parseNodes_1.extendRange)(tryNode, tryNode.exceptClauses[tryNode.exceptClauses.length - 1]);
-            if (this._consumeTokenIfKeyword(13 /* Else */)) {
+            if (this._consumeTokenIfKeyword(13 /* KeywordType.Else */)) {
                 tryNode.elseSuite = this._parseSuite(this._isInFunction);
                 tryNode.elseSuite.parent = tryNode;
                 (0, parseNodes_1.extendRange)(tryNode, tryNode.elseSuite);
             }
         }
-        if (this._consumeTokenIfKeyword(16 /* Finally */)) {
+        if (this._consumeTokenIfKeyword(16 /* KeywordType.Finally */)) {
             tryNode.finallySuite = this._parseSuite(this._isInFunction);
             tryNode.finallySuite.parent = tryNode;
             (0, parseNodes_1.extendRange)(tryNode, tryNode.finallySuite);
@@ -1421,32 +1425,32 @@ class Parser {
     // funcdef: 'def' NAME parameters ['->' test] ':' suite
     // parameters: '(' [typedargslist] ')'
     _parseFunctionDef(asyncToken, decorators) {
-        const defToken = this._getKeywordToken(10 /* Def */);
+        const defToken = this._getKeywordToken(10 /* KeywordType.Def */);
         const nameToken = this._getTokenIfIdentifier();
         if (!nameToken) {
             this._addError(localize_1.Localizer.Diagnostic.expectedFunctionName(), defToken);
-            return parseNodes_1.ErrorNode.create(defToken, 10 /* MissingFunctionParameterList */, undefined, decorators);
+            return parseNodes_1.ErrorNode.create(defToken, 10 /* ErrorExpressionCategory.MissingFunctionParameterList */, undefined, decorators);
         }
         let typeParameters;
         const possibleOpenBracket = this._peekToken();
-        if (possibleOpenBracket.type === 15 /* OpenBracket */) {
+        if (possibleOpenBracket.type === 15 /* TokenType.OpenBracket */) {
             typeParameters = this._parseTypeParameterList();
             if (!this._parseOptions.isStubFile && this._getLanguageVersion() < pythonVersion_1.PythonVersion.V3_12) {
                 this._addError(localize_1.Localizer.Diagnostic.functionTypeParametersIllegal(), typeParameters);
             }
         }
         const openParenToken = this._peekToken();
-        if (!this._consumeTokenIfType(13 /* OpenParenthesis */)) {
+        if (!this._consumeTokenIfType(13 /* TokenType.OpenParenthesis */)) {
             this._addError(localize_1.Localizer.Diagnostic.expectedOpenParen(), this._peekToken());
-            return parseNodes_1.ErrorNode.create(nameToken, 10 /* MissingFunctionParameterList */, parseNodes_1.NameNode.create(nameToken), decorators);
+            return parseNodes_1.ErrorNode.create(nameToken, 10 /* ErrorExpressionCategory.MissingFunctionParameterList */, parseNodes_1.NameNode.create(nameToken), decorators);
         }
-        const paramList = this._parseVarArgsList(14 /* CloseParenthesis */, /* allowAnnotations */ true);
-        if (!this._consumeTokenIfType(14 /* CloseParenthesis */)) {
+        const paramList = this._parseVarArgsList(14 /* TokenType.CloseParenthesis */, /* allowAnnotations */ true);
+        if (!this._consumeTokenIfType(14 /* TokenType.CloseParenthesis */)) {
             this._addError(localize_1.Localizer.Diagnostic.expectedCloseParen(), openParenToken);
-            this._consumeTokensUntilType([10 /* Colon */]);
+            this._consumeTokensUntilType([10 /* TokenType.Colon */]);
         }
         let returnType;
-        if (this._consumeTokenIfType(21 /* Arrow */)) {
+        if (this._consumeTokenIfType(21 /* TokenType.Arrow */)) {
             returnType = this._parseTypeAnnotation();
         }
         let functionTypeAnnotationToken;
@@ -1525,12 +1529,12 @@ class Parser {
                     paramMap.set(name, name);
                 }
             }
-            else if (param.category === 0 /* Simple */) {
+            else if (param.category === 0 /* ParameterCategory.Simple */) {
                 if (paramList.length === 0) {
                     this._addError(localize_1.Localizer.Diagnostic.positionOnlyFirstParam(), param);
                 }
             }
-            if (param.category === 0 /* Simple */) {
+            if (param.category === 0 /* ParameterCategory.Simple */) {
                 if (!param.name) {
                     if (sawPositionOnlySeparator) {
                         this._addError(localize_1.Localizer.Diagnostic.duplicatePositionOnly(), param);
@@ -1560,7 +1564,7 @@ class Parser {
                 }
             }
             paramList.push(param);
-            if (param.category === 1 /* ArgsList */) {
+            if (param.category === 1 /* ParameterCategory.ArgsList */) {
                 if (!param.name) {
                     if (sawKeywordOnlySeparator) {
                         this._addError(localize_1.Localizer.Diagnostic.duplicateKeywordOnly(), param);
@@ -1577,7 +1581,7 @@ class Parser {
                     sawArgs = true;
                 }
             }
-            if (param.category === 2 /* KwargsDict */) {
+            if (param.category === 2 /* ParameterCategory.KwargsDict */) {
                 if (sawKwArgs) {
                     this._addError(localize_1.Localizer.Diagnostic.duplicateKwargsParam(), param);
                 }
@@ -1590,7 +1594,7 @@ class Parser {
             else if (sawKwArgs) {
                 this._addError(localize_1.Localizer.Diagnostic.paramAfterKwargsParam(), param);
             }
-            const foundComma = this._consumeTokenIfType(12 /* Comma */);
+            const foundComma = this._consumeTokenIfType(12 /* TokenType.Comma */);
             if (allowAnnotations && !param.typeAnnotation) {
                 // Look for a type annotation comment at the end of the line.
                 const typeAnnotationComment = this._parseVariableTypeAnnotationComment();
@@ -1606,7 +1610,7 @@ class Parser {
         }
         if (paramList.length > 0) {
             const lastParam = paramList[paramList.length - 1];
-            if (lastParam.category === 1 /* ArgsList */ && !lastParam.name) {
+            if (lastParam.category === 1 /* ParameterCategory.ArgsList */ && !lastParam.name) {
                 this._addError(localize_1.Localizer.Diagnostic.expectedNamedParameter(), lastParam);
             }
         }
@@ -1616,13 +1620,13 @@ class Parser {
         let starCount = 0;
         let slashCount = 0;
         const firstToken = this._peekToken();
-        if (this._consumeTokenIfOperator(26 /* Multiply */)) {
+        if (this._consumeTokenIfOperator(26 /* OperatorType.Multiply */)) {
             starCount = 1;
         }
-        else if (this._consumeTokenIfOperator(29 /* Power */)) {
+        else if (this._consumeTokenIfOperator(29 /* OperatorType.Power */)) {
             starCount = 2;
         }
-        else if (this._consumeTokenIfOperator(10 /* Divide */)) {
+        else if (this._consumeTokenIfOperator(10 /* OperatorType.Divide */)) {
             if (this._getLanguageVersion() < pythonVersion_1.PythonVersion.V3_8 && !this._parseOptions.isStubFile) {
                 this._addError(localize_1.Localizer.Diagnostic.positionOnlyIncompatible(), firstToken);
             }
@@ -1631,17 +1635,17 @@ class Parser {
         const paramName = this._getTokenIfIdentifier();
         if (!paramName) {
             if (starCount === 1) {
-                const paramNode = parseNodes_1.ParameterNode.create(firstToken, 1 /* ArgsList */);
+                const paramNode = parseNodes_1.ParameterNode.create(firstToken, 1 /* ParameterCategory.ArgsList */);
                 return paramNode;
             }
             else if (slashCount === 1) {
-                const paramNode = parseNodes_1.ParameterNode.create(firstToken, 0 /* Simple */);
+                const paramNode = parseNodes_1.ParameterNode.create(firstToken, 0 /* ParameterCategory.Simple */);
                 return paramNode;
             }
             // Check for the Python 2.x parameter sublist syntax and handle it gracefully.
-            if (this._peekTokenType() === 13 /* OpenParenthesis */) {
+            if (this._peekTokenType() === 13 /* TokenType.OpenParenthesis */) {
                 const sublistStart = this._getNextToken();
-                if (this._consumeTokensUntilType([14 /* CloseParenthesis */])) {
+                if (this._consumeTokensUntilType([14 /* TokenType.CloseParenthesis */])) {
                     this._getNextToken();
                 }
                 this._addError(localize_1.Localizer.Diagnostic.sublistParamsIncompatible(), sublistStart);
@@ -1650,12 +1654,12 @@ class Parser {
                 this._addError(localize_1.Localizer.Diagnostic.expectedParamName(), this._peekToken());
             }
         }
-        let paramType = 0 /* Simple */;
+        let paramType = 0 /* ParameterCategory.Simple */;
         if (starCount === 1) {
-            paramType = 1 /* ArgsList */;
+            paramType = 1 /* ParameterCategory.ArgsList */;
         }
         else if (starCount === 2) {
-            paramType = 2 /* KwargsDict */;
+            paramType = 2 /* ParameterCategory.KwargsDict */;
         }
         const paramNode = parseNodes_1.ParameterNode.create(firstToken, paramType);
         if (paramName) {
@@ -1663,12 +1667,12 @@ class Parser {
             paramNode.name.parent = paramNode;
             (0, parseNodes_1.extendRange)(paramNode, paramName);
         }
-        if (allowAnnotations && this._consumeTokenIfType(10 /* Colon */)) {
-            paramNode.typeAnnotation = this._parseTypeAnnotation(paramType === 1 /* ArgsList */);
+        if (allowAnnotations && this._consumeTokenIfType(10 /* TokenType.Colon */)) {
+            paramNode.typeAnnotation = this._parseTypeAnnotation(paramType === 1 /* ParameterCategory.ArgsList */);
             paramNode.typeAnnotation.parent = paramNode;
             (0, parseNodes_1.extendRange)(paramNode, paramNode.typeAnnotation);
         }
-        if (this._consumeTokenIfOperator(2 /* Assign */)) {
+        if (this._consumeTokenIfOperator(2 /* OperatorType.Assign */)) {
             paramNode.defaultValue = this._parseTestExpression(/* allowAssignmentExpression */ false);
             paramNode.defaultValue.parent = paramNode;
             (0, parseNodes_1.extendRange)(paramNode, paramNode.defaultValue);
@@ -1682,7 +1686,7 @@ class Parser {
     // Python 3.10 adds support for optional parentheses around
     // with_item list.
     _parseWithStatement(asyncToken) {
-        const withToken = this._getKeywordToken(37 /* With */);
+        const withToken = this._getKeywordToken(37 /* KeywordType.With */);
         let withItemList = [];
         const possibleParen = this._peekToken();
         // If the expression starts with a paren, parse it as though the
@@ -1690,21 +1694,21 @@ class Parser {
         // "dry run" to determine whether the entire list of "with items"
         // is enclosed in parentheses.
         let isParenthesizedWithItemList = false;
-        if (possibleParen.type === 13 /* OpenParenthesis */) {
+        if (possibleParen.type === 13 /* TokenType.OpenParenthesis */) {
             const openParenTokenIndex = this._tokenIndex;
             this._suppressErrors(() => {
                 this._getNextToken();
                 while (true) {
                     withItemList.push(this._parseWithItem());
-                    if (!this._consumeTokenIfType(12 /* Comma */)) {
+                    if (!this._consumeTokenIfType(12 /* TokenType.Comma */)) {
                         break;
                     }
-                    if (this._peekToken().type === 14 /* CloseParenthesis */) {
+                    if (this._peekToken().type === 14 /* TokenType.CloseParenthesis */) {
                         break;
                     }
                 }
-                if (this._peekToken().type === 14 /* CloseParenthesis */ &&
-                    this._peekToken(1).type === 10 /* Colon */) {
+                if (this._peekToken().type === 14 /* TokenType.CloseParenthesis */ &&
+                    this._peekToken(1).type === 10 /* TokenType.Colon */) {
                     isParenthesizedWithItemList = withItemList.length !== 1 || withItemList[0].target !== undefined;
                 }
                 this._tokenIndex = openParenTokenIndex;
@@ -1712,22 +1716,22 @@ class Parser {
             });
         }
         if (isParenthesizedWithItemList) {
-            this._consumeTokenIfType(13 /* OpenParenthesis */);
+            this._consumeTokenIfType(13 /* TokenType.OpenParenthesis */);
             if (this._getLanguageVersion() < pythonVersion_1.PythonVersion.V3_9) {
                 this._addError(localize_1.Localizer.Diagnostic.parenthesizedContextManagerIllegal(), possibleParen);
             }
         }
         while (true) {
             withItemList.push(this._parseWithItem());
-            if (!this._consumeTokenIfType(12 /* Comma */)) {
+            if (!this._consumeTokenIfType(12 /* TokenType.Comma */)) {
                 break;
             }
-            if (this._peekToken().type === 14 /* CloseParenthesis */) {
+            if (this._peekToken().type === 14 /* TokenType.CloseParenthesis */) {
                 break;
             }
         }
         if (isParenthesizedWithItemList) {
-            if (!this._consumeTokenIfType(14 /* CloseParenthesis */)) {
+            if (!this._consumeTokenIfType(14 /* TokenType.CloseParenthesis */)) {
                 this._addError(localize_1.Localizer.Diagnostic.expectedCloseParen(), possibleParen);
             }
         }
@@ -1757,7 +1761,7 @@ class Parser {
     _parseWithItem() {
         const expr = this._parseTestExpression(/* allowAssignmentExpression */ true);
         const itemNode = parseNodes_1.WithItemNode.create(expr);
-        if (this._consumeTokenIfKeyword(1 /* As */)) {
+        if (this._consumeTokenIfKeyword(1 /* KeywordType.As */)) {
             itemNode.target = this._parseExpression(/* allowUnpack */ false);
             itemNode.target.parent = itemNode;
             (0, parseNodes_1.extendRange)(itemNode, itemNode.target);
@@ -1769,7 +1773,7 @@ class Parser {
     _parseDecorated() {
         const decoratorList = [];
         while (true) {
-            if (this._peekOperatorType() === 22 /* MatrixMultiply */) {
+            if (this._peekOperatorType() === 22 /* OperatorType.MatrixMultiply */) {
                 decoratorList.push(this._parseDecorator());
             }
             else {
@@ -1777,20 +1781,20 @@ class Parser {
             }
         }
         const nextToken = this._peekToken();
-        if (nextToken.type === 8 /* Keyword */) {
-            if (nextToken.keywordType === 3 /* Async */) {
+        if (nextToken.type === 8 /* TokenType.Keyword */) {
+            if (nextToken.keywordType === 3 /* KeywordType.Async */) {
                 this._getNextToken();
-                if (this._peekKeywordType() !== 10 /* Def */) {
+                if (this._peekKeywordType() !== 10 /* KeywordType.Def */) {
                     this._addError(localize_1.Localizer.Diagnostic.expectedFunctionAfterAsync(), this._peekToken());
                 }
                 else {
                     return this._parseFunctionDef(nextToken, decoratorList);
                 }
             }
-            else if (nextToken.keywordType === 10 /* Def */) {
+            else if (nextToken.keywordType === 10 /* KeywordType.Def */) {
                 return this._parseFunctionDef(undefined, decoratorList);
             }
-            else if (nextToken.keywordType === 7 /* Class */) {
+            else if (nextToken.keywordType === 7 /* KeywordType.Class */) {
                 return this._parseClassDef(decoratorList);
             }
         }
@@ -1802,7 +1806,7 @@ class Parser {
     // decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE
     _parseDecorator() {
         const atOperator = this._getNextToken();
-        (0, debug_1.assert)(atOperator.operatorType === 22 /* MatrixMultiply */);
+        (0, debug_1.assert)(atOperator.operatorType === 22 /* OperatorType.MatrixMultiply */);
         const expression = this._parseTestExpression(/* allowAssignmentExpression */ true);
         // Versions of Python prior to 3.9 support a limited set of
         // expression forms.
@@ -1811,7 +1815,7 @@ class Parser {
             if (this._isNameOrMemberAccessExpression(expression)) {
                 isSupportedExpressionForm = true;
             }
-            else if (expression.nodeType === 9 /* Call */ &&
+            else if (expression.nodeType === 9 /* ParseNodeType.Call */ &&
                 this._isNameOrMemberAccessExpression(expression.leftExpression)) {
                 isSupportedExpressionForm = true;
             }
@@ -1820,24 +1824,24 @@ class Parser {
             }
         }
         const decoratorNode = parseNodes_1.DecoratorNode.create(atOperator, expression);
-        if (!this._consumeTokenIfType(2 /* NewLine */)) {
+        if (!this._consumeTokenIfType(2 /* TokenType.NewLine */)) {
             this._addError(localize_1.Localizer.Diagnostic.expectedDecoratorNewline(), this._peekToken());
-            this._consumeTokensUntilType([2 /* NewLine */]);
+            this._consumeTokensUntilType([2 /* TokenType.NewLine */]);
         }
         return decoratorNode;
     }
     _isNameOrMemberAccessExpression(expression) {
-        if (expression.nodeType === 38 /* Name */) {
+        if (expression.nodeType === 38 /* ParseNodeType.Name */) {
             return true;
         }
-        else if (expression.nodeType === 35 /* MemberAccess */) {
+        else if (expression.nodeType === 35 /* ParseNodeType.MemberAccess */) {
             return this._isNameOrMemberAccessExpression(expression.leftExpression);
         }
         return false;
     }
     // classdef: 'class' NAME ['(' [arglist] ')'] suite
     _parseClassDef(decorators) {
-        const classToken = this._getKeywordToken(7 /* Class */);
+        const classToken = this._getKeywordToken(7 /* KeywordType.Class */);
         let nameToken = this._getTokenIfIdentifier();
         if (!nameToken) {
             this._addError(localize_1.Localizer.Diagnostic.expectedClassName(), this._peekToken());
@@ -1845,7 +1849,7 @@ class Parser {
         }
         let typeParameters;
         const possibleOpenBracket = this._peekToken();
-        if (possibleOpenBracket.type === 15 /* OpenBracket */) {
+        if (possibleOpenBracket.type === 15 /* TokenType.OpenBracket */) {
             typeParameters = this._parseTypeParameterList();
             if (!this._parseOptions.isStubFile && this._getLanguageVersion() < pythonVersion_1.PythonVersion.V3_12) {
                 this._addError(localize_1.Localizer.Diagnostic.classTypeParametersIllegal(), typeParameters);
@@ -1853,9 +1857,9 @@ class Parser {
         }
         let argList = [];
         const openParenToken = this._peekToken();
-        if (this._consumeTokenIfType(13 /* OpenParenthesis */)) {
+        if (this._consumeTokenIfType(13 /* TokenType.OpenParenthesis */)) {
             argList = this._parseArgList().args;
-            if (!this._consumeTokenIfType(14 /* CloseParenthesis */)) {
+            if (!this._consumeTokenIfType(14 /* TokenType.CloseParenthesis */)) {
                 this._addError(localize_1.Localizer.Diagnostic.expectedCloseParen(), openParenToken);
             }
         }
@@ -1877,17 +1881,17 @@ class Parser {
         return classNode;
     }
     _parsePassStatement() {
-        return parseNodes_1.PassNode.create(this._getKeywordToken(30 /* Pass */));
+        return parseNodes_1.PassNode.create(this._getKeywordToken(30 /* KeywordType.Pass */));
     }
     _parseBreakStatement() {
-        const breakToken = this._getKeywordToken(5 /* Break */);
+        const breakToken = this._getKeywordToken(5 /* KeywordType.Break */);
         if (!this._isInLoop) {
             this._addError(localize_1.Localizer.Diagnostic.breakOutsideLoop(), breakToken);
         }
         return parseNodes_1.BreakNode.create(breakToken);
     }
     _parseContinueStatement() {
-        const continueToken = this._getKeywordToken(8 /* Continue */);
+        const continueToken = this._getKeywordToken(8 /* KeywordType.Continue */);
         if (!this._isInLoop) {
             this._addError(localize_1.Localizer.Diagnostic.continueOutsideLoop(), continueToken);
         }
@@ -1898,7 +1902,7 @@ class Parser {
     }
     // return_stmt: 'return' [testlist]
     _parseReturnStatement() {
-        const returnToken = this._getKeywordToken(32 /* Return */);
+        const returnToken = this._getKeywordToken(32 /* KeywordType.Return */);
         const returnNode = parseNodes_1.ReturnNode.create(returnToken);
         if (!this._isInFunction) {
             this._addError(localize_1.Localizer.Diagnostic.returnOutsideFunction(), returnToken);
@@ -1906,7 +1910,7 @@ class Parser {
         if (!this._isNextTokenNeverExpression()) {
             const returnExpr = this._parseTestOrStarListAsExpression(
             /* allowAssignmentExpression */ true, 
-            /* allowMultipleUnpack */ true, 2 /* MissingExpression */, () => localize_1.Localizer.Diagnostic.expectedReturnExpr());
+            /* allowMultipleUnpack */ true, 2 /* ErrorExpressionCategory.MissingExpression */, () => localize_1.Localizer.Diagnostic.expectedReturnExpr());
             this._reportConditionalErrorForStarTupleElement(returnExpr);
             returnNode.returnExpression = returnExpr;
             returnNode.returnExpression.parent = returnNode;
@@ -1919,14 +1923,14 @@ class Parser {
     // import_as_names: import_as_name (',' import_as_name)* [',']
     // import_as_name: NAME ['as' NAME]
     _parseFromStatement() {
-        const fromToken = this._getKeywordToken(18 /* From */);
+        const fromToken = this._getKeywordToken(18 /* KeywordType.From */);
         const modName = this._parseDottedModuleName(/* allowJustDots */ true);
         const importFromNode = parseNodes_1.ImportFromNode.create(fromToken, modName);
         // Handle imports from __future__ specially because they can
         // change the way we interpret the rest of the file.
         const isFutureImport = modName.leadingDots === 0 && modName.nameParts.length === 1 && modName.nameParts[0].value === '__future__';
         const possibleInputToken = this._peekToken();
-        if (!this._consumeTokenIfKeyword(21 /* Import */)) {
+        if (!this._consumeTokenIfKeyword(21 /* KeywordType.Import */)) {
             this._addError(localize_1.Localizer.Diagnostic.expectedImport(), this._peekToken());
             if (!modName.hasTrailingDot) {
                 importFromNode.missingImportKeyword = true;
@@ -1936,7 +1940,7 @@ class Parser {
             (0, parseNodes_1.extendRange)(importFromNode, possibleInputToken);
             // Look for "*" token.
             const possibleStarToken = this._peekToken();
-            if (this._consumeTokenIfOperator(26 /* Multiply */)) {
+            if (this._consumeTokenIfOperator(26 /* OperatorType.Multiply */)) {
                 (0, parseNodes_1.extendRange)(importFromNode, possibleStarToken);
                 importFromNode.isWildcardImport = true;
                 importFromNode.wildcardToken = possibleStarToken;
@@ -1944,7 +1948,7 @@ class Parser {
             }
             else {
                 const openParenToken = this._peekToken();
-                const inParen = this._consumeTokenIfType(13 /* OpenParenthesis */);
+                const inParen = this._consumeTokenIfType(13 /* TokenType.OpenParenthesis */);
                 let trailingCommaToken;
                 while (true) {
                     const importName = this._getTokenIfIdentifier();
@@ -1953,7 +1957,7 @@ class Parser {
                     }
                     trailingCommaToken = undefined;
                     const importFromAsNode = parseNodes_1.ImportFromAsNode.create(parseNodes_1.NameNode.create(importName));
-                    if (this._consumeTokenIfKeyword(1 /* As */)) {
+                    if (this._consumeTokenIfKeyword(1 /* KeywordType.As */)) {
                         const aliasName = this._getTokenIfIdentifier();
                         if (!aliasName) {
                             this._addError(localize_1.Localizer.Diagnostic.expectedImportAlias(), this._peekToken());
@@ -1972,7 +1976,7 @@ class Parser {
                         this._futureImports.add(importName.value);
                     }
                     const nextToken = this._peekToken();
-                    if (!this._consumeTokenIfType(12 /* Comma */)) {
+                    if (!this._consumeTokenIfType(12 /* TokenType.Comma */)) {
                         break;
                     }
                     trailingCommaToken = nextToken;
@@ -1983,7 +1987,7 @@ class Parser {
                 if (inParen) {
                     importFromNode.usesParens = true;
                     const nextToken = this._peekToken();
-                    if (!this._consumeTokenIfType(14 /* CloseParenthesis */)) {
+                    if (!this._consumeTokenIfType(14 /* TokenType.CloseParenthesis */)) {
                         this._addError(localize_1.Localizer.Diagnostic.expectedCloseParen(), openParenToken);
                     }
                     else {
@@ -2031,12 +2035,12 @@ class Parser {
     // dotted_as_name: dotted_name ['as' NAME]
     _parseImportStatement() {
         var _a;
-        const importToken = this._getKeywordToken(21 /* Import */);
+        const importToken = this._getKeywordToken(21 /* KeywordType.Import */);
         const importNode = parseNodes_1.ImportNode.create(importToken);
         while (true) {
             const modName = this._parseDottedModuleName();
             const importAsNode = parseNodes_1.ImportAsNode.create(modName);
-            if (this._consumeTokenIfKeyword(1 /* As */)) {
+            if (this._consumeTokenIfKeyword(1 /* KeywordType.As */)) {
                 const aliasToken = this._getTokenIfIdentifier();
                 if (aliasToken) {
                     importAsNode.alias = parseNodes_1.NameNode.create(aliasToken);
@@ -2081,7 +2085,7 @@ class Parser {
                     this._typingImportAliases.push(((_a = importAsNode.alias) === null || _a === void 0 ? void 0 : _a.value) || firstNamePartValue);
                 }
             }
-            if (!this._consumeTokenIfType(12 /* Comma */)) {
+            if (!this._consumeTokenIfType(12 /* TokenType.Comma */)) {
                 break;
             }
         }
@@ -2096,9 +2100,9 @@ class Parser {
         var _a;
         const moduleNameNode = parseNodes_1.ModuleNameNode.create(this._peekToken());
         while (true) {
-            const token = (_a = this._getTokenIfType(19 /* Ellipsis */)) !== null && _a !== void 0 ? _a : this._getTokenIfType(20 /* Dot */);
+            const token = (_a = this._getTokenIfType(19 /* TokenType.Ellipsis */)) !== null && _a !== void 0 ? _a : this._getTokenIfType(20 /* TokenType.Dot */);
             if (token) {
-                if (token.type === 19 /* Ellipsis */) {
+                if (token.type === 19 /* TokenType.Ellipsis */) {
                     moduleNameNode.leadingDots += 3;
                 }
                 else {
@@ -2124,7 +2128,7 @@ class Parser {
             namePart.parent = moduleNameNode;
             (0, parseNodes_1.extendRange)(moduleNameNode, namePart);
             const nextToken = this._peekToken();
-            if (!this._consumeTokenIfType(20 /* Dot */)) {
+            if (!this._consumeTokenIfType(20 /* TokenType.Dot */)) {
                 break;
             }
             // Extend the module name to include the dot.
@@ -2133,7 +2137,7 @@ class Parser {
         return moduleNameNode;
     }
     _parseGlobalStatement() {
-        const globalToken = this._getKeywordToken(19 /* Global */);
+        const globalToken = this._getKeywordToken(19 /* KeywordType.Global */);
         const globalNode = parseNodes_1.GlobalNode.create(globalToken);
         globalNode.nameList = this._parseNameList();
         if (globalNode.nameList.length > 0) {
@@ -2145,7 +2149,7 @@ class Parser {
         return globalNode;
     }
     _parseNonlocalStatement() {
-        const nonlocalToken = this._getKeywordToken(27 /* Nonlocal */);
+        const nonlocalToken = this._getKeywordToken(27 /* KeywordType.Nonlocal */);
         const nonlocalNode = parseNodes_1.NonlocalNode.create(nonlocalToken);
         nonlocalNode.nameList = this._parseNameList();
         if (nonlocalNode.nameList.length > 0) {
@@ -2165,7 +2169,7 @@ class Parser {
                 break;
             }
             nameList.push(parseNodes_1.NameNode.create(name));
-            if (!this._consumeTokenIfType(12 /* Comma */)) {
+            if (!this._consumeTokenIfType(12 /* TokenType.Comma */)) {
                 break;
             }
         }
@@ -2174,24 +2178,24 @@ class Parser {
     // raise_stmt: 'raise' [test ['from' test]]
     // (old) raise_stmt: 'raise' [test [',' test [',' test]]]
     _parseRaiseStatement() {
-        const raiseToken = this._getKeywordToken(31 /* Raise */);
+        const raiseToken = this._getKeywordToken(31 /* KeywordType.Raise */);
         const raiseNode = parseNodes_1.RaiseNode.create(raiseToken);
         if (!this._isNextTokenNeverExpression()) {
             raiseNode.typeExpression = this._parseTestExpression(/* allowAssignmentExpression */ true);
             raiseNode.typeExpression.parent = raiseNode;
             (0, parseNodes_1.extendRange)(raiseNode, raiseNode.typeExpression);
-            if (this._consumeTokenIfKeyword(18 /* From */)) {
+            if (this._consumeTokenIfKeyword(18 /* KeywordType.From */)) {
                 raiseNode.valueExpression = this._parseTestExpression(/* allowAssignmentExpression */ true);
                 raiseNode.valueExpression.parent = raiseNode;
                 (0, parseNodes_1.extendRange)(raiseNode, raiseNode.valueExpression);
             }
             else {
-                if (this._consumeTokenIfType(12 /* Comma */)) {
+                if (this._consumeTokenIfType(12 /* TokenType.Comma */)) {
                     // Handle the Python 2.x variant
                     raiseNode.valueExpression = this._parseTestExpression(/* allowAssignmentExpression */ true);
                     raiseNode.valueExpression.parent = raiseNode;
                     (0, parseNodes_1.extendRange)(raiseNode, raiseNode.valueExpression);
-                    if (this._consumeTokenIfType(12 /* Comma */)) {
+                    if (this._consumeTokenIfType(12 /* TokenType.Comma */)) {
                         raiseNode.tracebackExpression = this._parseTestExpression(/* allowAssignmentExpression */ true);
                         raiseNode.tracebackExpression.parent = raiseNode;
                         (0, parseNodes_1.extendRange)(raiseNode, raiseNode.tracebackExpression);
@@ -2203,10 +2207,10 @@ class Parser {
     }
     // assert_stmt: 'assert' test [',' test]
     _parseAssertStatement() {
-        const assertToken = this._getKeywordToken(2 /* Assert */);
+        const assertToken = this._getKeywordToken(2 /* KeywordType.Assert */);
         const expr = this._parseTestExpression(/* allowAssignmentExpression */ false);
         const assertNode = parseNodes_1.AssertNode.create(assertToken, expr);
-        if (this._consumeTokenIfType(12 /* Comma */)) {
+        if (this._consumeTokenIfType(12 /* TokenType.Comma */)) {
             const exceptionExpr = this._parseTestExpression(/* allowAssignmentExpression */ false);
             assertNode.exceptionExpression = exceptionExpr;
             assertNode.exceptionExpression.parent = assertNode;
@@ -2216,7 +2220,7 @@ class Parser {
     }
     // del_stmt: 'del' exprlist
     _parseDelStatement() {
-        const delToken = this._getKeywordToken(11 /* Del */);
+        const delToken = this._getKeywordToken(11 /* KeywordType.Del */);
         const exprListResult = this._parseExpressionList(/* allowStar */ true);
         if (!exprListResult.parseError && exprListResult.list.length === 0) {
             this._addError(localize_1.Localizer.Diagnostic.expectedDelExpr(), this._peekToken());
@@ -2234,9 +2238,9 @@ class Parser {
     // yield_expr: 'yield' [yield_arg]
     // yield_arg: 'from' test | testlist
     _parseYieldExpression() {
-        const yieldToken = this._getKeywordToken(38 /* Yield */);
+        const yieldToken = this._getKeywordToken(38 /* KeywordType.Yield */);
         const nextToken = this._peekToken();
-        if (this._consumeTokenIfKeyword(18 /* From */)) {
+        if (this._consumeTokenIfKeyword(18 /* KeywordType.From */)) {
             if (this._getLanguageVersion() < pythonVersion_1.PythonVersion.V3_3) {
                 this._addError(localize_1.Localizer.Diagnostic.yieldFromIllegal(), nextToken);
             }
@@ -2246,13 +2250,13 @@ class Parser {
         if (!this._isNextTokenNeverExpression()) {
             exprList = this._parseTestOrStarListAsExpression(
             /* allowAssignmentExpression */ false, 
-            /* allowMultipleUnpack */ true, 2 /* MissingExpression */, () => localize_1.Localizer.Diagnostic.expectedYieldExpr());
+            /* allowMultipleUnpack */ true, 2 /* ErrorExpressionCategory.MissingExpression */, () => localize_1.Localizer.Diagnostic.expectedYieldExpr());
             this._reportConditionalErrorForStarTupleElement(exprList);
         }
         return parseNodes_1.YieldNode.create(yieldToken, exprList);
     }
     _tryParseYieldExpression() {
-        if (this._peekKeywordType() !== 38 /* Yield */) {
+        if (this._peekKeywordType() !== 38 /* KeywordType.Yield */) {
             return undefined;
         }
         return this._parseYieldExpression();
@@ -2262,34 +2266,34 @@ class Parser {
         const statement = parseNodes_1.StatementListNode.create(this._peekToken());
         while (true) {
             // Swallow invalid tokens to make sure we make forward progress.
-            if (this._peekTokenType() === 0 /* Invalid */) {
+            if (this._peekTokenType() === 0 /* TokenType.Invalid */) {
                 const invalidToken = this._getNextToken();
                 const text = this._fileContents.substr(invalidToken.start, invalidToken.length);
                 const firstCharCode = text.charCodeAt(0);
                 // Remove any non-printable characters.
                 this._addError(localize_1.Localizer.Diagnostic.invalidTokenChars().format({ text: `\\u${firstCharCode.toString(16)}` }), invalidToken);
-                this._consumeTokensUntilType([2 /* NewLine */]);
+                this._consumeTokensUntilType([2 /* TokenType.NewLine */]);
                 break;
             }
             const smallStatement = this._parseSmallStatement();
             statement.statements.push(smallStatement);
             smallStatement.parent = statement;
             (0, parseNodes_1.extendRange)(statement, smallStatement);
-            if (smallStatement.nodeType === 0 /* Error */) {
+            if (smallStatement.nodeType === 0 /* ParseNodeType.Error */) {
                 // No need to log an error here. We assume that
                 // it was already logged by _parseSmallStatement.
                 break;
             }
             // Consume the semicolon if present.
-            if (!this._consumeTokenIfType(11 /* Semicolon */)) {
+            if (!this._consumeTokenIfType(11 /* TokenType.Semicolon */)) {
                 break;
             }
             const nextTokenType = this._peekTokenType();
-            if (nextTokenType === 2 /* NewLine */ || nextTokenType === 1 /* EndOfStream */) {
+            if (nextTokenType === 2 /* TokenType.NewLine */ || nextTokenType === 1 /* TokenType.EndOfStream */) {
                 break;
             }
         }
-        if (!this._consumeTokenIfType(2 /* NewLine */)) {
+        if (!this._consumeTokenIfType(2 /* TokenType.NewLine */)) {
             this._addError(localize_1.Localizer.Diagnostic.expectedNewlineOrSemicolon(), this._peekToken());
         }
         return statement;
@@ -2300,42 +2304,42 @@ class Parser {
     // import_stmt: import_name | import_from
     _parseSmallStatement() {
         switch (this._peekKeywordType()) {
-            case 30 /* Pass */:
+            case 30 /* KeywordType.Pass */:
                 return this._parsePassStatement();
-            case 5 /* Break */:
+            case 5 /* KeywordType.Break */:
                 return this._parseBreakStatement();
-            case 8 /* Continue */:
+            case 8 /* KeywordType.Continue */:
                 return this._parseContinueStatement();
-            case 32 /* Return */:
+            case 32 /* KeywordType.Return */:
                 return this._parseReturnStatement();
-            case 18 /* From */:
+            case 18 /* KeywordType.From */:
                 return this._parseFromStatement();
-            case 21 /* Import */:
+            case 21 /* KeywordType.Import */:
                 return this._parseImportStatement();
-            case 19 /* Global */:
+            case 19 /* KeywordType.Global */:
                 return this._parseGlobalStatement();
-            case 27 /* Nonlocal */:
+            case 27 /* KeywordType.Nonlocal */:
                 return this._parseNonlocalStatement();
-            case 31 /* Raise */:
+            case 31 /* KeywordType.Raise */:
                 return this._parseRaiseStatement();
-            case 2 /* Assert */:
+            case 2 /* KeywordType.Assert */:
                 return this._parseAssertStatement();
-            case 11 /* Del */:
+            case 11 /* KeywordType.Del */:
                 return this._parseDelStatement();
-            case 38 /* Yield */:
+            case 38 /* KeywordType.Yield */:
                 return this._parseYieldExpression();
-            case 35 /* Type */: {
+            case 35 /* KeywordType.Type */: {
                 // Type is considered a "soft" keyword, so we will treat it
                 // as an identifier if it is followed by an unexpected token.
                 const peekToken1 = this._peekToken(1);
                 const peekToken2 = this._peekToken(2);
                 let isInvalidTypeToken = true;
-                if (peekToken1.type === 7 /* Identifier */ || peekToken1.type === 8 /* Keyword */) {
-                    if (peekToken2.type === 15 /* OpenBracket */) {
+                if (peekToken1.type === 7 /* TokenType.Identifier */ || peekToken1.type === 8 /* TokenType.Keyword */) {
+                    if (peekToken2.type === 15 /* TokenType.OpenBracket */) {
                         isInvalidTypeToken = false;
                     }
-                    else if (peekToken2.type === 9 /* Operator */ &&
-                        peekToken2.operatorType === 2 /* Assign */) {
+                    else if (peekToken2.type === 9 /* TokenType.Operator */ &&
+                        peekToken2.operatorType === 2 /* OperatorType.Assign */) {
                         isInvalidTypeToken = false;
                     }
                 }
@@ -2351,7 +2355,7 @@ class Parser {
         // A single-element tuple with no trailing comma is simply an expression
         // that's surrounded by parens.
         if (exprListResult.list.length === 1 && !exprListResult.trailingComma) {
-            if (exprListResult.list[0].nodeType === 56 /* Unpack */) {
+            if (exprListResult.list[0].nodeType === 56 /* ParseNodeType.Unpack */) {
                 this._addError(localize_1.Localizer.Diagnostic.unpackOperatorNotAllowed(), exprListResult.list[0]);
             }
             return exprListResult.list[0];
@@ -2412,7 +2416,7 @@ class Parser {
         if (!allowMultipleUnpack && !exprListResult.parseError) {
             let sawStar = false;
             for (const expr of exprListResult.list) {
-                if (expr.nodeType === 56 /* Unpack */) {
+                if (expr.nodeType === 56 /* ParseNodeType.Unpack */) {
                     if (sawStar) {
                         this._addError(localize_1.Localizer.Diagnostic.duplicateUnpack(), expr);
                         break;
@@ -2428,36 +2432,36 @@ class Parser {
     // star_expr: '*' expr
     _parseExpression(allowUnpack) {
         const startToken = this._peekToken();
-        if (allowUnpack && this._consumeTokenIfOperator(26 /* Multiply */)) {
+        if (allowUnpack && this._consumeTokenIfOperator(26 /* OperatorType.Multiply */)) {
             return parseNodes_1.UnpackNode.create(startToken, this._parseExpression(/* allowUnpack */ false));
         }
         return this._parseBitwiseOrExpression();
     }
     // test_or_star: test | star_expr
     _parseTestOrStarExpression(allowAssignmentExpression) {
-        if (this._peekOperatorType() === 26 /* Multiply */) {
+        if (this._peekOperatorType() === 26 /* OperatorType.Multiply */) {
             return this._parseExpression(/* allowUnpack */ true);
         }
         return this._parseTestExpression(allowAssignmentExpression);
     }
     // test: or_test ['if' or_test 'else' test] | lambdef
     _parseTestExpression(allowAssignmentExpression) {
-        if (this._peekKeywordType() === 24 /* Lambda */) {
+        if (this._peekKeywordType() === 24 /* KeywordType.Lambda */) {
             return this._parseLambdaExpression();
         }
         const ifExpr = this._parseAssignmentExpression(!allowAssignmentExpression);
-        if (ifExpr.nodeType === 0 /* Error */) {
+        if (ifExpr.nodeType === 0 /* ParseNodeType.Error */) {
             return ifExpr;
         }
-        if (!this._consumeTokenIfKeyword(20 /* If */)) {
+        if (!this._consumeTokenIfKeyword(20 /* KeywordType.If */)) {
             return ifExpr;
         }
         const testExpr = this._parseOrTest();
-        if (testExpr.nodeType === 0 /* Error */) {
+        if (testExpr.nodeType === 0 /* ParseNodeType.Error */) {
             return testExpr;
         }
-        if (!this._consumeTokenIfKeyword(13 /* Else */)) {
-            return parseNodes_1.TernaryNode.create(ifExpr, testExpr, this._handleExpressionParseError(1 /* MissingElse */, localize_1.Localizer.Diagnostic.expectedElse()));
+        if (!this._consumeTokenIfKeyword(13 /* KeywordType.Else */)) {
+            return parseNodes_1.TernaryNode.create(ifExpr, testExpr, this._handleExpressionParseError(1 /* ErrorExpressionCategory.MissingElse */, localize_1.Localizer.Diagnostic.expectedElse()));
         }
         const elseExpr = this._parseTestExpression(/* allowAssignmentExpression */ true);
         return parseNodes_1.TernaryNode.create(ifExpr, testExpr, elseExpr);
@@ -2465,14 +2469,14 @@ class Parser {
     // assign_expr: NAME := test
     _parseAssignmentExpression(disallowAssignmentExpression = false) {
         const leftExpr = this._parseOrTest();
-        if (leftExpr.nodeType === 0 /* Error */) {
+        if (leftExpr.nodeType === 0 /* ParseNodeType.Error */) {
             return leftExpr;
         }
-        if (leftExpr.nodeType !== 38 /* Name */) {
+        if (leftExpr.nodeType !== 38 /* ParseNodeType.Name */) {
             return leftExpr;
         }
         const walrusToken = this._peekToken();
-        if (!this._consumeTokenIfOperator(35 /* Walrus */)) {
+        if (!this._consumeTokenIfOperator(35 /* OperatorType.Walrus */)) {
             return leftExpr;
         }
         if (!this._assignmentExpressionsAllowed || this._isParsingTypeAnnotation || disallowAssignmentExpression) {
@@ -2487,41 +2491,41 @@ class Parser {
     // or_test: and_test ('or' and_test)*
     _parseOrTest() {
         let leftExpr = this._parseAndTest();
-        if (leftExpr.nodeType === 0 /* Error */) {
+        if (leftExpr.nodeType === 0 /* ParseNodeType.Error */) {
             return leftExpr;
         }
         while (true) {
             const peekToken = this._peekToken();
-            if (!this._consumeTokenIfKeyword(29 /* Or */)) {
+            if (!this._consumeTokenIfKeyword(29 /* KeywordType.Or */)) {
                 break;
             }
             const rightExpr = this._parseAndTest();
-            leftExpr = this._createBinaryOperationNode(leftExpr, rightExpr, peekToken, 37 /* Or */);
+            leftExpr = this._createBinaryOperationNode(leftExpr, rightExpr, peekToken, 37 /* OperatorType.Or */);
         }
         return leftExpr;
     }
     // and_test: not_test ('and' not_test)*
     _parseAndTest() {
         let leftExpr = this._parseNotTest();
-        if (leftExpr.nodeType === 0 /* Error */) {
+        if (leftExpr.nodeType === 0 /* ParseNodeType.Error */) {
             return leftExpr;
         }
         while (true) {
             const peekToken = this._peekToken();
-            if (!this._consumeTokenIfKeyword(0 /* And */)) {
+            if (!this._consumeTokenIfKeyword(0 /* KeywordType.And */)) {
                 break;
             }
             const rightExpr = this._parseNotTest();
-            leftExpr = this._createBinaryOperationNode(leftExpr, rightExpr, peekToken, 36 /* And */);
+            leftExpr = this._createBinaryOperationNode(leftExpr, rightExpr, peekToken, 36 /* OperatorType.And */);
         }
         return leftExpr;
     }
     // not_test: 'not' not_test | comparison
     _parseNotTest() {
         const notToken = this._peekToken();
-        if (this._consumeTokenIfKeyword(28 /* Not */)) {
+        if (this._consumeTokenIfKeyword(28 /* KeywordType.Not */)) {
             const notExpr = this._parseNotTest();
-            return this._createUnaryOperationNode(notToken, notExpr, 38 /* Not */);
+            return this._createUnaryOperationNode(notToken, notExpr, 38 /* OperatorType.Not */);
         }
         return this._parseComparison();
     }
@@ -2529,7 +2533,7 @@ class Parser {
     // comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'|'is' 'not'
     _parseComparison() {
         let leftExpr = this._parseBitwiseOrExpression();
-        if (leftExpr.nodeType === 0 /* Error */) {
+        if (leftExpr.nodeType === 0 /* ParseNodeType.Error */) {
             return leftExpr;
         }
         while (true) {
@@ -2537,30 +2541,30 @@ class Parser {
             const peekToken = this._peekToken();
             if (tokenizer_1.Tokenizer.isOperatorComparison(this._peekOperatorType())) {
                 comparisonOperator = this._peekOperatorType();
-                if (comparisonOperator === 19 /* LessOrGreaterThan */) {
+                if (comparisonOperator === 19 /* OperatorType.LessOrGreaterThan */) {
                     this._addError(localize_1.Localizer.Diagnostic.operatorLessOrGreaterDeprecated(), peekToken);
-                    comparisonOperator = 28 /* NotEquals */;
+                    comparisonOperator = 28 /* OperatorType.NotEquals */;
                 }
                 this._getNextToken();
             }
-            else if (this._consumeTokenIfKeyword(22 /* In */)) {
-                comparisonOperator = 41 /* In */;
+            else if (this._consumeTokenIfKeyword(22 /* KeywordType.In */)) {
+                comparisonOperator = 41 /* OperatorType.In */;
             }
-            else if (this._consumeTokenIfKeyword(23 /* Is */)) {
-                if (this._consumeTokenIfKeyword(28 /* Not */)) {
-                    comparisonOperator = 40 /* IsNot */;
+            else if (this._consumeTokenIfKeyword(23 /* KeywordType.Is */)) {
+                if (this._consumeTokenIfKeyword(28 /* KeywordType.Not */)) {
+                    comparisonOperator = 40 /* OperatorType.IsNot */;
                 }
                 else {
-                    comparisonOperator = 39 /* Is */;
+                    comparisonOperator = 39 /* OperatorType.Is */;
                 }
             }
-            else if (this._peekKeywordType() === 28 /* Not */) {
+            else if (this._peekKeywordType() === 28 /* KeywordType.Not */) {
                 const tokenAfterNot = this._peekToken(1);
-                if (tokenAfterNot.type === 8 /* Keyword */ &&
-                    tokenAfterNot.keywordType === 22 /* In */) {
+                if (tokenAfterNot.type === 8 /* TokenType.Keyword */ &&
+                    tokenAfterNot.keywordType === 22 /* KeywordType.In */) {
                     this._getNextToken();
                     this._getNextToken();
-                    comparisonOperator = 42 /* NotIn */;
+                    comparisonOperator = 42 /* OperatorType.NotIn */;
                 }
             }
             if (comparisonOperator === undefined) {
@@ -2574,60 +2578,60 @@ class Parser {
     // expr: xor_expr ('|' xor_expr)*
     _parseBitwiseOrExpression() {
         let leftExpr = this._parseBitwiseXorExpression();
-        if (leftExpr.nodeType === 0 /* Error */) {
+        if (leftExpr.nodeType === 0 /* ParseNodeType.Error */) {
             return leftExpr;
         }
         while (true) {
             const peekToken = this._peekToken();
-            if (!this._consumeTokenIfOperator(6 /* BitwiseOr */)) {
+            if (!this._consumeTokenIfOperator(6 /* OperatorType.BitwiseOr */)) {
                 break;
             }
             const rightExpr = this._parseBitwiseXorExpression();
-            leftExpr = this._createBinaryOperationNode(leftExpr, rightExpr, peekToken, 6 /* BitwiseOr */);
+            leftExpr = this._createBinaryOperationNode(leftExpr, rightExpr, peekToken, 6 /* OperatorType.BitwiseOr */);
         }
         return leftExpr;
     }
     // xor_expr: and_expr ('^' and_expr)*
     _parseBitwiseXorExpression() {
         let leftExpr = this._parseBitwiseAndExpression();
-        if (leftExpr.nodeType === 0 /* Error */) {
+        if (leftExpr.nodeType === 0 /* ParseNodeType.Error */) {
             return leftExpr;
         }
         while (true) {
             const peekToken = this._peekToken();
-            if (!this._consumeTokenIfOperator(8 /* BitwiseXor */)) {
+            if (!this._consumeTokenIfOperator(8 /* OperatorType.BitwiseXor */)) {
                 break;
             }
             const rightExpr = this._parseBitwiseAndExpression();
-            leftExpr = this._createBinaryOperationNode(leftExpr, rightExpr, peekToken, 8 /* BitwiseXor */);
+            leftExpr = this._createBinaryOperationNode(leftExpr, rightExpr, peekToken, 8 /* OperatorType.BitwiseXor */);
         }
         return leftExpr;
     }
     // and_expr: shift_expr ('&' shift_expr)*
     _parseBitwiseAndExpression() {
         let leftExpr = this._parseShiftExpression();
-        if (leftExpr.nodeType === 0 /* Error */) {
+        if (leftExpr.nodeType === 0 /* ParseNodeType.Error */) {
             return leftExpr;
         }
         while (true) {
             const peekToken = this._peekToken();
-            if (!this._consumeTokenIfOperator(3 /* BitwiseAnd */)) {
+            if (!this._consumeTokenIfOperator(3 /* OperatorType.BitwiseAnd */)) {
                 break;
             }
             const rightExpr = this._parseShiftExpression();
-            leftExpr = this._createBinaryOperationNode(leftExpr, rightExpr, peekToken, 3 /* BitwiseAnd */);
+            leftExpr = this._createBinaryOperationNode(leftExpr, rightExpr, peekToken, 3 /* OperatorType.BitwiseAnd */);
         }
         return leftExpr;
     }
     // shift_expr: arith_expr (('<<'|'>>') arith_expr)*
     _parseShiftExpression() {
         let leftExpr = this._parseArithmeticExpression();
-        if (leftExpr.nodeType === 0 /* Error */) {
+        if (leftExpr.nodeType === 0 /* ParseNodeType.Error */) {
             return leftExpr;
         }
         let peekToken = this._peekToken();
         let nextOperator = this._peekOperatorType();
-        while (nextOperator === 17 /* LeftShift */ || nextOperator === 31 /* RightShift */) {
+        while (nextOperator === 17 /* OperatorType.LeftShift */ || nextOperator === 31 /* OperatorType.RightShift */) {
             this._getNextToken();
             const rightExpr = this._parseArithmeticExpression();
             leftExpr = this._createBinaryOperationNode(leftExpr, rightExpr, peekToken, nextOperator);
@@ -2639,15 +2643,15 @@ class Parser {
     // arith_expr: term (('+'|'-') term)*
     _parseArithmeticExpression() {
         let leftExpr = this._parseArithmeticTerm();
-        if (leftExpr.nodeType === 0 /* Error */) {
+        if (leftExpr.nodeType === 0 /* ParseNodeType.Error */) {
             return leftExpr;
         }
         let peekToken = this._peekToken();
         let nextOperator = this._peekOperatorType();
-        while (nextOperator === 0 /* Add */ || nextOperator === 33 /* Subtract */) {
+        while (nextOperator === 0 /* OperatorType.Add */ || nextOperator === 33 /* OperatorType.Subtract */) {
             this._getNextToken();
             const rightExpr = this._parseArithmeticTerm();
-            if (rightExpr.nodeType === 0 /* Error */) {
+            if (rightExpr.nodeType === 0 /* ParseNodeType.Error */) {
                 return rightExpr;
             }
             leftExpr = this._createBinaryOperationNode(leftExpr, rightExpr, peekToken, nextOperator);
@@ -2659,16 +2663,16 @@ class Parser {
     // term: factor (('*'|'@'|'/'|'%'|'//') factor)*
     _parseArithmeticTerm() {
         let leftExpr = this._parseArithmeticFactor();
-        if (leftExpr.nodeType === 0 /* Error */) {
+        if (leftExpr.nodeType === 0 /* ParseNodeType.Error */) {
             return leftExpr;
         }
         let peekToken = this._peekToken();
         let nextOperator = this._peekOperatorType();
-        while (nextOperator === 26 /* Multiply */ ||
-            nextOperator === 22 /* MatrixMultiply */ ||
-            nextOperator === 10 /* Divide */ ||
-            nextOperator === 24 /* Mod */ ||
-            nextOperator === 13 /* FloorDivide */) {
+        while (nextOperator === 26 /* OperatorType.Multiply */ ||
+            nextOperator === 22 /* OperatorType.MatrixMultiply */ ||
+            nextOperator === 10 /* OperatorType.Divide */ ||
+            nextOperator === 24 /* OperatorType.Mod */ ||
+            nextOperator === 13 /* OperatorType.FloorDivide */) {
             this._getNextToken();
             const rightExpr = this._parseArithmeticFactor();
             leftExpr = this._createBinaryOperationNode(leftExpr, rightExpr, peekToken, nextOperator);
@@ -2682,21 +2686,21 @@ class Parser {
     _parseArithmeticFactor() {
         const nextToken = this._peekToken();
         const nextOperator = this._peekOperatorType();
-        if (nextOperator === 0 /* Add */ ||
-            nextOperator === 33 /* Subtract */ ||
-            nextOperator === 5 /* BitwiseInvert */) {
+        if (nextOperator === 0 /* OperatorType.Add */ ||
+            nextOperator === 33 /* OperatorType.Subtract */ ||
+            nextOperator === 5 /* OperatorType.BitwiseInvert */) {
             this._getNextToken();
             const expression = this._parseArithmeticFactor();
             return this._createUnaryOperationNode(nextToken, expression, nextOperator);
         }
         const leftExpr = this._parseAtomExpression();
-        if (leftExpr.nodeType === 0 /* Error */) {
+        if (leftExpr.nodeType === 0 /* ParseNodeType.Error */) {
             return leftExpr;
         }
         const peekToken = this._peekToken();
-        if (this._consumeTokenIfOperator(29 /* Power */)) {
+        if (this._consumeTokenIfOperator(29 /* OperatorType.Power */)) {
             const rightExpr = this._parseArithmeticFactor();
-            return this._createBinaryOperationNode(leftExpr, rightExpr, peekToken, 29 /* Power */);
+            return this._createBinaryOperationNode(leftExpr, rightExpr, peekToken, 29 /* OperatorType.Power */);
         }
         return leftExpr;
     }
@@ -2705,14 +2709,14 @@ class Parser {
     // time. We assume here that the code isn't making use of some custom type alias
     // to refer to the typing types.
     _isTypingAnnotation(typeAnnotation, name) {
-        if (typeAnnotation.nodeType === 38 /* Name */) {
+        if (typeAnnotation.nodeType === 38 /* ParseNodeType.Name */) {
             const alias = this._typingSymbolAliases.get(typeAnnotation.value);
             if (alias === name) {
                 return true;
             }
         }
-        else if (typeAnnotation.nodeType === 35 /* MemberAccess */) {
-            if (typeAnnotation.leftExpression.nodeType === 38 /* Name */ &&
+        else if (typeAnnotation.nodeType === 35 /* ParseNodeType.MemberAccess */) {
+            if (typeAnnotation.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
                 typeAnnotation.memberName.value === name) {
                 const baseName = typeAnnotation.leftExpression.value;
                 return this._typingImportAliases.some((alias) => alias === baseName);
@@ -2724,21 +2728,21 @@ class Parser {
     // trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME
     _parseAtomExpression() {
         let awaitToken;
-        if (this._peekKeywordType() === 4 /* Await */ && !this._isParsingTypeAnnotation) {
-            awaitToken = this._getKeywordToken(4 /* Await */);
+        if (this._peekKeywordType() === 4 /* KeywordType.Await */ && !this._isParsingTypeAnnotation) {
+            awaitToken = this._getKeywordToken(4 /* KeywordType.Await */);
             if (this._getLanguageVersion() < pythonVersion_1.PythonVersion.V3_5) {
                 this._addError(localize_1.Localizer.Diagnostic.awaitIllegal(), awaitToken);
             }
         }
         let atomExpression = this._parseAtom();
-        if (atomExpression.nodeType === 0 /* Error */) {
+        if (atomExpression.nodeType === 0 /* ParseNodeType.Error */) {
             return atomExpression;
         }
         // Consume trailers.
         while (true) {
             // Is it a function call?
             const startOfTrailerToken = this._peekToken();
-            if (this._consumeTokenIfType(13 /* OpenParenthesis */)) {
+            if (this._consumeTokenIfType(13 /* TokenType.OpenParenthesis */)) {
                 // Generally, function calls are not allowed within type annotations,
                 // but they are permitted in "Annotated" annotations.
                 const wasParsingTypeAnnotation = this._isParsingTypeAnnotation;
@@ -2747,7 +2751,7 @@ class Parser {
                 const callNode = parseNodes_1.CallNode.create(atomExpression, argListResult.args, argListResult.trailingComma);
                 if (argListResult.args.length > 1 || argListResult.trailingComma) {
                     argListResult.args.forEach((arg) => {
-                        if (arg.valueExpression.nodeType === 32 /* ListComprehension */) {
+                        if (arg.valueExpression.nodeType === 32 /* ParseNodeType.ListComprehension */) {
                             if (!arg.valueExpression.isParenthesized) {
                                 this._addError(localize_1.Localizer.Diagnostic.generatorNotParenthesized(), arg.valueExpression);
                             }
@@ -2756,11 +2760,11 @@ class Parser {
                 }
                 const nextToken = this._peekToken();
                 let isArgListTerminated = false;
-                if (!this._consumeTokenIfType(14 /* CloseParenthesis */)) {
+                if (!this._consumeTokenIfType(14 /* TokenType.CloseParenthesis */)) {
                     this._addError(localize_1.Localizer.Diagnostic.expectedCloseParen(), startOfTrailerToken);
                     // Consume the remainder of tokens on the line for error
                     // recovery.
-                    this._consumeTokensUntilType([2 /* NewLine */]);
+                    this._consumeTokensUntilType([2 /* TokenType.NewLine */]);
                     // Extend the node's range to include the rest of the line.
                     // This helps the signatureHelpProvider.
                     (0, parseNodes_1.extendRange)(callNode, this._peekToken());
@@ -2772,7 +2776,7 @@ class Parser {
                 this._isParsingTypeAnnotation = wasParsingTypeAnnotation;
                 atomExpression = callNode;
                 if (atomExpression.maxChildDepth !== undefined && atomExpression.maxChildDepth >= maxChildNodeDepth) {
-                    atomExpression = parseNodes_1.ErrorNode.create(atomExpression, 14 /* MaxDepthExceeded */);
+                    atomExpression = parseNodes_1.ErrorNode.create(atomExpression, 14 /* ErrorExpressionCategory.MaxDepthExceeded */);
                     this._addError(localize_1.Localizer.Diagnostic.maxParseDepthExceeded(), atomExpression);
                 }
                 // If the argument list wasn't terminated, break out of the loop
@@ -2780,7 +2784,7 @@ class Parser {
                     break;
                 }
             }
-            else if (this._consumeTokenIfType(15 /* OpenBracket */)) {
+            else if (this._consumeTokenIfType(15 /* TokenType.OpenBracket */)) {
                 // Is it an index operator?
                 // This is an unfortunate hack that's necessary to accommodate 'Literal'
                 // and 'Annotated' type annotations properly. We need to suspend treating
@@ -2798,26 +2802,26 @@ class Parser {
                 const closingToken = this._peekToken();
                 const indexNode = parseNodes_1.IndexNode.create(atomExpression, subscriptList.list, subscriptList.trailingComma, closingToken);
                 (0, parseNodes_1.extendRange)(indexNode, indexNode);
-                if (!this._consumeTokenIfType(16 /* CloseBracket */)) {
+                if (!this._consumeTokenIfType(16 /* TokenType.CloseBracket */)) {
                     // Handle the error case, but don't use the error node in this
                     // case because it creates problems for the completion provider.
-                    this._handleExpressionParseError(6 /* MissingIndexCloseBracket */, localize_1.Localizer.Diagnostic.expectedCloseBracket(), startOfTrailerToken, indexNode);
+                    this._handleExpressionParseError(6 /* ErrorExpressionCategory.MissingIndexCloseBracket */, localize_1.Localizer.Diagnostic.expectedCloseBracket(), startOfTrailerToken, indexNode);
                 }
                 atomExpression = indexNode;
                 if (atomExpression.maxChildDepth !== undefined && atomExpression.maxChildDepth >= maxChildNodeDepth) {
-                    atomExpression = parseNodes_1.ErrorNode.create(atomExpression, 14 /* MaxDepthExceeded */);
+                    atomExpression = parseNodes_1.ErrorNode.create(atomExpression, 14 /* ErrorExpressionCategory.MaxDepthExceeded */);
                     this._addError(localize_1.Localizer.Diagnostic.maxParseDepthExceeded(), atomExpression);
                 }
             }
-            else if (this._consumeTokenIfType(20 /* Dot */)) {
+            else if (this._consumeTokenIfType(20 /* TokenType.Dot */)) {
                 // Is it a member access?
                 const memberName = this._getTokenIfIdentifier();
                 if (!memberName) {
-                    return this._handleExpressionParseError(7 /* MissingMemberAccessName */, localize_1.Localizer.Diagnostic.expectedMemberName(), startOfTrailerToken, atomExpression, [8 /* Keyword */]);
+                    return this._handleExpressionParseError(7 /* ErrorExpressionCategory.MissingMemberAccessName */, localize_1.Localizer.Diagnostic.expectedMemberName(), startOfTrailerToken, atomExpression, [8 /* TokenType.Keyword */]);
                 }
                 atomExpression = parseNodes_1.MemberAccessNode.create(atomExpression, parseNodes_1.NameNode.create(memberName));
                 if (atomExpression.maxChildDepth !== undefined && atomExpression.maxChildDepth >= maxChildNodeDepth) {
-                    atomExpression = parseNodes_1.ErrorNode.create(atomExpression, 14 /* MaxDepthExceeded */);
+                    atomExpression = parseNodes_1.ErrorNode.create(atomExpression, 14 /* ErrorExpressionCategory.MaxDepthExceeded */);
                     this._addError(localize_1.Localizer.Diagnostic.maxParseDepthExceeded(), atomExpression);
                 }
             }
@@ -2837,33 +2841,33 @@ class Parser {
         let trailingComma = false;
         while (true) {
             const firstToken = this._peekToken();
-            if (firstToken.type !== 10 /* Colon */ && this._isNextTokenNeverExpression()) {
+            if (firstToken.type !== 10 /* TokenType.Colon */ && this._isNextTokenNeverExpression()) {
                 break;
             }
-            let argType = 0 /* Simple */;
-            if (this._consumeTokenIfOperator(26 /* Multiply */)) {
-                argType = 1 /* UnpackedList */;
+            let argType = 0 /* ArgumentCategory.Simple */;
+            if (this._consumeTokenIfOperator(26 /* OperatorType.Multiply */)) {
+                argType = 1 /* ArgumentCategory.UnpackedList */;
             }
-            else if (this._consumeTokenIfOperator(29 /* Power */)) {
-                argType = 2 /* UnpackedDictionary */;
+            else if (this._consumeTokenIfOperator(29 /* OperatorType.Power */)) {
+                argType = 2 /* ArgumentCategory.UnpackedDictionary */;
             }
             const startOfSubscriptIndex = this._tokenIndex;
             let valueExpr = this._parsePossibleSlice();
             let nameIdentifier;
             // Is this a keyword argument?
-            if (argType === 0 /* Simple */) {
-                if (this._consumeTokenIfOperator(2 /* Assign */)) {
+            if (argType === 0 /* ArgumentCategory.Simple */) {
+                if (this._consumeTokenIfOperator(2 /* OperatorType.Assign */)) {
                     const nameExpr = valueExpr;
                     valueExpr = this._parsePossibleSlice();
-                    if (nameExpr.nodeType === 38 /* Name */) {
+                    if (nameExpr.nodeType === 38 /* ParseNodeType.Name */) {
                         nameIdentifier = nameExpr.token;
                     }
                     else {
                         this._addError(localize_1.Localizer.Diagnostic.expectedParamName(), nameExpr);
                     }
                 }
-                else if (valueExpr.nodeType === 38 /* Name */ &&
-                    this._peekOperatorType() === 35 /* Walrus */) {
+                else if (valueExpr.nodeType === 38 /* ParseNodeType.Name */ &&
+                    this._peekOperatorType() === 35 /* OperatorType.Walrus */) {
                     this._tokenIndex = startOfSubscriptIndex;
                     valueExpr = this._parseTestExpression(/* allowAssignmentExpression */ true);
                     // Python 3.10 and newer allow assignment expressions to be used inside of a subscript.
@@ -2880,25 +2884,25 @@ class Parser {
             if (argNode.name) {
                 sawKeywordArg = true;
             }
-            else if (sawKeywordArg && argNode.argumentCategory === 0 /* Simple */) {
+            else if (sawKeywordArg && argNode.argumentCategory === 0 /* ArgumentCategory.Simple */) {
                 this._addError(localize_1.Localizer.Diagnostic.positionArgAfterNamedArg(), argNode);
             }
             argList.push(argNode);
             if (argNode.name) {
                 this._addError(localize_1.Localizer.Diagnostic.keywordSubscriptIllegal(), argNode.name);
             }
-            if (argType !== 0 /* Simple */) {
+            if (argType !== 0 /* ArgumentCategory.Simple */) {
                 const unpackListAllowed = this._parseOptions.isStubFile ||
                     this._isParsingQuotedText ||
                     this._getLanguageVersion() >= pythonVersion_1.PythonVersion.V3_11;
-                if (argType === 1 /* UnpackedList */ && !unpackListAllowed) {
+                if (argType === 1 /* ArgumentCategory.UnpackedList */ && !unpackListAllowed) {
                     this._addError(localize_1.Localizer.Diagnostic.unpackedSubscriptIllegal(), argNode);
                 }
-                if (argType === 2 /* UnpackedDictionary */) {
+                if (argType === 2 /* ArgumentCategory.UnpackedDictionary */) {
                     this._addError(localize_1.Localizer.Diagnostic.unpackedDictSubscriptIllegal(), argNode);
                 }
             }
-            if (!this._consumeTokenIfType(12 /* Comma */)) {
+            if (!this._consumeTokenIfType(12 /* TokenType.Comma */)) {
                 trailingComma = false;
                 break;
             }
@@ -2906,10 +2910,10 @@ class Parser {
         }
         // An empty subscript list is illegal.
         if (argList.length === 0) {
-            const errorNode = this._handleExpressionParseError(3 /* MissingIndexOrSlice */, localize_1.Localizer.Diagnostic.expectedSliceIndex(), 
+            const errorNode = this._handleExpressionParseError(3 /* ErrorExpressionCategory.MissingIndexOrSlice */, localize_1.Localizer.Diagnostic.expectedSliceIndex(), 
             /* targetToken */ undefined, 
-            /* childNode */ undefined, [16 /* CloseBracket */]);
-            argList.push(parseNodes_1.ArgumentNode.create(this._peekToken(), errorNode, 0 /* Simple */));
+            /* childNode */ undefined, [16 /* TokenType.CloseBracket */]);
+            argList.push(parseNodes_1.ArgumentNode.create(this._peekToken(), errorNode, 0 /* ArgumentCategory.Simple */));
         }
         return {
             list: argList,
@@ -2925,16 +2929,16 @@ class Parser {
         let sawColon = false;
         while (true) {
             const nextTokenType = this._peekTokenType();
-            if (nextTokenType === 16 /* CloseBracket */ || nextTokenType === 12 /* Comma */) {
+            if (nextTokenType === 16 /* TokenType.CloseBracket */ || nextTokenType === 12 /* TokenType.Comma */) {
                 break;
             }
-            if (nextTokenType !== 10 /* Colon */) {
+            if (nextTokenType !== 10 /* TokenType.Colon */) {
                 // Python 3.10 and newer allow assignment expressions to be used inside of a subscript.
                 const allowAssignmentExpression = this._parseOptions.isStubFile || this._getLanguageVersion() >= pythonVersion_1.PythonVersion.V3_10;
                 sliceExpressions[sliceIndex] = this._parseTestExpression(allowAssignmentExpression);
             }
             sliceIndex++;
-            if (sliceIndex >= 3 || !this._consumeTokenIfType(10 /* Colon */)) {
+            if (sliceIndex >= 3 || !this._consumeTokenIfType(10 /* TokenType.Colon */)) {
                 break;
             }
             sawColon = true;
@@ -2944,7 +2948,7 @@ class Parser {
             if (sliceExpressions[0]) {
                 return sliceExpressions[0];
             }
-            return parseNodes_1.ErrorNode.create(this._peekToken(), 3 /* MissingIndexOrSlice */);
+            return parseNodes_1.ErrorNode.create(this._peekToken(), 3 /* ErrorExpressionCategory.MissingIndexOrSlice */);
         }
         const sliceNode = parseNodes_1.SliceNode.create(firstToken);
         sliceNode.startValue = sliceExpressions[0];
@@ -2972,9 +2976,9 @@ class Parser {
         let trailingComma = false;
         while (true) {
             const nextTokenType = this._peekTokenType();
-            if (nextTokenType === 14 /* CloseParenthesis */ ||
-                nextTokenType === 2 /* NewLine */ ||
-                nextTokenType === 1 /* EndOfStream */) {
+            if (nextTokenType === 14 /* TokenType.CloseParenthesis */ ||
+                nextTokenType === 2 /* TokenType.NewLine */ ||
+                nextTokenType === 1 /* TokenType.EndOfStream */) {
                 break;
             }
             trailingComma = false;
@@ -2982,11 +2986,11 @@ class Parser {
             if (arg.name) {
                 sawKeywordArg = true;
             }
-            else if (sawKeywordArg && arg.argumentCategory === 0 /* Simple */) {
+            else if (sawKeywordArg && arg.argumentCategory === 0 /* ArgumentCategory.Simple */) {
                 this._addError(localize_1.Localizer.Diagnostic.positionArgAfterNamedArg(), arg);
             }
             argList.push(arg);
-            if (!this._consumeTokenIfType(12 /* Comma */)) {
+            if (!this._consumeTokenIfType(12 /* TokenType.Comma */)) {
                 break;
             }
             trailingComma = true;
@@ -2999,20 +3003,20 @@ class Parser {
     //             '*' test )
     _parseArgument() {
         const firstToken = this._peekToken();
-        let argType = 0 /* Simple */;
-        if (this._consumeTokenIfOperator(26 /* Multiply */)) {
-            argType = 1 /* UnpackedList */;
+        let argType = 0 /* ArgumentCategory.Simple */;
+        if (this._consumeTokenIfOperator(26 /* OperatorType.Multiply */)) {
+            argType = 1 /* ArgumentCategory.UnpackedList */;
         }
-        else if (this._consumeTokenIfOperator(29 /* Power */)) {
-            argType = 2 /* UnpackedDictionary */;
+        else if (this._consumeTokenIfOperator(29 /* OperatorType.Power */)) {
+            argType = 2 /* ArgumentCategory.UnpackedDictionary */;
         }
         let valueExpr = this._parseTestExpression(/* allowAssignmentExpression */ true);
         let nameIdentifier;
-        if (argType === 0 /* Simple */) {
-            if (this._consumeTokenIfOperator(2 /* Assign */)) {
+        if (argType === 0 /* ArgumentCategory.Simple */) {
+            if (this._consumeTokenIfOperator(2 /* OperatorType.Assign */)) {
                 const nameExpr = valueExpr;
                 valueExpr = this._parseTestExpression(/* allowAssignmentExpression */ false);
-                if (nameExpr.nodeType === 38 /* Name */) {
+                if (nameExpr.nodeType === 38 /* ParseNodeType.Name */) {
                     nameIdentifier = nameExpr.token;
                 }
                 else {
@@ -3039,59 +3043,59 @@ class Parser {
     //     NAME | NUMBER | STRING+ | '...' | 'None' | 'True' | 'False' | '__debug__')
     _parseAtom() {
         const nextToken = this._peekToken();
-        if (nextToken.type === 19 /* Ellipsis */) {
+        if (nextToken.type === 19 /* TokenType.Ellipsis */) {
             return parseNodes_1.EllipsisNode.create(this._getNextToken());
         }
-        if (nextToken.type === 6 /* Number */) {
+        if (nextToken.type === 6 /* TokenType.Number */) {
             return parseNodes_1.NumberNode.create(this._getNextToken());
         }
-        if (nextToken.type === 7 /* Identifier */) {
+        if (nextToken.type === 7 /* TokenType.Identifier */) {
             return parseNodes_1.NameNode.create(this._getNextToken());
         }
-        if (nextToken.type === 5 /* String */ || nextToken.type === 24 /* FStringStart */) {
+        if (nextToken.type === 5 /* TokenType.String */ || nextToken.type === 24 /* TokenType.FStringStart */) {
             return this._parseStringList();
         }
-        if (nextToken.type === 22 /* Backtick */) {
+        if (nextToken.type === 22 /* TokenType.Backtick */) {
             this._getNextToken();
             // Atoms with backticks are no longer allowed in Python 3.x, but they
             // were a thing in Python 2.x. We'll parse them to improve parse recovery
             // and emit an error.
             this._addError(localize_1.Localizer.Diagnostic.backticksIllegal(), nextToken);
-            const expressionNode = this._parseTestListAsExpression(2 /* MissingExpression */, () => localize_1.Localizer.Diagnostic.expectedExpr());
-            this._consumeTokenIfType(22 /* Backtick */);
+            const expressionNode = this._parseTestListAsExpression(2 /* ErrorExpressionCategory.MissingExpression */, () => localize_1.Localizer.Diagnostic.expectedExpr());
+            this._consumeTokenIfType(22 /* TokenType.Backtick */);
             return expressionNode;
         }
-        if (nextToken.type === 13 /* OpenParenthesis */) {
+        if (nextToken.type === 13 /* TokenType.OpenParenthesis */) {
             const possibleTupleNode = this._parseTupleAtom();
-            if (possibleTupleNode.nodeType === 55 /* UnaryOperation */ ||
-                possibleTupleNode.nodeType === 6 /* Await */ ||
-                possibleTupleNode.nodeType === 7 /* BinaryOperation */) {
+            if (possibleTupleNode.nodeType === 55 /* ParseNodeType.UnaryOperation */ ||
+                possibleTupleNode.nodeType === 6 /* ParseNodeType.Await */ ||
+                possibleTupleNode.nodeType === 7 /* ParseNodeType.BinaryOperation */) {
                 // Mark binary expressions as parenthesized so we don't attempt
                 // to use comparison chaining, which isn't appropriate when the
                 // expression is parenthesized. Unary and await expressions
                 // are also marked to be able to display them unambiguously.
                 possibleTupleNode.parenthesized = true;
             }
-            if (possibleTupleNode.nodeType === 48 /* StringList */) {
+            if (possibleTupleNode.nodeType === 48 /* ParseNodeType.StringList */) {
                 possibleTupleNode.isParenthesized = true;
             }
-            if (possibleTupleNode.nodeType === 32 /* ListComprehension */) {
+            if (possibleTupleNode.nodeType === 32 /* ParseNodeType.ListComprehension */) {
                 possibleTupleNode.isParenthesized = true;
             }
             return possibleTupleNode;
         }
-        else if (nextToken.type === 15 /* OpenBracket */) {
+        else if (nextToken.type === 15 /* TokenType.OpenBracket */) {
             return this._parseListAtom();
         }
-        else if (nextToken.type === 17 /* OpenCurlyBrace */) {
+        else if (nextToken.type === 17 /* TokenType.OpenCurlyBrace */) {
             return this._parseDictionaryOrSetAtom();
         }
-        if (nextToken.type === 8 /* Keyword */) {
+        if (nextToken.type === 8 /* TokenType.Keyword */) {
             const keywordToken = nextToken;
-            if (keywordToken.keywordType === 15 /* False */ ||
-                keywordToken.keywordType === 33 /* True */ ||
-                keywordToken.keywordType === 9 /* Debug */ ||
-                keywordToken.keywordType === 26 /* None */) {
+            if (keywordToken.keywordType === 15 /* KeywordType.False */ ||
+                keywordToken.keywordType === 33 /* KeywordType.True */ ||
+                keywordToken.keywordType === 9 /* KeywordType.Debug */ ||
+                keywordToken.keywordType === 26 /* KeywordType.None */) {
                 return parseNodes_1.ConstantNode.create(this._getNextToken());
             }
             // Make an identifier out of the keyword.
@@ -3100,7 +3104,7 @@ class Parser {
                 return parseNodes_1.NameNode.create(keywordAsIdentifier);
             }
         }
-        return this._handleExpressionParseError(2 /* MissingExpression */, localize_1.Localizer.Diagnostic.expectedExpr());
+        return this._handleExpressionParseError(2 /* ErrorExpressionCategory.MissingExpression */, localize_1.Localizer.Diagnostic.expectedExpr());
     }
     // Allocates a dummy "error expression" and consumes the remainder
     // of the tokens on the line for error recovery. A partially-completed
@@ -3109,7 +3113,7 @@ class Parser {
     _handleExpressionParseError(category, errorMsg, targetToken, childNode, additionalStopTokens) {
         var _a;
         this._addError(errorMsg, targetToken !== null && targetToken !== void 0 ? targetToken : this._peekToken());
-        const stopTokens = [2 /* NewLine */];
+        const stopTokens = [2 /* TokenType.NewLine */];
         if (additionalStopTokens) {
             (0, collectionUtils_1.appendArray)(stopTokens, additionalStopTokens);
         }
@@ -3125,9 +3129,9 @@ class Parser {
     }
     // lambdef: 'lambda' [varargslist] ':' test
     _parseLambdaExpression(allowConditional = true) {
-        const lambdaToken = this._getKeywordToken(24 /* Lambda */);
-        const argList = this._parseVarArgsList(10 /* Colon */, /* allowAnnotations */ false);
-        if (!this._consumeTokenIfType(10 /* Colon */)) {
+        const lambdaToken = this._getKeywordToken(24 /* KeywordType.Lambda */);
+        const argList = this._parseVarArgsList(10 /* TokenType.Colon */, /* allowAnnotations */ false);
+        if (!this._consumeTokenIfType(10 /* TokenType.Colon */)) {
             this._addError(localize_1.Localizer.Diagnostic.expectedColon(), this._peekToken());
         }
         let testExpr;
@@ -3145,7 +3149,7 @@ class Parser {
         return lambdaNode;
     }
     _tryParseLambdaExpression(allowConditional = true) {
-        if (this._peekKeywordType() !== 24 /* Lambda */) {
+        if (this._peekKeywordType() !== 24 /* KeywordType.Lambda */) {
             return undefined;
         }
         return this._parseLambdaExpression(allowConditional);
@@ -3155,11 +3159,11 @@ class Parser {
     _parseTupleAtom() {
         var _a;
         const startParen = this._getNextToken();
-        (0, debug_1.assert)(startParen.type === 13 /* OpenParenthesis */);
+        (0, debug_1.assert)(startParen.type === 13 /* TokenType.OpenParenthesis */);
         const yieldExpr = this._tryParseYieldExpression();
         if (yieldExpr) {
-            if (this._peekTokenType() !== 14 /* CloseParenthesis */) {
-                return this._handleExpressionParseError(8 /* MissingTupleCloseParen */, localize_1.Localizer.Diagnostic.expectedCloseParen(), startParen, yieldExpr);
+            if (this._peekTokenType() !== 14 /* TokenType.CloseParenthesis */) {
+                return this._handleExpressionParseError(8 /* ErrorExpressionCategory.MissingTupleCloseParen */, localize_1.Localizer.Diagnostic.expectedCloseParen(), startParen, yieldExpr);
             }
             else {
                 (0, parseNodes_1.extendRange)(yieldExpr, this._getNextToken());
@@ -3169,8 +3173,8 @@ class Parser {
         const exprListResult = this._parseTestListWithComprehension(/* isGenerator */ true);
         const tupleOrExpression = this._makeExpressionOrTuple(exprListResult, /* enclosedInParens */ true);
         (0, parseNodes_1.extendRange)(tupleOrExpression, startParen);
-        if (this._peekTokenType() !== 14 /* CloseParenthesis */) {
-            return this._handleExpressionParseError(8 /* MissingTupleCloseParen */, localize_1.Localizer.Diagnostic.expectedCloseParen(), startParen, (_a = exprListResult.parseError) !== null && _a !== void 0 ? _a : tupleOrExpression);
+        if (this._peekTokenType() !== 14 /* TokenType.CloseParenthesis */) {
+            return this._handleExpressionParseError(8 /* ErrorExpressionCategory.MissingTupleCloseParen */, localize_1.Localizer.Diagnostic.expectedCloseParen(), startParen, (_a = exprListResult.parseError) !== null && _a !== void 0 ? _a : tupleOrExpression);
         }
         else {
             (0, parseNodes_1.extendRange)(tupleOrExpression, this._getNextToken());
@@ -3182,11 +3186,11 @@ class Parser {
     _parseListAtom() {
         var _a;
         const startBracket = this._getNextToken();
-        (0, debug_1.assert)(startBracket.type === 15 /* OpenBracket */);
+        (0, debug_1.assert)(startBracket.type === 15 /* TokenType.OpenBracket */);
         const exprListResult = this._parseTestListWithComprehension(/* isGenerator */ false);
         const closeBracket = this._peekToken();
-        if (!this._consumeTokenIfType(16 /* CloseBracket */)) {
-            return this._handleExpressionParseError(9 /* MissingListCloseBracket */, localize_1.Localizer.Diagnostic.expectedCloseBracket(), startBracket, (_a = exprListResult.parseError) !== null && _a !== void 0 ? _a : _createList());
+        if (!this._consumeTokenIfType(16 /* TokenType.CloseBracket */)) {
+            return this._handleExpressionParseError(9 /* ErrorExpressionCategory.MissingListCloseBracket */, localize_1.Localizer.Diagnostic.expectedCloseBracket(), startBracket, (_a = exprListResult.parseError) !== null && _a !== void 0 ? _a : _createList());
         }
         return _createList();
         function _createList() {
@@ -3225,7 +3229,7 @@ class Parser {
     // setentry: test | star_expr
     _parseDictionaryOrSetAtom() {
         const startBrace = this._getNextToken();
-        (0, debug_1.assert)(startBrace.type === 17 /* OpenCurlyBrace */);
+        (0, debug_1.assert)(startBrace.type === 17 /* TokenType.OpenCurlyBrace */);
         const dictionaryEntries = [];
         const setEntries = [];
         let isDictionary = false;
@@ -3234,7 +3238,7 @@ class Parser {
         let isFirstEntry = true;
         let trailingCommaToken;
         while (true) {
-            if (this._peekTokenType() === 18 /* CloseCurlyBrace */) {
+            if (this._peekTokenType() === 18 /* TokenType.CloseCurlyBrace */) {
                 break;
             }
             trailingCommaToken = undefined;
@@ -3242,17 +3246,17 @@ class Parser {
             let keyExpression;
             let valueExpression;
             const doubleStar = this._peekToken();
-            if (this._consumeTokenIfOperator(29 /* Power */)) {
+            if (this._consumeTokenIfOperator(29 /* OperatorType.Power */)) {
                 doubleStarExpression = this._parseExpression(/* allowUnpack */ false);
             }
             else {
                 keyExpression = this._parseTestOrStarExpression(/* allowAssignmentExpression */ true);
-                if (this._consumeTokenIfType(10 /* Colon */)) {
+                if (this._consumeTokenIfType(10 /* TokenType.Colon */)) {
                     valueExpression = this._parseTestExpression(/* allowAssignmentExpression */ false);
                 }
             }
             if (keyExpression && valueExpression) {
-                if (keyExpression.nodeType === 56 /* Unpack */) {
+                if (keyExpression.nodeType === 56 /* ParseNodeType.Unpack */) {
                     this._addError(localize_1.Localizer.Diagnostic.unpackInDict(), keyExpression);
                 }
                 if (isSet) {
@@ -3297,7 +3301,7 @@ class Parser {
                 (0, debug_1.assert)(keyExpression !== undefined);
                 if (keyExpression) {
                     if (isDictionary) {
-                        const missingValueErrorNode = parseNodes_1.ErrorNode.create(this._peekToken(), 13 /* MissingDictValue */);
+                        const missingValueErrorNode = parseNodes_1.ErrorNode.create(this._peekToken(), 13 /* ErrorExpressionCategory.MissingDictValue */);
                         const keyEntryNode = parseNodes_1.DictionaryKeyEntryNode.create(keyExpression, missingValueErrorNode);
                         dictionaryEntries.push(keyEntryNode);
                         this._addError(localize_1.Localizer.Diagnostic.dictKeyValuePairs(), keyExpression);
@@ -3320,14 +3324,14 @@ class Parser {
             if (sawListComprehension) {
                 break;
             }
-            if (this._peekTokenType() !== 12 /* Comma */) {
+            if (this._peekTokenType() !== 12 /* TokenType.Comma */) {
                 break;
             }
             trailingCommaToken = this._getNextToken();
             isFirstEntry = false;
         }
         let closeCurlyBrace = this._peekToken();
-        if (!this._consumeTokenIfType(18 /* CloseCurlyBrace */)) {
+        if (!this._consumeTokenIfType(18 /* TokenType.CloseCurlyBrace */)) {
             this._addError(localize_1.Localizer.Diagnostic.expectedCloseBrace(), startBrace);
             closeCurlyBrace = undefined;
         }
@@ -3371,7 +3375,7 @@ class Parser {
                 break;
             }
             const expr = parser();
-            if (expr.nodeType === 0 /* Error */) {
+            if (expr.nodeType === 0 /* ParseNodeType.Error */) {
                 parseError = expr;
                 break;
             }
@@ -3380,7 +3384,7 @@ class Parser {
             if (finalEntryCheck()) {
                 break;
             }
-            if (!this._consumeTokenIfType(12 /* Comma */)) {
+            if (!this._consumeTokenIfType(12 /* TokenType.Comma */)) {
                 trailingComma = false;
                 break;
             }
@@ -3398,19 +3402,19 @@ class Parser {
         var _a, _b;
         let leftExpr = this._parseTestOrStarListAsExpression(
         /* allowAssignmentExpression */ false, 
-        /* allowMultipleUnpack */ false, 2 /* MissingExpression */, () => localize_1.Localizer.Diagnostic.expectedExpr());
+        /* allowMultipleUnpack */ false, 2 /* ErrorExpressionCategory.MissingExpression */, () => localize_1.Localizer.Diagnostic.expectedExpr());
         let annotationExpr;
-        if (leftExpr.nodeType === 0 /* Error */) {
+        if (leftExpr.nodeType === 0 /* ParseNodeType.Error */) {
             return leftExpr;
         }
         // Is this a type annotation assignment?
-        if (this._consumeTokenIfType(10 /* Colon */)) {
+        if (this._consumeTokenIfType(10 /* TokenType.Colon */)) {
             annotationExpr = this._parseTypeAnnotation();
             leftExpr = parseNodes_1.TypeAnnotationNode.create(leftExpr, annotationExpr);
             if (!this._parseOptions.isStubFile && this._getLanguageVersion() < pythonVersion_1.PythonVersion.V3_6) {
                 this._addError(localize_1.Localizer.Diagnostic.varAnnotationIllegal(), annotationExpr);
             }
-            if (!this._consumeTokenIfOperator(2 /* Assign */)) {
+            if (!this._consumeTokenIfOperator(2 /* OperatorType.Assign */)) {
                 return leftExpr;
             }
             // This is an unfortunate hack that's necessary to accommodate 'TypeAlias'
@@ -3424,17 +3428,17 @@ class Parser {
             }
             const rightExpr = (_a = this._tryParseYieldExpression()) !== null && _a !== void 0 ? _a : this._parseTestOrStarListAsExpression(
             /* allowAssignmentExpression */ false, 
-            /* allowMultipleUnpack */ true, 2 /* MissingExpression */, () => localize_1.Localizer.Diagnostic.expectedAssignRightHandExpr());
+            /* allowMultipleUnpack */ true, 2 /* ErrorExpressionCategory.MissingExpression */, () => localize_1.Localizer.Diagnostic.expectedAssignRightHandExpr());
             this._isParsingTypeAnnotation = wasParsingTypeAnnotation;
             return parseNodes_1.AssignmentNode.create(leftExpr, rightExpr);
         }
         // Is this a simple assignment?
-        if (this._consumeTokenIfOperator(2 /* Assign */)) {
+        if (this._consumeTokenIfOperator(2 /* OperatorType.Assign */)) {
             return this._parseChainAssignments(leftExpr);
         }
         if (tokenizer_1.Tokenizer.isOperatorAssignment(this._peekOperatorType())) {
             const operatorToken = this._getNextToken();
-            const rightExpr = (_b = this._tryParseYieldExpression()) !== null && _b !== void 0 ? _b : this._parseTestListAsExpression(2 /* MissingExpression */, () => localize_1.Localizer.Diagnostic.expectedBinaryRightHandExpr());
+            const rightExpr = (_b = this._tryParseYieldExpression()) !== null && _b !== void 0 ? _b : this._parseTestListAsExpression(2 /* ErrorExpressionCategory.MissingExpression */, () => localize_1.Localizer.Diagnostic.expectedBinaryRightHandExpr());
             // Make a shallow copy of the dest expression but give it a new ID.
             const destExpr = Object.assign({}, leftExpr);
             destExpr.id = (0, parseNodes_1.getNextNodeId)();
@@ -3451,12 +3455,12 @@ class Parser {
             rightExpr =
                 (_a = this._tryParseYieldExpression()) !== null && _a !== void 0 ? _a : this._parseTestOrStarListAsExpression(
                 /* allowAssignmentExpression */ false, 
-                /* allowMultipleUnpack */ true, 2 /* MissingExpression */, () => localize_1.Localizer.Diagnostic.expectedAssignRightHandExpr());
-            if (rightExpr.nodeType === 0 /* Error */) {
+                /* allowMultipleUnpack */ true, 2 /* ErrorExpressionCategory.MissingExpression */, () => localize_1.Localizer.Diagnostic.expectedAssignRightHandExpr());
+            if (rightExpr.nodeType === 0 /* ParseNodeType.Error */) {
                 break;
             }
             // Continue until we've consumed the entire chain.
-            if (!this._consumeTokenIfOperator(2 /* Assign */)) {
+            if (!this._consumeTokenIfOperator(2 /* OperatorType.Assign */)) {
                 break;
             }
             assignmentTargets.push(rightExpr);
@@ -3489,39 +3493,39 @@ class Parser {
     }
     _parseFunctionTypeAnnotation() {
         const openParenToken = this._peekToken();
-        if (!this._consumeTokenIfType(13 /* OpenParenthesis */)) {
+        if (!this._consumeTokenIfType(13 /* TokenType.OpenParenthesis */)) {
             this._addError(localize_1.Localizer.Diagnostic.expectedOpenParen(), this._peekToken());
             return undefined;
         }
         let paramAnnotations = [];
         while (true) {
             const nextTokenType = this._peekTokenType();
-            if (nextTokenType === 14 /* CloseParenthesis */ ||
-                nextTokenType === 2 /* NewLine */ ||
-                nextTokenType === 1 /* EndOfStream */) {
+            if (nextTokenType === 14 /* TokenType.CloseParenthesis */ ||
+                nextTokenType === 2 /* TokenType.NewLine */ ||
+                nextTokenType === 1 /* TokenType.EndOfStream */) {
                 break;
             }
             // Consume "*" or "**" indicators but don't do anything with them.
             // (We don't enforce that these are present, absent, or match
             // the corresponding parameter types.)
-            this._consumeTokenIfOperator(26 /* Multiply */) || this._consumeTokenIfOperator(29 /* Power */);
+            this._consumeTokenIfOperator(26 /* OperatorType.Multiply */) || this._consumeTokenIfOperator(29 /* OperatorType.Power */);
             const paramAnnotation = this._parseTypeAnnotation();
             paramAnnotations.push(paramAnnotation);
-            if (!this._consumeTokenIfType(12 /* Comma */)) {
+            if (!this._consumeTokenIfType(12 /* TokenType.Comma */)) {
                 break;
             }
         }
-        if (!this._consumeTokenIfType(14 /* CloseParenthesis */)) {
+        if (!this._consumeTokenIfType(14 /* TokenType.CloseParenthesis */)) {
             this._addError(localize_1.Localizer.Diagnostic.expectedCloseParen(), openParenToken);
-            this._consumeTokensUntilType([10 /* Colon */]);
+            this._consumeTokensUntilType([10 /* TokenType.Colon */]);
         }
-        if (!this._consumeTokenIfType(21 /* Arrow */)) {
+        if (!this._consumeTokenIfType(21 /* TokenType.Arrow */)) {
             this._addError(localize_1.Localizer.Diagnostic.expectedArrow(), this._peekToken());
             return undefined;
         }
         const returnType = this._parseTypeAnnotation();
         let isParamListEllipsis = false;
-        if (paramAnnotations.length === 1 && paramAnnotations[0].nodeType === 18 /* Ellipsis */) {
+        if (paramAnnotations.length === 1 && paramAnnotations[0].nodeType === 18 /* ParseNodeType.Ellipsis */) {
             paramAnnotations = [];
             isParamListEllipsis = true;
         }
@@ -3533,7 +3537,7 @@ class Parser {
         this._isParsingTypeAnnotation = true;
         // Allow unpack operators.
         const startToken = this._peekToken();
-        const isUnpack = this._consumeTokenIfOperator(26 /* Multiply */);
+        const isUnpack = this._consumeTokenIfOperator(26 /* OperatorType.Multiply */);
         if (isUnpack) {
             if (!allowUnpack) {
                 this._addError(localize_1.Localizer.Diagnostic.unpackInAnnotation(), startToken);
@@ -3552,20 +3556,20 @@ class Parser {
         return result;
     }
     _reportStringTokenErrors(stringToken, unescapedResult) {
-        if (stringToken.flags & 65536 /* Unterminated */) {
+        if (stringToken.flags & 65536 /* StringTokenFlags.Unterminated */) {
             this._addError(localize_1.Localizer.Diagnostic.stringUnterminated(), stringToken);
         }
         if (unescapedResult === null || unescapedResult === void 0 ? void 0 : unescapedResult.nonAsciiInBytes) {
             this._addError(localize_1.Localizer.Diagnostic.stringNonAsciiBytes(), stringToken);
         }
-        if (stringToken.flags & 64 /* Format */) {
+        if (stringToken.flags & 64 /* StringTokenFlags.Format */) {
             if (this._getLanguageVersion() < pythonVersion_1.PythonVersion.V3_6) {
                 this._addError(localize_1.Localizer.Diagnostic.formatStringIllegal(), stringToken);
             }
-            if (stringToken.flags & 32 /* Bytes */) {
+            if (stringToken.flags & 32 /* StringTokenFlags.Bytes */) {
                 this._addError(localize_1.Localizer.Diagnostic.formatStringBytes(), stringToken);
             }
-            if (stringToken.flags & 16 /* Unicode */) {
+            if (stringToken.flags & 16 /* StringTokenFlags.Unicode */) {
                 this._addError(localize_1.Localizer.Diagnostic.formatStringUnicode(), stringToken);
             }
         }
@@ -3600,7 +3604,7 @@ class Parser {
             return undefined;
         }
         const tokenOffset = curToken.start + curToken.length + match[1].length;
-        return tokenizerTypes_1.StringToken.create(tokenOffset, typeString.length, 0 /* None */, typeString, 0, 
+        return tokenizerTypes_1.StringToken.create(tokenOffset, typeString.length, 0 /* StringTokenFlags.None */, typeString, 0, 
         /* comments */ undefined);
     }
     _parseVariableTypeAnnotationComment() {
@@ -3611,7 +3615,7 @@ class Parser {
         const stringNode = this._makeStringNode(stringToken);
         const stringListNode = parseNodes_1.StringListNode.create([stringNode]);
         const parser = new Parser();
-        const parseResults = parser.parseTextExpression(this._fileContents, stringToken.start, stringToken.length, this._parseOptions, 1 /* VariableAnnotation */, 
+        const parseResults = parser.parseTextExpression(this._fileContents, stringToken.start, stringToken.length, this._parseOptions, 1 /* ParseTextMode.VariableAnnotation */, 
         /* initialParenDepth */ undefined, this._typingSymbolAliases);
         parseResults.diagnostics.forEach((diag) => {
             this._addError(diag.message, stringListNode);
@@ -3619,19 +3623,19 @@ class Parser {
         if (!parseResults.parseTree) {
             return undefined;
         }
-        (0, debug_1.assert)(parseResults.parseTree.nodeType !== 62 /* FunctionAnnotation */);
+        (0, debug_1.assert)(parseResults.parseTree.nodeType !== 62 /* ParseNodeType.FunctionAnnotation */);
         return parseResults.parseTree;
     }
     _parseFunctionTypeAnnotationComment(stringToken, functionNode) {
         const stringNode = this._makeStringNode(stringToken);
         const stringListNode = parseNodes_1.StringListNode.create([stringNode]);
         const parser = new Parser();
-        const parseResults = parser.parseTextExpression(this._fileContents, stringToken.start, stringToken.length, this._parseOptions, 2 /* FunctionAnnotation */, 
+        const parseResults = parser.parseTextExpression(this._fileContents, stringToken.start, stringToken.length, this._parseOptions, 2 /* ParseTextMode.FunctionAnnotation */, 
         /* initialParenDepth */ undefined, this._typingSymbolAliases);
         parseResults.diagnostics.forEach((diag) => {
             this._addError(diag.message, stringListNode);
         });
-        if (!parseResults.parseTree || parseResults.parseTree.nodeType !== 62 /* FunctionAnnotation */) {
+        if (!parseResults.parseTree || parseResults.parseTree.nodeType !== 62 /* ParseNodeType.FunctionAnnotation */) {
             return;
         }
         const functionAnnotation = parseResults.parseTree;
@@ -3643,19 +3647,19 @@ class Parser {
         var _a;
         let nextToken = this._getNextToken();
         // The caller should have already confirmed that the next token is an open brace.
-        (0, debug_1.assert)(nextToken.type === 17 /* OpenCurlyBrace */);
+        (0, debug_1.assert)(nextToken.type === 17 /* TokenType.OpenCurlyBrace */);
         // Consume the expression.
         const expr = (_a = this._tryParseYieldExpression()) !== null && _a !== void 0 ? _a : this._parseTestOrStarListAsExpression(
         /* allowAssignmentExpression */ true, 
-        /* allowMultipleUnpack */ true, 2 /* MissingExpression */, () => localize_1.Localizer.Diagnostic.expectedExpr());
+        /* allowMultipleUnpack */ true, 2 /* ErrorExpressionCategory.MissingExpression */, () => localize_1.Localizer.Diagnostic.expectedExpr());
         fieldExpressions.push(expr);
-        if (expr.nodeType === 0 /* Error */) {
+        if (expr.nodeType === 0 /* ParseNodeType.Error */) {
             return false;
         }
         // Consume an optional "=" token after the expression.
         nextToken = this._peekToken();
-        if (nextToken.type === 9 /* Operator */ &&
-            nextToken.operatorType === 2 /* Assign */) {
+        if (nextToken.type === 9 /* TokenType.Operator */ &&
+            nextToken.operatorType === 2 /* OperatorType.Assign */) {
             // This feature requires Python 3.8 or newer.
             if (this._parseOptions.pythonVersion < pythonVersion_1.PythonVersion.V3_8) {
                 this._addError(localize_1.Localizer.Diagnostic.formatStringDebuggingIllegal(), nextToken);
@@ -3664,10 +3668,10 @@ class Parser {
             nextToken = this._peekToken();
         }
         // Consume an optional !r, !s, or !a token.
-        if (nextToken.type === 23 /* ExclamationMark */) {
+        if (nextToken.type === 23 /* TokenType.ExclamationMark */) {
             this._getNextToken();
             nextToken = this._peekToken();
-            if (nextToken.type !== 7 /* Identifier */) {
+            if (nextToken.type !== 7 /* TokenType.Identifier */) {
                 this._addError(localize_1.Localizer.Diagnostic.formatStringExpectedConversion(), nextToken);
             }
             else {
@@ -3675,12 +3679,12 @@ class Parser {
                 nextToken = this._peekToken();
             }
         }
-        if (nextToken.type === 10 /* Colon */) {
+        if (nextToken.type === 10 /* TokenType.Colon */) {
             this._getNextToken();
             this._parseFStringFormatString(fieldExpressions, middleTokens, formatExpressions, nestingDepth);
             nextToken = this._peekToken();
         }
-        if (nextToken.type !== 18 /* CloseCurlyBrace */) {
+        if (nextToken.type !== 18 /* TokenType.CloseCurlyBrace */) {
             this._addError(localize_1.Localizer.Diagnostic.formatStringUnterminated(), nextToken);
             return false;
         }
@@ -3693,14 +3697,14 @@ class Parser {
     _parseFStringFormatString(fieldExpressions, middleTokens, formatExpressions, nestingDepth) {
         while (true) {
             const nextToken = this._peekToken();
-            if (nextToken.type === 18 /* CloseCurlyBrace */ || nextToken.type === 26 /* FStringEnd */) {
+            if (nextToken.type === 18 /* TokenType.CloseCurlyBrace */ || nextToken.type === 26 /* TokenType.FStringEnd */) {
                 break;
             }
-            if (nextToken.type === 25 /* FStringMiddle */) {
+            if (nextToken.type === 25 /* TokenType.FStringMiddle */) {
                 this._getNextToken();
                 continue;
             }
-            if (nextToken.type === 17 /* OpenCurlyBrace */) {
+            if (nextToken.type === 17 /* TokenType.OpenCurlyBrace */) {
                 // The Python interpreter reports an error at the point where the
                 // nesting level exceeds 1. Don't report the error again for deeper nestings.
                 if (nestingDepth === 2) {
@@ -3720,24 +3724,24 @@ class Parser {
         // Consume middle tokens and expressions until we hit a "{" or "}" token.
         while (true) {
             const nextToken = this._peekToken();
-            if (nextToken.type === 26 /* FStringEnd */) {
+            if (nextToken.type === 26 /* TokenType.FStringEnd */) {
                 endToken = nextToken;
-                if ((endToken.flags & 65536 /* Unterminated */) !== 0) {
+                if ((endToken.flags & 65536 /* StringTokenFlags.Unterminated */) !== 0) {
                     this._addError(localize_1.Localizer.Diagnostic.stringUnterminated(), startToken);
                 }
                 this._getNextToken();
                 break;
             }
-            if (nextToken.type === 25 /* FStringMiddle */) {
+            if (nextToken.type === 25 /* TokenType.FStringMiddle */) {
                 middleTokens.push(nextToken);
                 this._getNextToken();
                 continue;
             }
-            if (nextToken.type === 17 /* OpenCurlyBrace */) {
+            if (nextToken.type === 17 /* TokenType.OpenCurlyBrace */) {
                 if (!this._parseFStringReplacementField(fieldExpressions, middleTokens, formatExpressions)) {
                     // An error was reported. Try to recover the parse.
-                    if (this._consumeTokensUntilType([26 /* FStringEnd */, 2 /* NewLine */])) {
-                        if (this._peekToken().type === 26 /* FStringEnd */) {
+                    if (this._consumeTokensUntilType([26 /* TokenType.FStringEnd */, 2 /* TokenType.NewLine */])) {
+                        if (this._peekToken().type === 26 /* TokenType.FStringEnd */) {
                             this._getNextToken();
                         }
                     }
@@ -3746,10 +3750,10 @@ class Parser {
                 continue;
             }
             // We've hit an error. Consume tokens until we find the end.
-            if (this._consumeTokensUntilType([26 /* FStringEnd */])) {
+            if (this._consumeTokensUntilType([26 /* TokenType.FStringEnd */])) {
                 this._getNextToken();
             }
-            this._addError(nextToken.type === 18 /* CloseCurlyBrace */
+            this._addError(nextToken.type === 18 /* TokenType.CloseCurlyBrace */
                 ? localize_1.Localizer.Diagnostic.formatStringBrace()
                 : localize_1.Localizer.Diagnostic.stringUnterminated(), nextToken);
             break;
@@ -3762,11 +3766,11 @@ class Parser {
         // the subnode with an error node. Otherwise we risk crashing in the binder
         // or type evaluator.
         if (leftExpression.maxChildDepth !== undefined && leftExpression.maxChildDepth >= maxChildNodeDepth) {
-            leftExpression = parseNodes_1.ErrorNode.create(leftExpression, 14 /* MaxDepthExceeded */);
+            leftExpression = parseNodes_1.ErrorNode.create(leftExpression, 14 /* ErrorExpressionCategory.MaxDepthExceeded */);
             this._addError(localize_1.Localizer.Diagnostic.maxParseDepthExceeded(), leftExpression);
         }
         if (rightExpression.maxChildDepth !== undefined && rightExpression.maxChildDepth >= maxChildNodeDepth) {
-            rightExpression = parseNodes_1.ErrorNode.create(rightExpression, 14 /* MaxDepthExceeded */);
+            rightExpression = parseNodes_1.ErrorNode.create(rightExpression, 14 /* ErrorExpressionCategory.MaxDepthExceeded */);
             this._addError(localize_1.Localizer.Diagnostic.maxParseDepthExceeded(), rightExpression);
         }
         return parseNodes_1.BinaryOperationNode.create(leftExpression, rightExpression, operatorToken, operator);
@@ -3776,7 +3780,7 @@ class Parser {
         // the subnode with an error node. Otherwise we risk crashing in the binder
         // or type evaluator.
         if (expression.maxChildDepth !== undefined && expression.maxChildDepth >= maxChildNodeDepth) {
-            expression = parseNodes_1.ErrorNode.create(expression, 14 /* MaxDepthExceeded */);
+            expression = parseNodes_1.ErrorNode.create(expression, 14 /* ErrorExpressionCategory.MaxDepthExceeded */);
             this._addError(localize_1.Localizer.Diagnostic.maxParseDepthExceeded(), expression);
         }
         return parseNodes_1.UnaryOperationNode.create(operatorToken, expression, operator);
@@ -3785,10 +3789,10 @@ class Parser {
         const stringList = [];
         while (true) {
             const nextToken = this._peekToken();
-            if (nextToken.type === 5 /* String */) {
+            if (nextToken.type === 5 /* TokenType.String */) {
                 stringList.push(this._makeStringNode(this._getNextToken()));
             }
-            else if (nextToken.type === 24 /* FStringStart */) {
+            else if (nextToken.type === 24 /* TokenType.FStringStart */) {
                 stringList.push(this._parseFormatString(this._getNextToken()));
             }
             else {
@@ -3803,7 +3807,7 @@ class Parser {
             if (stringNode.strings.length > 1) {
                 this._addError(localize_1.Localizer.Diagnostic.annotationSpansStrings(), stringNode);
             }
-            else if (stringNode.strings[0].nodeType === 27 /* FormatString */) {
+            else if (stringNode.strings[0].nodeType === 27 /* ParseNodeType.FormatString */) {
                 this._addError(localize_1.Localizer.Diagnostic.annotationFormatString(), stringNode);
             }
             else {
@@ -3819,14 +3823,14 @@ class Parser {
                 }
                 else {
                     const parser = new Parser();
-                    const parseResults = parser.parseTextExpression(this._fileContents, tokenOffset + prefixLength, unescapedString.length, this._parseOptions, 1 /* VariableAnnotation */, (stringNode.strings[0].token.flags & 4 /* Triplicate */) !== 0 ? 1 : 0, this._typingSymbolAliases);
+                    const parseResults = parser.parseTextExpression(this._fileContents, tokenOffset + prefixLength, unescapedString.length, this._parseOptions, 1 /* ParseTextMode.VariableAnnotation */, (stringNode.strings[0].token.flags & 4 /* StringTokenFlags.Triplicate */) !== 0 ? 1 : 0, this._typingSymbolAliases);
                     if (parseResults.diagnostics.length === 0 ||
                         this._parseOptions.reportErrorsForParsedStringContents) {
                         parseResults.diagnostics.forEach((diag) => {
                             this._addError(diag.message, stringNode);
                         });
                         if (parseResults.parseTree) {
-                            (0, debug_1.assert)(parseResults.parseTree.nodeType !== 62 /* FunctionAnnotation */);
+                            (0, debug_1.assert)(parseResults.parseTree.nodeType !== 62 /* ParseNodeType.FunctionAnnotation */);
                             stringNode.typeAnnotation = parseResults.parseTree;
                             stringNode.typeAnnotation.parent = stringNode;
                         }
@@ -3840,7 +3844,7 @@ class Parser {
     // following a return or yield statement in cases where the tuple
     // wasn't surrounded in parentheses.
     _reportConditionalErrorForStarTupleElement(possibleTupleExpr) {
-        if (possibleTupleExpr.nodeType !== 52 /* Tuple */) {
+        if (possibleTupleExpr.nodeType !== 52 /* ParseNodeType.Tuple */) {
             return;
         }
         if (possibleTupleExpr.enclosedInParens) {
@@ -3850,7 +3854,7 @@ class Parser {
             return;
         }
         for (const expr of possibleTupleExpr.expressions) {
-            if (expr.nodeType === 56 /* Unpack */) {
+            if (expr.nodeType === 56 /* ParseNodeType.Unpack */) {
                 this._addError(localize_1.Localizer.Diagnostic.unpackTuplesIllegal(), expr);
                 return;
             }
@@ -3861,47 +3865,47 @@ class Parser {
     _isNextTokenNeverExpression() {
         const nextToken = this._peekToken();
         switch (nextToken.type) {
-            case 8 /* Keyword */: {
+            case 8 /* TokenType.Keyword */: {
                 switch (this._peekKeywordType()) {
-                    case 17 /* For */:
-                    case 22 /* In */:
-                    case 20 /* If */:
+                    case 17 /* KeywordType.For */:
+                    case 22 /* KeywordType.In */:
+                    case 20 /* KeywordType.If */:
                         return true;
                 }
                 break;
             }
-            case 9 /* Operator */: {
+            case 9 /* TokenType.Operator */: {
                 switch (this._peekOperatorType()) {
-                    case 1 /* AddEqual */:
-                    case 34 /* SubtractEqual */:
-                    case 27 /* MultiplyEqual */:
-                    case 11 /* DivideEqual */:
-                    case 25 /* ModEqual */:
-                    case 4 /* BitwiseAndEqual */:
-                    case 7 /* BitwiseOrEqual */:
-                    case 9 /* BitwiseXorEqual */:
-                    case 18 /* LeftShiftEqual */:
-                    case 32 /* RightShiftEqual */:
-                    case 30 /* PowerEqual */:
-                    case 14 /* FloorDivideEqual */:
-                    case 2 /* Assign */:
+                    case 1 /* OperatorType.AddEqual */:
+                    case 34 /* OperatorType.SubtractEqual */:
+                    case 27 /* OperatorType.MultiplyEqual */:
+                    case 11 /* OperatorType.DivideEqual */:
+                    case 25 /* OperatorType.ModEqual */:
+                    case 4 /* OperatorType.BitwiseAndEqual */:
+                    case 7 /* OperatorType.BitwiseOrEqual */:
+                    case 9 /* OperatorType.BitwiseXorEqual */:
+                    case 18 /* OperatorType.LeftShiftEqual */:
+                    case 32 /* OperatorType.RightShiftEqual */:
+                    case 30 /* OperatorType.PowerEqual */:
+                    case 14 /* OperatorType.FloorDivideEqual */:
+                    case 2 /* OperatorType.Assign */:
                         return true;
                 }
                 break;
             }
-            case 3 /* Indent */:
-            case 4 /* Dedent */:
-            case 2 /* NewLine */:
-            case 1 /* EndOfStream */:
-            case 11 /* Semicolon */:
-            case 14 /* CloseParenthesis */:
-            case 16 /* CloseBracket */:
-            case 18 /* CloseCurlyBrace */:
-            case 12 /* Comma */:
-            case 10 /* Colon */:
-            case 23 /* ExclamationMark */:
-            case 25 /* FStringMiddle */:
-            case 26 /* FStringEnd */:
+            case 3 /* TokenType.Indent */:
+            case 4 /* TokenType.Dedent */:
+            case 2 /* TokenType.NewLine */:
+            case 1 /* TokenType.EndOfStream */:
+            case 11 /* TokenType.Semicolon */:
+            case 14 /* TokenType.CloseParenthesis */:
+            case 16 /* TokenType.CloseBracket */:
+            case 18 /* TokenType.CloseCurlyBrace */:
+            case 12 /* TokenType.Comma */:
+            case 10 /* TokenType.Colon */:
+            case 23 /* TokenType.ExclamationMark */:
+            case 25 /* TokenType.FStringMiddle */:
+            case 26 /* TokenType.FStringEnd */:
                 return true;
         }
         return false;
@@ -3938,31 +3942,31 @@ class Parser {
     }
     _peekKeywordType() {
         const nextToken = this._peekToken();
-        if (nextToken.type !== 8 /* Keyword */) {
+        if (nextToken.type !== 8 /* TokenType.Keyword */) {
             return undefined;
         }
         return nextToken.keywordType;
     }
     _peekOperatorType() {
         const nextToken = this._peekToken();
-        if (nextToken.type !== 9 /* Operator */) {
+        if (nextToken.type !== 9 /* TokenType.Operator */) {
             return undefined;
         }
         return nextToken.operatorType;
     }
     _getTokenIfIdentifier() {
         const nextToken = this._peekToken();
-        if (nextToken.type === 7 /* Identifier */) {
+        if (nextToken.type === 7 /* TokenType.Identifier */) {
             return this._getNextToken();
         }
         // If the next token is invalid, treat it as an identifier.
-        if (nextToken.type === 0 /* Invalid */) {
+        if (nextToken.type === 0 /* TokenType.Invalid */) {
             this._getNextToken();
             this._addError(localize_1.Localizer.Diagnostic.invalidIdentifierChar(), nextToken);
             return tokenizerTypes_1.IdentifierToken.create(nextToken.start, nextToken.length, '', nextToken.comments);
         }
         // If this is a "soft keyword", it can be converted into an identifier.
-        if (nextToken.type === 8 /* Keyword */) {
+        if (nextToken.type === 8 /* TokenType.Keyword */) {
             const keywordType = this._peekKeywordType();
             if (tokenizerTypes_1.softKeywords.find((type) => type === keywordType)) {
                 const keywordText = this._fileContents.substr(nextToken.start, nextToken.length);
@@ -3981,7 +3985,7 @@ class Parser {
             if (terminators.some((term) => term === token.type)) {
                 return true;
             }
-            if (token.type === 1 /* EndOfStream */) {
+            if (token.type === 1 /* TokenType.EndOfStream */) {
                 return false;
             }
             this._getNextToken();
@@ -4012,7 +4016,7 @@ class Parser {
     }
     _getKeywordToken(keywordType) {
         const keywordToken = this._getNextToken();
-        (0, debug_1.assert)(keywordToken.type === 8 /* Keyword */);
+        (0, debug_1.assert)(keywordToken.type === 8 /* TokenType.Keyword */);
         (0, debug_1.assert)(keywordToken.keywordType === keywordType);
         return keywordToken;
     }