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

package/dist/analyzer/binder.js

@@ -18,7 +18,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];
@@ -109,7 +113,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         // We'll assume that if there is no builtins scope provided, we must be
         // binding the builtins module itself.
         const isBuiltInModule = this._fileInfo.builtinsScope === undefined;
-        this._createNewScope(isBuiltInModule ? 4 /* Builtin */ : 3 /* Module */, this._fileInfo.builtinsScope, () => {
+        this._createNewScope(isBuiltInModule ? 4 /* ScopeType.Builtin */ : 3 /* ScopeType.Module */, this._fileInfo.builtinsScope, () => {
             AnalyzerNodeInfo.setScope(node, this._currentScope);
             AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
             // Bind implicit names.
@@ -201,13 +205,13 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         }
         // A source file was found, but the type stub was missing.
         if (!importResult.isStubFile &&
-            importResult.importType === 1 /* ThirdParty */ &&
+            importResult.importType === 1 /* ImportType.ThirdParty */ &&
             !importResult.pyTypedInfo) {
             const diagnostic = this._addDiagnostic(this._fileInfo.diagnosticRuleSet.reportMissingTypeStubs, diagnosticRules_1.DiagnosticRule.reportMissingTypeStubs, localize_1.Localizer.Diagnostic.stubFileMissing().format({ importName: importResult.importName }), node);
             if (diagnostic) {
                 // Add a diagnostic action for resolving this diagnostic.
                 const createTypeStubAction = {
-                    action: "pyright.createtypestub" /* createTypeStub */,
+                    action: "pyright.createtypestub" /* Commands.createTypeStub */,
                     moduleName: importResult.importName,
                 };
                 diagnostic.addAction(createTypeStubAction);
@@ -218,7 +222,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     visitClass(node) {
         this.walkMultiple(node.decorators);
         const classDeclaration = {
-            type: 6 /* Class */,
+            type: 6 /* DeclarationType.Class */,
             node,
             path: this._fileInfo.filePath,
             range: (0, positionUtils_1.convertTextRangeToRange)(node.name, this._fileInfo.lines),
@@ -235,7 +239,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             this.walk(node.typeParameters);
         }
         this.walkMultiple(node.arguments);
-        this._createNewScope(2 /* Class */, this._getNonClassParentScope(), () => {
+        this._createNewScope(2 /* ScopeType.Class */, this._getNonClassParentScope(), () => {
             AnalyzerNodeInfo.setScope(node, this._currentScope);
             this._addImplicitSymbolToCurrentScope('__doc__', node, 'str | None');
             this._addImplicitSymbolToCurrentScope('__module__', node, 'str');
@@ -261,7 +265,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         const symbol = this._bindNameToScope(this._currentScope, node.name);
         const containingClassNode = ParseTreeUtils.getEnclosingClass(node, /* stopAtFunction */ true);
         const functionDeclaration = {
-            type: 5 /* Function */,
+            type: 5 /* DeclarationType.Function */,
             node,
             isMethod: !!containingClassNode,
             isGenerator: false,
@@ -301,7 +305,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         }
         // Don't walk the body of the function until we're done analyzing
         // the current scope.
-        this._createNewScope(1 /* Function */, this._getNonClassParentScope(), () => {
+        this._createNewScope(1 /* ScopeType.Function */, this._getNonClassParentScope(), () => {
             AnalyzerNodeInfo.setScope(node, this._currentScope);
             const enclosingClass = ParseTreeUtils.getEnclosingClass(node);
             if (enclosingClass) {
@@ -323,7 +327,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                         }
                         if (symbol) {
                             const paramDeclaration = {
-                                type: 2 /* Parameter */,
+                                type: 2 /* DeclarationType.Parameter */,
                                 node: paramNode,
                                 path: this._fileInfo.filePath,
                                 range: (0, positionUtils_1.convertTextRangeToRange)(paramNode, this._fileInfo.lines),
@@ -371,7 +375,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 this.walk(param.defaultValue);
             }
         });
-        this._createNewScope(1 /* Function */, this._getNonClassParentScope(), () => {
+        this._createNewScope(1 /* ScopeType.Function */, this._getNonClassParentScope(), () => {
             AnalyzerNodeInfo.setScope(node, this._currentScope);
             this._deferBinding(() => {
                 // Create a start node for the lambda.
@@ -381,7 +385,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                         const symbol = this._bindNameToScope(this._currentScope, paramNode.name);
                         if (symbol) {
                             const paramDeclaration = {
-                                type: 2 /* Parameter */,
+                                type: 2 /* DeclarationType.Parameter */,
                                 node: paramNode,
                                 path: this._fileInfo.filePath,
                                 range: (0, positionUtils_1.convertTextRangeToRange)(paramNode, this._fileInfo.lines),
@@ -421,7 +425,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         // There are libraries that make extensive use of unannotated decorators,
         // and this can lead to a performance issue when walking the control
         // flow graph if we need to evaluate every decorator.
-        if (!ParseTreeUtils.isNodeContainedWithinNodeType(node, 13 /* Decorator */)) {
+        if (!ParseTreeUtils.isNodeContainedWithinNodeType(node, 13 /* ParseNodeType.Decorator */)) {
             // Skip if we're in an 'Annotated' annotation because this creates
             // problems for "No Return" return type analysis when annotation
             // evaluation is deferred.
@@ -430,29 +434,29 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
         // Is this an manipulation of dunder all?
-        if (this._currentScope.type === 3 /* Module */ &&
-            node.leftExpression.nodeType === 35 /* MemberAccess */ &&
-            node.leftExpression.leftExpression.nodeType === 38 /* Name */ &&
+        if (this._currentScope.type === 3 /* ScopeType.Module */ &&
+            node.leftExpression.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
+            node.leftExpression.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
             node.leftExpression.leftExpression.value === '__all__') {
             let emitDunderAllWarning = true;
             // Is this a call to "__all__.extend()"?
             if (node.leftExpression.memberName.value === 'extend' && node.arguments.length === 1) {
                 const argExpr = node.arguments[0].valueExpression;
                 // Is this a call to "__all__.extend([<list>])"?
-                if (argExpr.nodeType === 31 /* List */) {
+                if (argExpr.nodeType === 31 /* ParseNodeType.List */) {
                     argExpr.entries.forEach((listEntryNode) => {
                         var _a, _b;
-                        if (listEntryNode.nodeType === 48 /* StringList */ &&
+                        if (listEntryNode.nodeType === 48 /* ParseNodeType.StringList */ &&
                             listEntryNode.strings.length === 1 &&
-                            listEntryNode.strings[0].nodeType === 49 /* String */) {
+                            listEntryNode.strings[0].nodeType === 49 /* ParseNodeType.String */) {
                             (_a = this._dunderAllNames) === null || _a === void 0 ? void 0 : _a.push(listEntryNode.strings[0].value);
                             (_b = this._dunderAllStringNodes) === null || _b === void 0 ? void 0 : _b.push(listEntryNode.strings[0]);
                             emitDunderAllWarning = false;
                         }
                     });
                 }
-                else if (argExpr.nodeType === 35 /* MemberAccess */ &&
-                    argExpr.leftExpression.nodeType === 38 /* Name */ &&
+                else if (argExpr.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
+                    argExpr.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
                     argExpr.memberName.value === '__all__') {
                     // Is this a call to "__all__.extend(<mod>.__all__)"?
                     const namesToAdd = this._getDunderAllNamesFromImport(argExpr.leftExpression.value);
@@ -468,9 +472,9 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             else if (node.leftExpression.memberName.value === 'remove' && node.arguments.length === 1) {
                 // Is this a call to "__all__.remove()"?
                 const argExpr = node.arguments[0].valueExpression;
-                if (argExpr.nodeType === 48 /* StringList */ &&
+                if (argExpr.nodeType === 48 /* ParseNodeType.StringList */ &&
                     argExpr.strings.length === 1 &&
-                    argExpr.strings[0].nodeType === 49 /* String */ &&
+                    argExpr.strings[0].nodeType === 49 /* ParseNodeType.String */ &&
                     this._dunderAllNames) {
                     this._dunderAllNames = this._dunderAllNames.filter((name) => name !== argExpr.strings[0].value);
                     this._dunderAllStringNodes = this._dunderAllStringNodes.filter((node) => node.value !== argExpr.strings[0].value);
@@ -480,9 +484,9 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             else if (node.leftExpression.memberName.value === 'append' && node.arguments.length === 1) {
                 // Is this a call to "__all__.append()"?
                 const argExpr = node.arguments[0].valueExpression;
-                if (argExpr.nodeType === 48 /* StringList */ &&
+                if (argExpr.nodeType === 48 /* ParseNodeType.StringList */ &&
                     argExpr.strings.length === 1 &&
-                    argExpr.strings[0].nodeType === 49 /* String */) {
+                    argExpr.strings[0].nodeType === 49 /* ParseNodeType.String */) {
                     (_a = this._dunderAllNames) === null || _a === void 0 ? void 0 : _a.push(argExpr.strings[0].value);
                     (_b = this._dunderAllStringNodes) === null || _b === void 0 ? void 0 : _b.push(argExpr.strings[0]);
                     emitDunderAllWarning = false;
@@ -503,9 +507,9 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         });
         node.parameters.forEach((param) => {
             const name = param.name;
-            const symbol = new symbol_1.Symbol(0 /* None */);
+            const symbol = new symbol_1.Symbol(0 /* SymbolFlags.None */);
             const paramDeclaration = {
-                type: 3 /* TypeParameter */,
+                type: 3 /* DeclarationType.TypeParameter */,
                 node: param,
                 path: this._fileInfo.filePath,
                 range: (0, positionUtils_1.convertTextRangeToRange)(node, this._fileInfo.lines),
@@ -536,7 +540,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             this.walk(node.typeParameters);
         }
         const typeAliasDeclaration = {
-            type: 4 /* TypeAlias */,
+            type: 4 /* DeclarationType.TypeAlias */,
             node,
             path: this._fileInfo.filePath,
             range: (0, positionUtils_1.convertTextRangeToRange)(node.name, this._fileInfo.lines),
@@ -571,11 +575,11 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         // If the assignment target base expression is potentially a
         // TypedDict, add the base expression to the flow expressions set
         // to accommodate TypedDict type narrowing.
-        if (node.leftExpression.nodeType === 24 /* Index */) {
+        if (node.leftExpression.nodeType === 24 /* ParseNodeType.Index */) {
             const target = node.leftExpression;
             if (target.items.length === 1 &&
                 !target.trailingComma &&
-                target.items[0].valueExpression.nodeType === 48 /* StringList */) {
+                target.items[0].valueExpression.nodeType === 48 /* ParseNodeType.StringList */) {
                 if ((0, codeFlowTypes_1.isCodeFlowSupportedForReference)(target.baseExpression)) {
                     const baseExprReferenceKey = (0, codeFlowTypes_1.createKeyForReference)(target.baseExpression);
                     this._currentScopeCodeFlowExpressions.add(baseExprReferenceKey);
@@ -589,7 +593,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             // or as class variables, not as local variables within a function.
             isPossibleTypeAlias = false;
         }
-        else if (node.rightExpression.nodeType === 9 /* Call */ && this._fileInfo.isTypingStubFile) {
+        else if (node.rightExpression.nodeType === 9 /* ParseNodeType.Call */ && this._fileInfo.isTypingStubFile) {
             // Some special built-in types defined in typing.pyi use
             // assignments of the form List = _Alias(). We don't want to
             // treat these as type aliases.
@@ -603,19 +607,19 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         // If we didn't create assignment target flow nodes above, do so now.
         this._createAssignmentTargetFlowNodes(node.leftExpression, /* walkTargets */ true, /* unbound */ false);
         // Is this an assignment to dunder all?
-        if (this._currentScope.type === 3 /* Module */) {
-            if ((node.leftExpression.nodeType === 38 /* Name */ && node.leftExpression.value === '__all__') ||
-                (node.leftExpression.nodeType === 54 /* TypeAnnotation */ &&
-                    node.leftExpression.valueExpression.nodeType === 38 /* Name */ &&
+        if (this._currentScope.type === 3 /* ScopeType.Module */) {
+            if ((node.leftExpression.nodeType === 38 /* ParseNodeType.Name */ && node.leftExpression.value === '__all__') ||
+                (node.leftExpression.nodeType === 54 /* ParseNodeType.TypeAnnotation */ &&
+                    node.leftExpression.valueExpression.nodeType === 38 /* ParseNodeType.Name */ &&
                     node.leftExpression.valueExpression.value === '__all__')) {
                 const expr = node.rightExpression;
                 this._dunderAllNames = [];
                 let emitDunderAllWarning = false;
-                if (expr.nodeType === 31 /* List */) {
+                if (expr.nodeType === 31 /* ParseNodeType.List */) {
                     expr.entries.forEach((listEntryNode) => {
-                        if (listEntryNode.nodeType === 48 /* StringList */ &&
+                        if (listEntryNode.nodeType === 48 /* ParseNodeType.StringList */ &&
                             listEntryNode.strings.length === 1 &&
-                            listEntryNode.strings[0].nodeType === 49 /* String */) {
+                            listEntryNode.strings[0].nodeType === 49 /* ParseNodeType.String */) {
                             this._dunderAllNames.push(listEntryNode.strings[0].value);
                             this._dunderAllStringNodes.push(listEntryNode.strings[0]);
                         }
@@ -624,11 +628,11 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                         }
                     });
                 }
-                else if (expr.nodeType === 52 /* Tuple */) {
+                else if (expr.nodeType === 52 /* ParseNodeType.Tuple */) {
                     expr.expressions.forEach((tupleEntryNode) => {
-                        if (tupleEntryNode.nodeType === 48 /* StringList */ &&
+                        if (tupleEntryNode.nodeType === 48 /* ParseNodeType.StringList */ &&
                             tupleEntryNode.strings.length === 1 &&
-                            tupleEntryNode.strings[0].nodeType === 49 /* String */) {
+                            tupleEntryNode.strings[0].nodeType === 49 /* ParseNodeType.String */) {
                             this._dunderAllNames.push(tupleEntryNode.strings[0].value);
                             this._dunderAllStringNodes.push(tupleEntryNode.strings[0]);
                         }
@@ -647,22 +651,22 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
         // Is this an assignment to dunder slots?
-        if (this._currentScope.type === 2 /* Class */) {
-            if ((node.leftExpression.nodeType === 38 /* Name */ && node.leftExpression.value === '__slots__') ||
-                (node.leftExpression.nodeType === 54 /* TypeAnnotation */ &&
-                    node.leftExpression.valueExpression.nodeType === 38 /* Name */ &&
+        if (this._currentScope.type === 2 /* ScopeType.Class */) {
+            if ((node.leftExpression.nodeType === 38 /* ParseNodeType.Name */ && node.leftExpression.value === '__slots__') ||
+                (node.leftExpression.nodeType === 54 /* ParseNodeType.TypeAnnotation */ &&
+                    node.leftExpression.valueExpression.nodeType === 38 /* ParseNodeType.Name */ &&
                     node.leftExpression.valueExpression.value === '__slots__')) {
                 const expr = node.rightExpression;
                 this._dunderSlotsEntries = [];
                 let isExpressionUnderstood = true;
-                if (expr.nodeType === 48 /* StringList */) {
+                if (expr.nodeType === 48 /* ParseNodeType.StringList */) {
                     this._dunderSlotsEntries.push(expr);
                 }
-                else if (expr.nodeType === 31 /* List */) {
+                else if (expr.nodeType === 31 /* ParseNodeType.List */) {
                     expr.entries.forEach((listEntryNode) => {
-                        if (listEntryNode.nodeType === 48 /* StringList */ &&
+                        if (listEntryNode.nodeType === 48 /* ParseNodeType.StringList */ &&
                             listEntryNode.strings.length === 1 &&
-                            listEntryNode.strings[0].nodeType === 49 /* String */) {
+                            listEntryNode.strings[0].nodeType === 49 /* ParseNodeType.String */) {
                             this._dunderSlotsEntries.push(listEntryNode);
                         }
                         else {
@@ -670,11 +674,11 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                         }
                     });
                 }
-                else if (expr.nodeType === 52 /* Tuple */) {
+                else if (expr.nodeType === 52 /* ParseNodeType.Tuple */) {
                     expr.expressions.forEach((tupleEntryNode) => {
-                        if (tupleEntryNode.nodeType === 48 /* StringList */ &&
+                        if (tupleEntryNode.nodeType === 48 /* ParseNodeType.StringList */ &&
                             tupleEntryNode.strings.length === 1 &&
-                            tupleEntryNode.strings[0].nodeType === 49 /* String */) {
+                            tupleEntryNode.strings[0].nodeType === 49 /* ParseNodeType.String */) {
                             this._dunderSlotsEntries.push(tupleEntryNode);
                         }
                         else {
@@ -735,27 +739,27 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         this._createAssignmentTargetFlowNodes(node.destExpression, /* walkTargets */ false, /* unbound */ false);
         // Is this an assignment to dunder all of the form
         // __all__ += <expression>?
-        if (node.operator === 1 /* AddEqual */ &&
-            this._currentScope.type === 3 /* Module */ &&
-            node.leftExpression.nodeType === 38 /* Name */ &&
+        if (node.operator === 1 /* OperatorType.AddEqual */ &&
+            this._currentScope.type === 3 /* ScopeType.Module */ &&
+            node.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
             node.leftExpression.value === '__all__') {
             const expr = node.rightExpression;
             let emitDunderAllWarning = true;
-            if (expr.nodeType === 31 /* List */) {
+            if (expr.nodeType === 31 /* ParseNodeType.List */) {
                 // Is this the form __all__ += ["a", "b"]?
                 expr.entries.forEach((listEntryNode) => {
                     var _a;
-                    if (listEntryNode.nodeType === 48 /* StringList */ &&
+                    if (listEntryNode.nodeType === 48 /* ParseNodeType.StringList */ &&
                         listEntryNode.strings.length === 1 &&
-                        listEntryNode.strings[0].nodeType === 49 /* String */) {
+                        listEntryNode.strings[0].nodeType === 49 /* ParseNodeType.String */) {
                         (_a = this._dunderAllNames) === null || _a === void 0 ? void 0 : _a.push(listEntryNode.strings[0].value);
                         this._dunderAllStringNodes.push(listEntryNode.strings[0]);
                     }
                 });
                 emitDunderAllWarning = false;
             }
-            else if (expr.nodeType === 35 /* MemberAccess */ &&
-                expr.leftExpression.nodeType === 38 /* Name */ &&
+            else if (expr.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
+                expr.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
                 expr.memberName.value === '__all__') {
                 // Is this using the form "__all__ += <mod>.__all__"?
                 const namesToAdd = this._getDunderAllNamesFromImport(expr.leftExpression.value);
@@ -789,7 +793,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         }
         // If this is an annotated variable assignment within a class body,
         // we need to evaluate the type annotation first.
-        const bindVariableBeforeAnnotationEvaluation = ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 3 /* Assignment */ &&
+        const bindVariableBeforeAnnotationEvaluation = ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 3 /* ParseNodeType.Assignment */ &&
             ParseTreeUtils.getEnclosingClass(node, /* stopAtFunction */ true) !== undefined;
         if (!bindVariableBeforeAnnotationEvaluation) {
             this.walk(node.typeAnnotation);
@@ -1009,7 +1013,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             this._createAssignmentTargetFlowNodes(node.name, /* walkTargets */ true, /* unbound */ false);
             if (symbol) {
                 const declaration = {
-                    type: 1 /* Variable */,
+                    type: 1 /* DeclarationType.Variable */,
                     node: node.name,
                     isConstant: (0, symbolNameUtils_1.isConstantName)(node.name.value),
                     inferredTypeSource: node,
@@ -1033,6 +1037,9 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         return false;
     }
     visitRaise(node) {
+        if (this._currentFlowNode) {
+            this._addExceptTargets(this._currentFlowNode);
+        }
         if (this._targetFunctionDeclaration) {
             if (!this._targetFunctionDeclaration.raiseStatements) {
                 this._targetFunctionDeclaration.raiseStatements = [];
@@ -1183,7 +1190,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             // Allow if it's within a generator expression. Execution of
             // generator expressions is deferred and therefore can be
             // run within the context of an async function later.
-            if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 32 /* ListComprehension */) {
+            if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 32 /* ParseNodeType.ListComprehension */) {
                 this._addError(localize_1.Localizer.Diagnostic.awaitNotInAsync(), node);
             }
         }
@@ -1194,7 +1201,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         node.nameList.forEach((name) => {
             const nameValue = name.value;
             // Is the binding inconsistent?
-            if (this._currentScope.getBindingType(nameValue) === 0 /* Nonlocal */) {
+            if (this._currentScope.getBindingType(nameValue) === 0 /* NameBindingType.Nonlocal */) {
                 this._addError(localize_1.Localizer.Diagnostic.nonLocalRedefinition().format({ name: nameValue }), name);
             }
             const valueWithScope = this._currentScope.lookUpSymbolRecursive(nameValue);
@@ -1205,7 +1212,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             // Add it to the global scope if it's not already added.
             this._bindNameToScope(globalScope, name);
             if (this._currentScope !== globalScope) {
-                this._currentScope.setBindingType(nameValue, 1 /* Global */);
+                this._currentScope.setBindingType(nameValue, 1 /* NameBindingType.Global */);
             }
         });
         return true;
@@ -1219,7 +1226,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             node.nameList.forEach((name) => {
                 const nameValue = name.value;
                 // Is the binding inconsistent?
-                if (this._currentScope.getBindingType(nameValue) === 1 /* Global */) {
+                if (this._currentScope.getBindingType(nameValue) === 1 /* NameBindingType.Global */) {
                     this._addError(localize_1.Localizer.Diagnostic.globalRedefinition().format({ name: nameValue }), name);
                 }
                 const valueWithScope = this._currentScope.lookUpSymbolRecursive(nameValue);
@@ -1231,7 +1238,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                     this._addError(localize_1.Localizer.Diagnostic.nonLocalNoBinding().format({ name: nameValue }), name);
                 }
                 if (valueWithScope) {
-                    this._currentScope.setBindingType(nameValue, 0 /* Nonlocal */);
+                    this._currentScope.setBindingType(nameValue, 0 /* NameBindingType.Nonlocal */);
                 }
             });
         }
@@ -1256,7 +1263,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             }
             const symbol = this._bindNameToScope(this._currentScope, symbolNameNode);
             if (symbol &&
-                (this._currentScope.type === 3 /* Module */ || this._currentScope.type === 4 /* Builtin */) &&
+                (this._currentScope.type === 3 /* ScopeType.Module */ || this._currentScope.type === 4 /* ScopeType.Builtin */) &&
                 (!node.alias ||
                     node.module.nameParts.length !== 1 ||
                     node.module.nameParts[0].value !== node.alias.value)) {
@@ -1347,7 +1354,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                             // alias it.
                             if (importedSymbol) {
                                 const aliasDecl = {
-                                    type: 8 /* Alias */,
+                                    type: 8 /* DeclarationType.Alias */,
                                     node,
                                     path: resolvedPath,
                                     loadSymbolsFromPath: true,
@@ -1367,7 +1374,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                                     const implicitImport = importInfo.filteredImplicitImports.get(name);
                                     if (implicitImport) {
                                         const submoduleFallback = {
-                                            type: 8 /* Alias */,
+                                            type: 8 /* DeclarationType.Alias */,
                                             node,
                                             path: implicitImport.path,
                                             loadSymbolsFromPath: true,
@@ -1377,7 +1384,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                                             isInExceptSuite: this._isInExceptSuite,
                                         };
                                         const aliasDecl = {
-                                            type: 8 /* Alias */,
+                                            type: 8 /* DeclarationType.Alias */,
                                             node,
                                             path: resolvedPath,
                                             loadSymbolsFromPath: true,
@@ -1422,8 +1429,8 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                     // All import statements of the form `from . import x` treat x
                     // as an externally-visible (not hidden) symbol.
                     if (node.module.nameParts.length > 0) {
-                        if (this._currentScope.type === 3 /* Module */ ||
-                            this._currentScope.type === 4 /* Builtin */) {
+                        if (this._currentScope.type === 3 /* ScopeType.Module */ ||
+                            this._currentScope.type === 4 /* ScopeType.Builtin */) {
                             if (!importSymbolNode.alias ||
                                 importSymbolNode.alias.value !== importSymbolNode.name.value) {
                                 if (this._fileInfo.isStubFile || this._fileInfo.isInPyTypedPackage) {
@@ -1445,7 +1452,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                     let loadSymbolsFromPath = true;
                     if (implicitImport) {
                         submoduleFallback = {
-                            type: 8 /* Alias */,
+                            type: 8 /* DeclarationType.Alias */,
                             node: importSymbolNode,
                             path: implicitImport.path,
                             loadSymbolsFromPath: true,
@@ -1469,7 +1476,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                         }
                     }
                     const aliasDecl = {
-                        type: 8 /* Alias */,
+                        type: 8 /* DeclarationType.Alias */,
                         node: importSymbolNode,
                         path: resolvedPath,
                         loadSymbolsFromPath,
@@ -1583,7 +1590,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         return false;
     }
     visitUnaryOperation(node) {
-        if (node.operator === 38 /* Not */ && this._currentFalseTarget && this._currentTrueTarget) {
+        if (node.operator === 38 /* OperatorType.Not */ && this._currentFalseTarget && this._currentTrueTarget) {
             // Swap the existing true/false targets.
             this._bindConditional(node.expression, this._currentFalseTarget, this._currentTrueTarget);
         }
@@ -1599,7 +1606,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         return false;
     }
     visitBinaryOperation(node) {
-        if (node.operator === 36 /* And */ || node.operator === 37 /* Or */) {
+        if (node.operator === 36 /* OperatorType.And */ || node.operator === 37 /* OperatorType.Or */) {
             let trueTarget = this._currentTrueTarget;
             let falseTarget = this._currentFalseTarget;
             let postRightLabel;
@@ -1608,7 +1615,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 trueTarget = falseTarget = postRightLabel;
             }
             const preRightLabel = this._createBranchLabel();
-            if (node.operator === 36 /* And */) {
+            if (node.operator === 36 /* OperatorType.And */) {
                 this._bindConditional(node.leftExpression, preRightLabel, falseTarget);
             }
             else {
@@ -1634,10 +1641,10 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     visitListComprehension(node) {
         const enclosingFunction = ParseTreeUtils.getEnclosingFunction(node);
         // The first iterable is executed outside of the comprehension scope.
-        if (node.forIfNodes.length > 0 && node.forIfNodes[0].nodeType === 33 /* ListComprehensionFor */) {
+        if (node.forIfNodes.length > 0 && node.forIfNodes[0].nodeType === 33 /* ParseNodeType.ListComprehensionFor */) {
             this.walk(node.forIfNodes[0].iterableExpression);
         }
-        this._createNewScope(0 /* ListComprehension */, this._getNonClassParentScope(), () => {
+        this._createNewScope(0 /* ScopeType.ListComprehension */, this._getNonClassParentScope(), () => {
             var _a;
             AnalyzerNodeInfo.setScope(node, this._currentScope);
             const falseLabel = this._createBranchLabel();
@@ -1647,7 +1654,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             for (let i = 0; i < node.forIfNodes.length; i++) {
                 const compr = node.forIfNodes[i];
                 const addedSymbols = new Map();
-                if (compr.nodeType === 33 /* ListComprehensionFor */) {
+                if (compr.nodeType === 33 /* ParseNodeType.ListComprehensionFor */) {
                     this._bindPossibleTupleNamedTarget(compr.targetExpression, addedSymbols);
                     this._addInferredTypeAssignmentForVariable(compr.targetExpression, compr);
                     // Async for is not allowed outside of an async function
@@ -1657,7 +1664,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                             // Allow if it's within a generator expression. Execution of
                             // generator expressions is deferred and therefore can be
                             // run within the context of an async function later.
-                            if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 31 /* List */) {
+                            if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 31 /* ParseNodeType.List */) {
                                 this._addError(localize_1.Localizer.Diagnostic.asyncNotInAsyncFunction(), compr.asyncToken);
                             }
                         }
@@ -1666,7 +1673,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             }
             for (let i = 0; i < node.forIfNodes.length; i++) {
                 const compr = node.forIfNodes[i];
-                if (compr.nodeType === 33 /* ListComprehensionFor */) {
+                if (compr.nodeType === 33 /* ParseNodeType.ListComprehensionFor */) {
                     // We already walked the first iterable expression above,
                     // so skip it here.
                     if (i !== 0) {
@@ -1761,7 +1768,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             this._createAssignmentTargetFlowNodes(node.target, /* walkTargets */ false, /* unbound */ false);
             if (symbol) {
                 const declaration = {
-                    type: 1 /* Variable */,
+                    type: 1 /* DeclarationType.Variable */,
                     node: node.target,
                     isConstant: (0, symbolNameUtils_1.isConstantName)(node.target.value),
                     inferredTypeSource: node,
@@ -1796,7 +1803,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             const entry = this._activeTypeParams.get(typeParamNode.name.value);
             if (entry) {
                 const decls = entry.getDeclarations();
-                (0, debug_1.assert)(decls && decls.length === 1 && decls[0].type === 3 /* TypeParameter */);
+                (0, debug_1.assert)(decls && decls.length === 1 && decls[0].type === 3 /* DeclarationType.TypeParameter */);
                 if (decls[0].node === typeParamNode) {
                     this._activeTypeParams.delete(typeParamNode.name.value);
                 }
@@ -1807,13 +1814,13 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         // We may not be able to use the current scope if it's a class scope.
         // Walk up until we find a non-class scope instead.
         let parentScope = this._currentScope;
-        while (parentScope.type === 2 /* Class */) {
+        while (parentScope.type === 2 /* ScopeType.Class */) {
             parentScope = parentScope.parent;
         }
         return parentScope;
     }
     _addSlotsToCurrentScope(slotNameNodes) {
-        (0, debug_1.assert)(this._currentScope.type === 2 /* Class */);
+        (0, debug_1.assert)(this._currentScope.type === 2 /* ScopeType.Class */);
         let slotsContainsDict = false;
         for (const slotNameNode of slotNameNodes) {
             const slotName = slotNameNode.strings[0].value;
@@ -1823,14 +1830,14 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             }
             let symbol = this._currentScope.lookUpSymbol(slotName);
             if (!symbol) {
-                symbol = this._currentScope.addSymbol(slotName, 1 /* InitiallyUnbound */ | 4 /* ClassMember */);
+                symbol = this._currentScope.addSymbol(slotName, 1 /* SymbolFlags.InitiallyUnbound */ | 4 /* SymbolFlags.ClassMember */);
                 const honorPrivateNaming = this._fileInfo.diagnosticRuleSet.reportPrivateUsage !== 'none';
                 if ((0, symbolNameUtils_1.isPrivateOrProtectedName)(slotName) && honorPrivateNaming) {
                     symbol.setIsPrivateMember();
                 }
             }
             const declaration = {
-                type: 1 /* Variable */,
+                type: 1 /* DeclarationType.Variable */,
                 node: slotNameNode,
                 isConstant: (0, symbolNameUtils_1.isConstantName)(slotName),
                 isDefinedBySlots: true,
@@ -1850,10 +1857,10 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         let prevNode;
         let prevPrevNode;
         while (curNode) {
-            if (curNode.nodeType === 32 /* ListComprehension */) {
+            if (curNode.nodeType === 32 /* ParseNodeType.ListComprehension */) {
                 if (ignoreOutermostIterable && curNode.forIfNodes.length > 0) {
                     const outermostCompr = curNode.forIfNodes[0];
-                    if (prevNode === outermostCompr && outermostCompr.nodeType === 33 /* ListComprehensionFor */) {
+                    if (prevNode === outermostCompr && outermostCompr.nodeType === 33 /* ParseNodeType.ListComprehensionFor */) {
                         if (prevPrevNode === outermostCompr.iterableExpression) {
                             return false;
                         }
@@ -1872,7 +1879,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         this._createAssignmentTargetFlowNodes(target, /* walkTargets */ false, /* unbound */ false);
         if (symbol) {
             const declaration = {
-                type: 1 /* Variable */,
+                type: 1 /* DeclarationType.Variable */,
                 node: target,
                 isConstant: (0, symbolNameUtils_1.isConstantName)(target.value),
                 inferredTypeSource: target.parent,
@@ -1899,7 +1906,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             return undefined;
         }
         // There should be only one declaration for the variable.
-        const aliasDecl = varSymbol.getDeclarations().find((decl) => decl.type === 8 /* Alias */);
+        const aliasDecl = varSymbol.getDeclarations().find((decl) => decl.type === 8 /* DeclarationType.Alias */);
         const resolvedPath = (aliasDecl === null || aliasDecl === void 0 ? void 0 : aliasDecl.path) && aliasDecl.loadSymbolsFromPath
             ? aliasDecl.path
             : ((_a = aliasDecl === null || aliasDecl === void 0 ? void 0 : aliasDecl.submoduleFallback) === null || _a === void 0 ? void 0 : _a.path) && aliasDecl.submoduleFallback.loadSymbolsFromPath
@@ -1939,7 +1946,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         // python module loader.
         const existingDecl = symbol
             .getDeclarations()
-            .find((decl) => decl.type === 8 /* Alias */ && decl.firstNamePart === firstNamePartValue);
+            .find((decl) => decl.type === 8 /* DeclarationType.Alias */ && decl.firstNamePart === firstNamePartValue);
         let newDecl;
         let pathOfLastSubmodule;
         if (importInfo && importInfo.isImportFound && !importInfo.isNativeLib && importInfo.resolvedPaths.length > 0) {
@@ -1954,7 +1961,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         }
         else if (isResolved) {
             newDecl = {
-                type: 8 /* Alias */,
+                type: 8 /* DeclarationType.Alias */,
                 node,
                 path: pathOfLastSubmodule,
                 loadSymbolsFromPath: false,
@@ -1970,7 +1977,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             // bogus path so it gets an unknown type (rather than an unbound type) at
             // analysis time.
             newDecl = {
-                type: 8 /* Alias */,
+                type: 8 /* DeclarationType.Alias */,
                 node,
                 path: pathOfLastSubmodule,
                 loadSymbolsFromPath: true,
@@ -2172,12 +2179,12 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     // positive or negative case).
     _bindNeverCondition(node, target, isPositiveTest) {
         const expressionList = [];
-        if (node.nodeType === 55 /* UnaryOperation */ && node.operator === 38 /* Not */) {
+        if (node.nodeType === 55 /* ParseNodeType.UnaryOperation */ && node.operator === 38 /* OperatorType.Not */) {
             this._bindNeverCondition(node.expression, target, !isPositiveTest);
         }
-        else if (node.nodeType === 7 /* BinaryOperation */ &&
-            (node.operator === 36 /* And */ || node.operator === 37 /* Or */)) {
-            let isAnd = node.operator === 36 /* And */;
+        else if (node.nodeType === 7 /* ParseNodeType.BinaryOperation */ &&
+            (node.operator === 36 /* OperatorType.And */ || node.operator === 37 /* OperatorType.Or */)) {
+            let isAnd = node.operator === 36 /* OperatorType.And */;
             if (isPositiveTest) {
                 isAnd = !isAnd;
             }
@@ -2214,7 +2221,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             // that is a name. This avoids complexities with composite expressions like
             // member access or index expressions.
             if (this._isNarrowingExpression(node, expressionList, /* neverNarrowingExpressions */ true)) {
-                const filteredExprList = expressionList.filter((expr) => expr.nodeType === 38 /* Name */);
+                const filteredExprList = expressionList.filter((expr) => expr.nodeType === 38 /* ParseNodeType.Name */);
                 if (filteredExprList.length > 0) {
                     this._currentFlowNode = this._createFlowConditional(isPositiveTest ? codeFlowTypes_1.FlowFlags.TrueNeverCondition : codeFlowTypes_1.FlowFlags.FalseNeverCondition, this._currentFlowNode, node);
                 }
@@ -2264,7 +2271,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             this._currentScopeCodeFlowExpressions.add(referenceKey);
         });
         // Select the first name expression.
-        const filteredExprList = expressionList.filter((expr) => expr.nodeType === 38 /* Name */);
+        const filteredExprList = expressionList.filter((expr) => expr.nodeType === 38 /* ParseNodeType.Name */);
         const conditionalFlowNode = {
             flags,
             id: this._getUniqueFlowNodeId(),
@@ -2278,11 +2285,11 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     // Indicates whether the expression is a NOT, AND or OR expression.
     _isLogicalExpression(expression) {
         switch (expression.nodeType) {
-            case 55 /* UnaryOperation */: {
-                return expression.operator === 38 /* Not */;
+            case 55 /* ParseNodeType.UnaryOperation */: {
+                return expression.operator === 38 /* OperatorType.Not */;
             }
-            case 7 /* BinaryOperation */: {
-                return expression.operator === 36 /* And */ || expression.operator === 37 /* Or */;
+            case 7 /* ParseNodeType.BinaryOperation */: {
+                return expression.operator === 36 /* OperatorType.And */ || expression.operator === 37 /* OperatorType.Or */;
             }
         }
         return false;
@@ -2297,13 +2304,13 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     // these) or something more complex (binary operator, call, etc.).
     _isNarrowingExpression(expression, expressionList, filterForNeverNarrowing = false, isComplexExpression = false) {
         switch (expression.nodeType) {
-            case 38 /* Name */:
-            case 35 /* MemberAccess */:
-            case 24 /* Index */: {
+            case 38 /* ParseNodeType.Name */:
+            case 35 /* ParseNodeType.MemberAccess */:
+            case 24 /* ParseNodeType.Index */: {
                 if (filterForNeverNarrowing) {
                     // Never narrowing doesn't support member access or index
                     // expressions.
-                    if (expression.nodeType !== 38 /* Name */) {
+                    if (expression.nodeType !== 38 /* ParseNodeType.Name */) {
                         return false;
                     }
                     // Never narrowing doesn't support simple names (falsy
@@ -2319,7 +2326,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                         // If the expression is a member access expression, add its
                         // leftExpression to the expression list because that expression
                         // can be narrowed based on the attribute type.
-                        if (expression.nodeType === 35 /* MemberAccess */) {
+                        if (expression.nodeType === 35 /* ParseNodeType.MemberAccess */) {
                             if ((0, codeFlowTypes_1.isCodeFlowSupportedForReference)(expression.leftExpression)) {
                                 expressionList.push(expression.leftExpression);
                             }
@@ -2327,10 +2334,10 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                         // If the expression is an index expression with a supported
                         // subscript, add its baseExpression to the expression list because
                         // that expression can be narrowed.
-                        if (expression.nodeType === 24 /* Index */ &&
+                        if (expression.nodeType === 24 /* ParseNodeType.Index */ &&
                             expression.items.length === 1 &&
                             !expression.trailingComma &&
-                            expression.items[0].argumentCategory === 0 /* Simple */) {
+                            expression.items[0].argumentCategory === 0 /* ArgumentCategory.Simple */) {
                             if ((0, codeFlowTypes_1.isCodeFlowSupportedForReference)(expression.baseExpression)) {
                                 expressionList.push(expression.baseExpression);
                             }
@@ -2340,30 +2347,30 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 }
                 return false;
             }
-            case 4 /* AssignmentExpression */: {
+            case 4 /* ParseNodeType.AssignmentExpression */: {
                 expressionList.push(expression.name);
                 this._isNarrowingExpression(expression.rightExpression, expressionList, filterForNeverNarrowing, 
                 /* isComplexExpression */ true);
                 return true;
             }
-            case 7 /* BinaryOperation */: {
-                const isOrIsNotOperator = expression.operator === 39 /* Is */ || expression.operator === 40 /* IsNot */;
-                const equalsOrNotEqualsOperator = expression.operator === 12 /* Equals */ || expression.operator === 28 /* NotEquals */;
+            case 7 /* ParseNodeType.BinaryOperation */: {
+                const isOrIsNotOperator = expression.operator === 39 /* OperatorType.Is */ || expression.operator === 40 /* OperatorType.IsNot */;
+                const equalsOrNotEqualsOperator = expression.operator === 12 /* OperatorType.Equals */ || expression.operator === 28 /* OperatorType.NotEquals */;
                 if (isOrIsNotOperator || equalsOrNotEqualsOperator) {
                     // Look for "X is None", "X is not None", "X == None", "X != None".
                     // These are commonly-used patterns used in control flow.
-                    if (expression.rightExpression.nodeType === 11 /* Constant */ &&
-                        expression.rightExpression.constType === 26 /* None */) {
+                    if (expression.rightExpression.nodeType === 11 /* ParseNodeType.Constant */ &&
+                        expression.rightExpression.constType === 26 /* KeywordType.None */) {
                         return this._isNarrowingExpression(expression.leftExpression, expressionList, filterForNeverNarrowing, 
                         /* isComplexExpression */ true);
                     }
                     // Look for "type(X) is Y" or "type(X) is not Y".
                     if (isOrIsNotOperator &&
-                        expression.leftExpression.nodeType === 9 /* Call */ &&
-                        expression.leftExpression.leftExpression.nodeType === 38 /* Name */ &&
+                        expression.leftExpression.nodeType === 9 /* ParseNodeType.Call */ &&
+                        expression.leftExpression.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
                         expression.leftExpression.leftExpression.value === 'type' &&
                         expression.leftExpression.arguments.length === 1 &&
-                        expression.leftExpression.arguments[0].argumentCategory === 0 /* Simple */) {
+                        expression.leftExpression.arguments[0].argumentCategory === 0 /* ArgumentCategory.Simple */) {
                         return this._isNarrowingExpression(expression.leftExpression.arguments[0].valueExpression, expressionList, filterForNeverNarrowing, 
                         /* isComplexExpression */ true);
                     }
@@ -2374,38 +2381,38 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                     return isLeftNarrowing;
                 }
                 // Look for "<string> in Y" or "<string> not in Y".
-                if (expression.operator === 41 /* In */ || expression.operator === 42 /* NotIn */) {
-                    if (expression.leftExpression.nodeType === 48 /* StringList */ &&
+                if (expression.operator === 41 /* OperatorType.In */ || expression.operator === 42 /* OperatorType.NotIn */) {
+                    if (expression.leftExpression.nodeType === 48 /* ParseNodeType.StringList */ &&
                         this._isNarrowingExpression(expression.rightExpression, expressionList, filterForNeverNarrowing, 
                         /* isComplexExpression */ true)) {
                         return true;
                     }
                 }
                 // Look for "X in Y" or "X not in Y".
-                if (expression.operator === 41 /* In */ || expression.operator === 42 /* NotIn */) {
+                if (expression.operator === 41 /* OperatorType.In */ || expression.operator === 42 /* OperatorType.NotIn */) {
                     return this._isNarrowingExpression(expression.leftExpression, expressionList, filterForNeverNarrowing, 
                     /* isComplexExpression */ true);
                 }
                 return false;
             }
-            case 55 /* UnaryOperation */: {
-                return (expression.operator === 38 /* Not */ &&
+            case 55 /* ParseNodeType.UnaryOperation */: {
+                return (expression.operator === 38 /* OperatorType.Not */ &&
                     this._isNarrowingExpression(expression.expression, expressionList, filterForNeverNarrowing, 
                     /* isComplexExpression */ false));
             }
-            case 5 /* AugmentedAssignment */: {
+            case 5 /* ParseNodeType.AugmentedAssignment */: {
                 return this._isNarrowingExpression(expression.rightExpression, expressionList, filterForNeverNarrowing, 
                 /* isComplexExpression */ true);
             }
-            case 9 /* Call */: {
-                if (expression.leftExpression.nodeType === 38 /* Name */ &&
+            case 9 /* ParseNodeType.Call */: {
+                if (expression.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
                     (expression.leftExpression.value === 'isinstance' ||
                         expression.leftExpression.value === 'issubclass') &&
                     expression.arguments.length === 2) {
                     return this._isNarrowingExpression(expression.arguments[0].valueExpression, expressionList, filterForNeverNarrowing, 
                     /* isComplexExpression */ true);
                 }
-                if (expression.leftExpression.nodeType === 38 /* Name */ &&
+                if (expression.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
                     expression.leftExpression.value === 'callable' &&
                     expression.arguments.length === 1) {
                     return this._isNarrowingExpression(expression.arguments[0].valueExpression, expressionList, filterForNeverNarrowing, 
@@ -2427,42 +2434,42 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     }
     _createAssignmentTargetFlowNodes(target, walkTargets, unbound) {
         switch (target.nodeType) {
-            case 38 /* Name */:
-            case 35 /* MemberAccess */: {
+            case 38 /* ParseNodeType.Name */:
+            case 35 /* ParseNodeType.MemberAccess */: {
                 this._createFlowAssignment(target, unbound);
                 if (walkTargets) {
                     this.walk(target);
                 }
                 break;
             }
-            case 24 /* Index */: {
+            case 24 /* ParseNodeType.Index */: {
                 this._createFlowAssignment(target, unbound);
                 if (walkTargets) {
                     this.walk(target);
                 }
                 break;
             }
-            case 52 /* Tuple */: {
+            case 52 /* ParseNodeType.Tuple */: {
                 target.expressions.forEach((expr) => {
                     this._createAssignmentTargetFlowNodes(expr, walkTargets, unbound);
                 });
                 break;
             }
-            case 54 /* TypeAnnotation */: {
+            case 54 /* ParseNodeType.TypeAnnotation */: {
                 this._createAssignmentTargetFlowNodes(target.valueExpression, /* walkTargets */ false, unbound);
                 if (walkTargets) {
                     this.walk(target);
                 }
                 break;
             }
-            case 56 /* Unpack */: {
+            case 56 /* ParseNodeType.Unpack */: {
                 this._createAssignmentTargetFlowNodes(target.expression, /* walkTargets */ false, unbound);
                 if (walkTargets) {
                     this.walk(target);
                 }
                 break;
             }
-            case 31 /* List */: {
+            case 31 /* ParseNodeType.List */: {
                 target.entries.forEach((entry) => {
                     this._createAssignmentTargetFlowNodes(entry, walkTargets, unbound);
                 });
@@ -2501,7 +2508,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     }
     _createFlowAssignment(node, unbound = false) {
         let targetSymbolId = symbol_1.indeterminateSymbolId;
-        if (node.nodeType === 38 /* Name */) {
+        if (node.nodeType === 38 /* ParseNodeType.Name */) {
             const symbolWithScope = this._currentScope.lookUpSymbolRecursive(node.value);
             (0, debug_1.assert)(symbolWithScope !== undefined);
             targetSymbolId = symbolWithScope.symbol.id;
@@ -2522,7 +2529,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             }
             // Assume that an assignment to a member access expression
             // can potentially generate an exception.
-            if (node.nodeType === 35 /* MemberAccess */) {
+            if (node.nodeType === 35 /* ParseNodeType.MemberAccess */) {
                 this._addExceptTargets(flowNode);
             }
             this._currentFlowNode = flowNode;
@@ -2611,7 +2618,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         // Is this name already bound to a scope other than the local one?
         const bindingType = this._currentScope.getBindingType(name);
         if (bindingType !== undefined) {
-            const scopeToUse = bindingType === 0 /* Nonlocal */
+            const scopeToUse = bindingType === 0 /* NameBindingType.Nonlocal */
                 ? this._currentScope.parent
                 : this._currentScope.getGlobalScope().scope;
             const symbolWithScope = scopeToUse.lookUpSymbolRecursive(name);
@@ -2623,15 +2630,15 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             // Don't overwrite an existing symbol.
             let symbol = scope.lookUpSymbol(name);
             if (!symbol) {
-                symbol = scope.addSymbol(name, 1 /* InitiallyUnbound */ | 4 /* ClassMember */);
-                if (this._currentScope.type === 3 /* Module */ || this._currentScope.type === 4 /* Builtin */) {
+                symbol = scope.addSymbol(name, 1 /* SymbolFlags.InitiallyUnbound */ | 4 /* SymbolFlags.ClassMember */);
+                if (this._currentScope.type === 3 /* ScopeType.Module */ || this._currentScope.type === 4 /* ScopeType.Builtin */) {
                     if ((0, symbolNameUtils_1.isPrivateOrProtectedName)(name)) {
                         if ((0, symbolNameUtils_1.isPrivateName)(name)) {
                             // Private names are obscured, so they are always externally hidden.
                             symbol.setIsExternallyHidden();
                         }
                         else if (this._fileInfo.isStubFile || this._fileInfo.isInPyTypedPackage) {
-                            if (this._currentScope.type === 4 /* Builtin */) {
+                            if (this._currentScope.type === 4 /* ScopeType.Builtin */) {
                                 // Don't include private-named symbols in the builtin scope.
                                 symbol.setIsExternallyHidden();
                             }
@@ -2654,27 +2661,27 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     }
     _bindPossibleTupleNamedTarget(target, addedSymbols) {
         switch (target.nodeType) {
-            case 38 /* Name */: {
+            case 38 /* ParseNodeType.Name */: {
                 this._bindNameToScope(this._currentScope, target, addedSymbols);
                 break;
             }
-            case 52 /* Tuple */: {
+            case 52 /* ParseNodeType.Tuple */: {
                 target.expressions.forEach((expr) => {
                     this._bindPossibleTupleNamedTarget(expr, addedSymbols);
                 });
                 break;
             }
-            case 31 /* List */: {
+            case 31 /* ParseNodeType.List */: {
                 target.entries.forEach((expr) => {
                     this._bindPossibleTupleNamedTarget(expr, addedSymbols);
                 });
                 break;
             }
-            case 54 /* TypeAnnotation */: {
+            case 54 /* ParseNodeType.TypeAnnotation */: {
                 this._bindPossibleTupleNamedTarget(target.valueExpression, addedSymbols);
                 break;
             }
-            case 56 /* Unpack */: {
+            case 56 /* ParseNodeType.Unpack */: {
                 this._bindPossibleTupleNamedTarget(target.expression, addedSymbols);
                 break;
             }
@@ -2684,7 +2691,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         const symbol = this._addSymbolToCurrentScope(nameValue, /* isInitiallyUnbound */ false);
         if (symbol) {
             symbol.addDeclaration({
-                type: 0 /* Intrinsic */,
+                type: 0 /* DeclarationType.Intrinsic */,
                 node,
                 intrinsicType: type,
                 path: this._fileInfo.filePath,
@@ -2699,15 +2706,15 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     _addSymbolToCurrentScope(nameValue, isInitiallyUnbound) {
         let symbol = this._currentScope.lookUpSymbol(nameValue);
         if (!symbol) {
-            let symbolFlags = 0 /* None */;
+            let symbolFlags = 0 /* SymbolFlags.None */;
             if (isInitiallyUnbound) {
-                symbolFlags |= 1 /* InitiallyUnbound */;
+                symbolFlags |= 1 /* SymbolFlags.InitiallyUnbound */;
             }
-            if (this._currentScope.type === 2 /* Class */) {
-                symbolFlags |= 4 /* ClassMember */;
+            if (this._currentScope.type === 2 /* ScopeType.Class */) {
+                symbolFlags |= 4 /* SymbolFlags.ClassMember */;
             }
             if (this._fileInfo.isStubFile && (0, symbolNameUtils_1.isPrivateOrProtectedName)(nameValue)) {
-                symbolFlags |= 2 /* ExternallyHidden */;
+                symbolFlags |= 2 /* SymbolFlags.ExternallyHidden */;
             }
             // Add the symbol. Assume that symbols with a default type source ID
             // are "implicit" symbols added to the scope. These are not initially unbound.
@@ -2720,7 +2727,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         const newScope = new scope_1.Scope(scopeType, parentScope);
         this._currentScope = newScope;
         // If this scope is an execution scope, allocate a new reference map.
-        const isExecutionScope = scopeType === 4 /* Builtin */ || scopeType === 3 /* Module */ || scopeType === 1 /* Function */;
+        const isExecutionScope = scopeType === 4 /* ScopeType.Builtin */ || scopeType === 3 /* ScopeType.Module */ || scopeType === 1 /* ScopeType.Function */;
         const prevExpressions = this._currentScopeCodeFlowExpressions;
         if (isExecutionScope) {
             this._currentScopeCodeFlowExpressions = new Set();
@@ -2732,12 +2739,12 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     }
     _addInferredTypeAssignmentForVariable(target, source, isPossibleTypeAlias = false) {
         switch (target.nodeType) {
-            case 38 /* Name */: {
+            case 38 /* ParseNodeType.Name */: {
                 const name = target;
                 const symbolWithScope = this._currentScope.lookUpSymbolRecursive(name.value);
                 if (symbolWithScope && symbolWithScope.symbol) {
                     const declaration = {
-                        type: 1 /* Variable */,
+                        type: 1 /* DeclarationType.Variable */,
                         node: target,
                         isConstant: (0, symbolNameUtils_1.isConstantName)(target.value),
                         inferredTypeSource: source,
@@ -2753,13 +2760,13 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 }
                 break;
             }
-            case 35 /* MemberAccess */: {
+            case 35 /* ParseNodeType.MemberAccess */: {
                 const memberAccessInfo = this._getMemberAccessInfo(target);
                 if (memberAccessInfo) {
                     const name = target.memberName;
                     let symbol = memberAccessInfo.classScope.lookUpSymbol(name.value);
                     if (!symbol) {
-                        symbol = memberAccessInfo.classScope.addSymbol(name.value, 1 /* InitiallyUnbound */);
+                        symbol = memberAccessInfo.classScope.addSymbol(name.value, 1 /* SymbolFlags.InitiallyUnbound */);
                         const honorPrivateNaming = this._fileInfo.diagnosticRuleSet.reportPrivateUsage !== 'none';
                         if ((0, symbolNameUtils_1.isPrivateOrProtectedName)(name.value) && honorPrivateNaming) {
                             symbol.setIsPrivateMember();
@@ -2773,7 +2780,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                         if (!symbol.isClassMember() ||
                             !symbol
                                 .getDeclarations()
-                                .some((decl) => decl.type === 5 /* Function */ && decl.isMethod)) {
+                                .some((decl) => decl.type === 5 /* DeclarationType.Function */ && decl.isMethod)) {
                             symbol.setIsInstanceMember();
                         }
                     }
@@ -2781,7 +2788,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                         symbol.setIsClassMember();
                     }
                     const declaration = {
-                        type: 1 /* Variable */,
+                        type: 1 /* DeclarationType.Variable */,
                         node: target.memberName,
                         isConstant: (0, symbolNameUtils_1.isConstantName)(name.value),
                         inferredTypeSource: source,
@@ -2796,21 +2803,21 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 }
                 break;
             }
-            case 52 /* Tuple */: {
+            case 52 /* ParseNodeType.Tuple */: {
                 target.expressions.forEach((expr) => {
                     this._addInferredTypeAssignmentForVariable(expr, source);
                 });
                 break;
             }
-            case 54 /* TypeAnnotation */: {
+            case 54 /* ParseNodeType.TypeAnnotation */: {
                 this._addInferredTypeAssignmentForVariable(target.valueExpression, source);
                 break;
             }
-            case 56 /* Unpack */: {
+            case 56 /* ParseNodeType.Unpack */: {
                 this._addInferredTypeAssignmentForVariable(target.expression, source);
                 break;
             }
-            case 31 /* List */: {
+            case 31 /* ParseNodeType.List */: {
                 target.entries.forEach((entry) => {
                     this._addInferredTypeAssignmentForVariable(entry, source);
                 });
@@ -2826,7 +2833,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         var _a, _b, _c;
         let declarationHandled = false;
         switch (target.nodeType) {
-            case 38 /* Name */: {
+            case 38 /* ParseNodeType.Name */: {
                 const name = target;
                 const symbolWithScope = this._currentScope.lookUpSymbolRecursive(name.value);
                 if (symbolWithScope && symbolWithScope.symbol) {
@@ -2848,10 +2855,10 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                     // body should also be considered a ClassVar.
                     if (finalInfo.isFinal) {
                         const containingClass = ParseTreeUtils.getEnclosingClassOrFunction(target);
-                        if (containingClass && containingClass.nodeType === 10 /* Class */) {
+                        if (containingClass && containingClass.nodeType === 10 /* ParseNodeType.Class */) {
                             // Make sure it's part of an assignment.
-                            if (((_a = target.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 3 /* Assignment */ ||
-                                ((_c = (_b = target.parent) === null || _b === void 0 ? void 0 : _b.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 3 /* Assignment */) {
+                            if (((_a = target.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 3 /* ParseNodeType.Assignment */ ||
+                                ((_c = (_b = target.parent) === null || _b === void 0 ? void 0 : _b.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 3 /* ParseNodeType.Assignment */) {
                                 classVarInfo = {
                                     isClassVar: true,
                                     classVarTypeNode: undefined,
@@ -2860,7 +2867,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                         }
                     }
                     const declaration = {
-                        type: 1 /* Variable */,
+                        type: 1 /* DeclarationType.Variable */,
                         node: target,
                         isConstant: (0, symbolNameUtils_1.isConstantName)(name.value),
                         isFinal: finalInfo.isFinal,
@@ -2880,14 +2887,14 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                         symbolWithScope.symbol.setIsInstanceMember();
                     }
                     // Look for an 'InitVar' either by itself or wrapped in an 'Annotated'.
-                    if (typeAnnotation.nodeType === 24 /* Index */) {
+                    if (typeAnnotation.nodeType === 24 /* ParseNodeType.Index */) {
                         if (this._isDataclassesAnnotation(typeAnnotation.baseExpression, 'InitVar')) {
                             symbolWithScope.symbol.setIsInitVar();
                         }
                         else if (this._isTypingAnnotation(typeAnnotation.baseExpression, 'Annotated') &&
                             typeAnnotation.items.length > 0) {
                             const item0Expr = typeAnnotation.items[0].valueExpression;
-                            if (item0Expr.nodeType === 24 /* Index */ &&
+                            if (item0Expr.nodeType === 24 /* ParseNodeType.Index */ &&
                                 this._isDataclassesAnnotation(item0Expr.baseExpression, 'InitVar')) {
                                 symbolWithScope.symbol.setIsInitVar();
                             }
@@ -2897,7 +2904,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 declarationHandled = true;
                 break;
             }
-            case 35 /* MemberAccess */: {
+            case 35 /* ParseNodeType.MemberAccess */: {
                 // We need to determine whether this expression is declaring a class or
                 // instance variable. This is difficult because python doesn't provide
                 // a keyword for accessing "this". Instead, it uses naming conventions
@@ -2910,7 +2917,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                     const name = target.memberName;
                     let symbol = memberAccessInfo.classScope.lookUpSymbol(name.value);
                     if (!symbol) {
-                        symbol = memberAccessInfo.classScope.addSymbol(name.value, 1 /* InitiallyUnbound */);
+                        symbol = memberAccessInfo.classScope.addSymbol(name.value, 1 /* SymbolFlags.InitiallyUnbound */);
                         const honorPrivateNaming = this._fileInfo.diagnosticRuleSet.reportPrivateUsage !== 'none';
                         if ((0, symbolNameUtils_1.isPrivateOrProtectedName)(name.value) && honorPrivateNaming) {
                             symbol.setIsPrivateMember();
@@ -2924,7 +2931,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                     }
                     const finalInfo = this._isAnnotationFinal(typeAnnotation);
                     const declaration = {
-                        type: 1 /* Variable */,
+                        type: 1 /* DeclarationType.Variable */,
                         node: target.memberName,
                         isConstant: (0, symbolNameUtils_1.isConstantName)(name.value),
                         isDefinedByMemberAccess: true,
@@ -2959,17 +2966,17 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     _isKnownAnnotation(typeAnnotation, name, importAliases, symbolAliases) {
         let annotationNode = typeAnnotation;
         // Is this a quoted annotation?
-        if (annotationNode.nodeType === 48 /* StringList */ && annotationNode.typeAnnotation) {
+        if (annotationNode.nodeType === 48 /* ParseNodeType.StringList */ && annotationNode.typeAnnotation) {
             annotationNode = annotationNode.typeAnnotation;
         }
-        if (annotationNode.nodeType === 38 /* Name */) {
+        if (annotationNode.nodeType === 38 /* ParseNodeType.Name */) {
             const alias = symbolAliases.get(annotationNode.value);
             if (alias === name) {
                 return true;
             }
         }
-        else if (annotationNode.nodeType === 35 /* MemberAccess */) {
-            if (annotationNode.leftExpression.nodeType === 38 /* Name */ &&
+        else if (annotationNode.nodeType === 35 /* ParseNodeType.MemberAccess */) {
+            if (annotationNode.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
                 annotationNode.memberName.value === name) {
                 const baseName = annotationNode.leftExpression.value;
                 return importAliases.some((alias) => alias === baseName);
@@ -3000,11 +3007,11 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             if (this._isTypingAnnotation(typeAnnotation, 'Final')) {
                 isFinal = true;
             }
-            else if (typeAnnotation.nodeType === 24 /* Index */ && typeAnnotation.items.length === 1) {
+            else if (typeAnnotation.nodeType === 24 /* ParseNodeType.Index */ && typeAnnotation.items.length === 1) {
                 // Recursively call to see if the base expression is "Final".
                 const finalInfo = this._isAnnotationFinal(typeAnnotation.baseExpression);
                 if (finalInfo.isFinal &&
-                    typeAnnotation.items[0].argumentCategory === 0 /* Simple */ &&
+                    typeAnnotation.items[0].argumentCategory === 0 /* ArgumentCategory.Simple */ &&
                     !typeAnnotation.items[0].name &&
                     !typeAnnotation.trailingComma) {
                     isFinal = true;
@@ -3022,10 +3029,10 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         let classVarTypeNode;
         while (typeAnnotation) {
             // Is this a quoted annotation?
-            if (typeAnnotation.nodeType === 48 /* StringList */ && typeAnnotation.typeAnnotation) {
+            if (typeAnnotation.nodeType === 48 /* ParseNodeType.StringList */ && typeAnnotation.typeAnnotation) {
                 typeAnnotation = typeAnnotation.typeAnnotation;
             }
-            if (typeAnnotation.nodeType === 24 /* Index */ &&
+            if (typeAnnotation.nodeType === 24 /* ParseNodeType.Index */ &&
                 typeAnnotation.items.length > 0 &&
                 this._isTypingAnnotation(typeAnnotation.baseExpression, 'Annotated')) {
                 typeAnnotation = typeAnnotation.items[0].valueExpression;
@@ -3034,11 +3041,11 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 isClassVar = true;
                 break;
             }
-            else if (typeAnnotation.nodeType === 24 /* Index */ && typeAnnotation.items.length === 1) {
+            else if (typeAnnotation.nodeType === 24 /* ParseNodeType.Index */ && typeAnnotation.items.length === 1) {
                 // Recursively call to see if the base expression is "ClassVar".
                 const finalInfo = this._isAnnotationClassVar(typeAnnotation.baseExpression);
                 if (finalInfo.isClassVar &&
-                    typeAnnotation.items[0].argumentCategory === 0 /* Simple */ &&
+                    typeAnnotation.items[0].argumentCategory === 0 /* ArgumentCategory.Simple */ &&
                     !typeAnnotation.items[0].name &&
                     !typeAnnotation.trailingComma) {
                     isClassVar = true;
@@ -3058,7 +3065,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     _getMemberAccessInfo(node) {
         // We handle only simple names on the left-hand side of the expression,
         // not calls, nested member accesses, index expressions, etc.
-        if (node.leftExpression.nodeType !== 38 /* Name */) {
+        if (node.leftExpression.nodeType !== 38 /* ParseNodeType.Name */) {
             return undefined;
         }
         const leftSymbolName = node.leftExpression.value;
@@ -3100,7 +3107,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 // a decorator that tells us otherwise.
                 isInstanceMember = true;
                 for (const decorator of methodNode.decorators) {
-                    if (decorator.expression.nodeType === 38 /* Name */) {
+                    if (decorator.expression.nodeType === 38 /* ParseNodeType.Name */) {
                         const decoratorName = decorator.expression.value;
                         if (decoratorName === 'staticmethod') {
                             // A static method doesn't have a "self" or "cls" parameter.
@@ -3152,16 +3159,16 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             return false;
         }
         let annotationNode;
-        if (node.nodeType === 54 /* TypeAnnotation */) {
+        if (node.nodeType === 54 /* ParseNodeType.TypeAnnotation */) {
             annotationNode = node;
         }
         else {
-            if (node.leftExpression.nodeType !== 54 /* TypeAnnotation */) {
+            if (node.leftExpression.nodeType !== 54 /* ParseNodeType.TypeAnnotation */) {
                 return false;
             }
             annotationNode = node.leftExpression;
         }
-        if (annotationNode.valueExpression.nodeType !== 38 /* Name */) {
+        if (annotationNode.valueExpression.nodeType !== 38 /* ParseNodeType.Name */) {
             return false;
         }
         const assignedNameNode = annotationNode.valueExpression;
@@ -3195,7 +3202,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         const symbol = this._bindNameToScope(this._currentScope, annotationNode.valueExpression);
         if (symbol) {
             symbol.addDeclaration({
-                type: 7 /* SpecialBuiltInClass */,
+                type: 7 /* DeclarationType.SpecialBuiltInClass */,
                 node: annotationNode,
                 path: this._fileInfo.filePath,
                 range: (0, positionUtils_1.convertTextRangeToRange)(annotationNode, this._fileInfo.lines),
@@ -3233,7 +3240,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 this._addError(localize_1.Localizer.Diagnostic.yieldOutsideFunction(), node);
             }
         }
-        else if (functionNode.isAsync && node.nodeType === 61 /* YieldFrom */) {
+        else if (functionNode.isAsync && node.nodeType === 61 /* ParseNodeType.YieldFrom */) {
             // PEP 525 indicates that 'yield from' is not allowed in an
             // async function.
             this._addError(localize_1.Localizer.Diagnostic.yieldFromOutsideAsync(), node);
@@ -3337,7 +3344,7 @@ class DummyScopeGenerator extends parseTreeWalker_1.ParseTreeWalker {
         this._currentScope = currentScope;
     }
     visitClass(node) {
-        const newScope = this._createNewScope(2 /* Class */, () => {
+        const newScope = this._createNewScope(2 /* ScopeType.Class */, () => {
             this.walk(node.suite);
         });
         if (!AnalyzerNodeInfo.getScope(node)) {
@@ -3346,7 +3353,7 @@ class DummyScopeGenerator extends parseTreeWalker_1.ParseTreeWalker {
         return false;
     }
     visitFunction(node) {
-        const newScope = this._createNewScope(1 /* Function */, () => {
+        const newScope = this._createNewScope(1 /* ScopeType.Function */, () => {
             this.walk(node.suite);
         });
         if (!AnalyzerNodeInfo.getScope(node)) {