@zzzen/pyright-internal 1.2.0-dev.20240526 → 1.2.0-dev.20240602

package/dist/analyzer/parseTreeUtils.js

@@ -165,13 +165,13 @@ function printExpression(node, flags = 0 /* PrintExpressionFlags.None */) {
             // Some left-hand expressions must be parenthesized.
             if (node.leftExpression.nodeType !== 35 /* ParseNodeType.MemberAccess */ &&
                 node.leftExpression.nodeType !== 38 /* ParseNodeType.Name */ &&
-                node.leftExpression.nodeType !== 24 /* ParseNodeType.Index */ &&
+                node.leftExpression.nodeType !== 27 /* ParseNodeType.Index */ &&
                 node.leftExpression.nodeType !== 9 /* ParseNodeType.Call */) {
                 lhs = `(${lhs})`;
             }
             return lhs + '(' + node.arguments.map((arg) => printArgument(arg, flags)).join(', ') + ')';
         }
-        case 24 /* ParseNodeType.Index */: {
+        case 27 /* ParseNodeType.Index */: {
             return (printExpression(node.baseExpression, flags) +
                 '[' +
                 node.items.map((item) => printArgument(item, flags)).join(', ') +
@@ -250,7 +250,7 @@ function printExpression(node, flags = 0 /* PrintExpressionFlags.None */) {
             }
             return exprString;
         }
-        case 27 /* ParseNodeType.FormatString */: {
+        case 30 /* ParseNodeType.FormatString */: {
             let exprString = 'f';
             let escapedString = '';
             const itemsToPrint = [...node.middleTokens, ...node.fieldExpressions].sort((a, b) => a.start - b.start);
@@ -308,7 +308,7 @@ function printExpression(node, flags = 0 /* PrintExpressionFlags.None */) {
                 ' else ' +
                 printExpression(node.elseExpression, flags));
         }
-        case 31 /* ParseNodeType.List */: {
+        case 34 /* ParseNodeType.List */: {
             const expressions = node.entries.map((expr) => {
                 return printExpression(expr, flags);
             });
@@ -337,15 +337,15 @@ function printExpression(node, flags = 0 /* PrintExpressionFlags.None */) {
         case 61 /* ParseNodeType.YieldFrom */: {
             return 'yield from ' + printExpression(node.expression, flags);
         }
-        case 18 /* ParseNodeType.Ellipsis */: {
+        case 21 /* ParseNodeType.Ellipsis */: {
             return '...';
         }
-        case 32 /* ParseNodeType.ListComprehension */: {
+        case 11 /* ParseNodeType.Comprehension */: {
             let listStr = '<ListExpression>';
             if ((0, parseNodes_1.isExpressionNode)(node.expression)) {
                 listStr = printExpression(node.expression, flags);
             }
-            else if (node.expression.nodeType === 17 /* ParseNodeType.DictionaryKeyEntry */) {
+            else if (node.expression.nodeType === 20 /* ParseNodeType.DictionaryKeyEntry */) {
                 const keyStr = printExpression(node.expression.keyExpression, flags);
                 const valueStr = printExpression(node.expression.valueExpression, flags);
                 listStr = `${keyStr}: ${valueStr}`;
@@ -355,7 +355,7 @@ function printExpression(node, flags = 0 /* PrintExpressionFlags.None */) {
                     ' ' +
                     node.forIfNodes
                         .map((expr) => {
-                        if (expr.nodeType === 33 /* ParseNodeType.ListComprehensionFor */) {
+                        if (expr.nodeType === 12 /* ParseNodeType.ComprehensionFor */) {
                             return (`${expr.isAsync ? 'async ' : ''}for ` +
                                 printExpression(expr.targetExpression, flags) +
                                 ` in ${printExpression(expr.iterableExpression, flags)}`);
@@ -385,7 +385,7 @@ function printExpression(node, flags = 0 /* PrintExpressionFlags.None */) {
             }
             return result;
         }
-        case 30 /* ParseNodeType.Lambda */: {
+        case 33 /* ParseNodeType.Lambda */: {
             return ('lambda ' +
                 node.parameters
                     .map((param) => {
@@ -411,7 +411,7 @@ function printExpression(node, flags = 0 /* PrintExpressionFlags.None */) {
                 ': ' +
                 printExpression(node.expression, flags));
         }
-        case 11 /* ParseNodeType.Constant */: {
+        case 14 /* ParseNodeType.Constant */: {
             if (node.constType === 33 /* KeywordType.True */) {
                 return 'True';
             }
@@ -426,13 +426,13 @@ function printExpression(node, flags = 0 /* PrintExpressionFlags.None */) {
             }
             break;
         }
-        case 15 /* ParseNodeType.Dictionary */: {
+        case 18 /* ParseNodeType.Dictionary */: {
             const dictContents = `${node.entries.map((entry) => {
-                if (entry.nodeType === 17 /* ParseNodeType.DictionaryKeyEntry */) {
+                if (entry.nodeType === 20 /* ParseNodeType.DictionaryKeyEntry */) {
                     return (`${printExpression(entry.keyExpression, flags)}: ` +
                         `${printExpression(entry.valueExpression, flags)}`);
                 }
-                else if (entry.nodeType === 16 /* ParseNodeType.DictionaryExpandEntry */) {
+                else if (entry.nodeType === 19 /* ParseNodeType.DictionaryExpandEntry */) {
                     return `**${printExpression(entry.expandExpression, flags)}`;
                 }
                 else {
@@ -526,12 +526,12 @@ function getCallForName(node) {
 exports.getCallForName = getCallForName;
 function getDecoratorForName(node) {
     var _a, _b, _c;
-    if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 13 /* ParseNodeType.Decorator */ && node.parent.expression === node) {
+    if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 16 /* ParseNodeType.Decorator */ && node.parent.expression === node) {
         return node.parent;
     }
     if (((_b = node.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 35 /* ParseNodeType.MemberAccess */ &&
         node.parent.memberName === node &&
-        ((_c = node.parent.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 13 /* ParseNodeType.Decorator */ &&
+        ((_c = node.parent.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 16 /* ParseNodeType.Decorator */ &&
         node.parent.parent.expression === node.parent) {
         return node.parent.parent;
     }
@@ -558,7 +558,7 @@ function getEnclosingClass(node, stopAtFunction = false) {
         if (curNode.nodeType === 36 /* ParseNodeType.Module */) {
             return undefined;
         }
-        if (curNode.nodeType === 28 /* ParseNodeType.Function */) {
+        if (curNode.nodeType === 31 /* ParseNodeType.Function */) {
             if (stopAtFunction) {
                 return undefined;
             }
@@ -589,7 +589,7 @@ function getEnclosingClassOrModule(node, stopAtFunction = false) {
         if (curNode.nodeType === 36 /* ParseNodeType.Module */) {
             return curNode;
         }
-        if (curNode.nodeType === 28 /* ParseNodeType.Function */) {
+        if (curNode.nodeType === 31 /* ParseNodeType.Function */) {
             if (stopAtFunction) {
                 return undefined;
             }
@@ -603,7 +603,7 @@ function getEnclosingFunction(node) {
     let curNode = node.parent;
     let prevNode;
     while (curNode) {
-        if (curNode.nodeType === 28 /* ParseNodeType.Function */) {
+        if (curNode.nodeType === 31 /* ParseNodeType.Function */) {
             // Don't treat a decorator as being "enclosed" in the function.
             if (!curNode.decorators.some((decorator) => decorator === prevNode)) {
                 return curNode;
@@ -626,7 +626,7 @@ exports.getEnclosingFunction = getEnclosingFunction;
 function getEnclosingFunctionEvaluationScope(node) {
     let curNode = getEvaluationScopeNode(node).node;
     while (curNode) {
-        if (curNode.nodeType === 28 /* ParseNodeType.Function */) {
+        if (curNode.nodeType === 31 /* ParseNodeType.Function */) {
             return curNode;
         }
         if (curNode.nodeType === 10 /* ParseNodeType.Class */ || !curNode.parent) {
@@ -640,7 +640,7 @@ exports.getEnclosingFunctionEvaluationScope = getEnclosingFunctionEvaluationScop
 function getEnclosingLambda(node) {
     let curNode = node.parent;
     while (curNode) {
-        if (curNode.nodeType === 30 /* ParseNodeType.Lambda */) {
+        if (curNode.nodeType === 33 /* ParseNodeType.Lambda */) {
             return curNode;
         }
         if (curNode.nodeType === 50 /* ParseNodeType.Suite */) {
@@ -654,7 +654,7 @@ exports.getEnclosingLambda = getEnclosingLambda;
 function getEnclosingClassOrFunction(node) {
     let curNode = node.parent;
     while (curNode) {
-        if (curNode.nodeType === 28 /* ParseNodeType.Function */) {
+        if (curNode.nodeType === 31 /* ParseNodeType.Function */) {
             return curNode;
         }
         if (curNode.nodeType === 10 /* ParseNodeType.Class */) {
@@ -674,12 +674,12 @@ function getEnclosingSuiteOrModule(node, stopAtFunction = false, stopAtLambda =
         if (curNode.nodeType === 36 /* ParseNodeType.Module */) {
             return curNode;
         }
-        if (curNode.nodeType === 30 /* ParseNodeType.Lambda */) {
+        if (curNode.nodeType === 33 /* ParseNodeType.Lambda */) {
             if (stopAtLambda) {
                 return undefined;
             }
         }
-        if (curNode.nodeType === 28 /* ParseNodeType.Function */) {
+        if (curNode.nodeType === 31 /* ParseNodeType.Function */) {
             if (stopAtFunction) {
                 return undefined;
             }
@@ -693,18 +693,18 @@ function getEvaluationNodeForAssignmentExpression(node) {
     // PEP 572 indicates that the evaluation node for an assignment expression
     // target within a list comprehension is contained within a lambda,
     // function or module, but not a class.
-    let sawListComprehension = false;
+    let sawComprehension = false;
     let curNode = getEvaluationScopeNode(node).node;
     while (curNode !== undefined) {
         switch (curNode.nodeType) {
-            case 28 /* ParseNodeType.Function */:
-            case 30 /* ParseNodeType.Lambda */:
+            case 31 /* ParseNodeType.Function */:
+            case 33 /* ParseNodeType.Lambda */:
             case 36 /* ParseNodeType.Module */:
                 return curNode;
             case 10 /* ParseNodeType.Class */:
-                return sawListComprehension ? undefined : curNode;
-            case 32 /* ParseNodeType.ListComprehension */:
-                sawListComprehension = true;
+                return sawComprehension ? undefined : curNode;
+            case 11 /* ParseNodeType.Comprehension */:
+                sawComprehension = true;
                 curNode = getEvaluationScopeNode(curNode.parent).node;
                 break;
             default:
@@ -740,7 +740,7 @@ function getEvaluationScopeNode(node) {
             case 76 /* ParseNodeType.TypeParameterList */: {
                 return { node: curNode, useProxyScope: true };
             }
-            case 28 /* ParseNodeType.Function */: {
+            case 31 /* ParseNodeType.Function */: {
                 if (!prevNode) {
                     break;
                 }
@@ -775,7 +775,7 @@ function getEvaluationScopeNode(node) {
                 }
                 break;
             }
-            case 30 /* ParseNodeType.Lambda */: {
+            case 33 /* ParseNodeType.Lambda */: {
                 if (curNode.parameters.some((param) => param === prevNode)) {
                     if (isParamNameNode) {
                         if ((0, analyzerNodeInfo_1.getScope)(curNode) !== undefined) {
@@ -814,12 +814,12 @@ function getEvaluationScopeNode(node) {
                 }
                 break;
             }
-            case 32 /* ParseNodeType.ListComprehension */: {
+            case 11 /* ParseNodeType.Comprehension */: {
                 if ((0, analyzerNodeInfo_1.getScope)(curNode) !== undefined) {
                     // The iterable expression of the first subnode of a list comprehension
                     // is evaluated within the scope of its parent.
                     const isFirstIterableExpr = prevNode === curNode.forIfNodes[0] &&
-                        curNode.forIfNodes[0].nodeType === 33 /* ParseNodeType.ListComprehensionFor */ &&
+                        curNode.forIfNodes[0].nodeType === 12 /* ParseNodeType.ComprehensionFor */ &&
                         curNode.forIfNodes[0].iterableExpression === prevPrevNode;
                     if (!isFirstIterableExpr) {
                         return { node: curNode };
@@ -858,7 +858,7 @@ function getTypeVarScopeNode(node) {
     let curNode = node;
     while (curNode) {
         switch (curNode.nodeType) {
-            case 28 /* ParseNodeType.Function */: {
+            case 31 /* ParseNodeType.Function */: {
                 if (!curNode.decorators.some((decorator) => decorator === prevNode)) {
                     return curNode;
                 }
@@ -888,7 +888,7 @@ function getExecutionScopeNode(node) {
     // within the context of their containing module or function. Likewise, list
     // comprehensions are executed within their container.
     while (evaluationScope.nodeType === 10 /* ParseNodeType.Class */ ||
-        evaluationScope.nodeType === 32 /* ParseNodeType.ListComprehension */) {
+        evaluationScope.nodeType === 11 /* ParseNodeType.Comprehension */) {
         evaluationScope = getEvaluationScopeNode(evaluationScope.parent).node;
     }
     return evaluationScope;
@@ -995,7 +995,7 @@ function getParentAnnotationNode(node) {
     let curNode = node;
     let prevNode;
     while (curNode) {
-        if (curNode.nodeType === 28 /* ParseNodeType.Function */) {
+        if (curNode.nodeType === 31 /* ParseNodeType.Function */) {
             if (prevNode === curNode.returnTypeAnnotation) {
                 return prevNode;
             }
@@ -1041,7 +1041,7 @@ function isSuiteEmpty(node) {
     for (const statement of node.statements) {
         if (statement.nodeType === 47 /* ParseNodeType.StatementList */) {
             for (const substatement of statement.statements) {
-                if (substatement.nodeType === 18 /* ParseNodeType.Ellipsis */) {
+                if (substatement.nodeType === 21 /* ParseNodeType.Ellipsis */) {
                     // Allow an ellipsis
                     sawEllipsis = true;
                 }
@@ -1088,7 +1088,7 @@ function isMatchingExpression(reference, expression) {
         return (isMatchingExpression(reference.leftExpression, expression.leftExpression) &&
             reference.memberName.value === expression.memberName.value);
     }
-    else if (reference.nodeType === 24 /* ParseNodeType.Index */ && expression.nodeType === 24 /* ParseNodeType.Index */) {
+    else if (reference.nodeType === 27 /* ParseNodeType.Index */ && expression.nodeType === 27 /* ParseNodeType.Index */) {
         if (!isMatchingExpression(reference.baseExpression, expression.baseExpression)) {
             return false;
         }
@@ -1142,7 +1142,7 @@ function isPartialMatchingExpression(reference, expression) {
         return (isMatchingExpression(reference.leftExpression, expression) ||
             isPartialMatchingExpression(reference.leftExpression, expression));
     }
-    else if (reference.nodeType === 24 /* ParseNodeType.Index */) {
+    else if (reference.nodeType === 27 /* ParseNodeType.Index */) {
         return (isMatchingExpression(reference.baseExpression, expression) ||
             isPartialMatchingExpression(reference.baseExpression, expression));
     }
@@ -1156,8 +1156,8 @@ function isWithinDefaultParamInitializer(node) {
         if (curNode.nodeType === 41 /* ParseNodeType.Parameter */ && prevNode === curNode.defaultValue) {
             return true;
         }
-        if (curNode.nodeType === 30 /* ParseNodeType.Lambda */ ||
-            curNode.nodeType === 28 /* ParseNodeType.Function */ ||
+        if (curNode.nodeType === 33 /* ParseNodeType.Lambda */ ||
+            curNode.nodeType === 31 /* ParseNodeType.Function */ ||
             curNode.nodeType === 10 /* ParseNodeType.Class */ ||
             curNode.nodeType === 36 /* ParseNodeType.Module */) {
             return false;
@@ -1177,10 +1177,10 @@ function isWithinTypeAnnotation(node, requireQuotedAnnotation) {
             (prevNode === curNode.typeAnnotation || prevNode === curNode.typeAnnotationComment)) {
             return isQuoted || !requireQuotedAnnotation;
         }
-        if (curNode.nodeType === 28 /* ParseNodeType.Function */ && prevNode === curNode.returnTypeAnnotation) {
+        if (curNode.nodeType === 31 /* ParseNodeType.Function */ && prevNode === curNode.returnTypeAnnotation) {
             return isQuoted || !requireQuotedAnnotation;
         }
-        if (curNode.nodeType === 28 /* ParseNodeType.Function */ && prevNode === curNode.functionAnnotationComment) {
+        if (curNode.nodeType === 31 /* ParseNodeType.Function */ && prevNode === curNode.functionAnnotationComment) {
             // Type comments are always considered forward declarations even though
             // they're not "quoted".
             return true;
@@ -1196,8 +1196,8 @@ function isWithinTypeAnnotation(node, requireQuotedAnnotation) {
         if (curNode.nodeType === 48 /* ParseNodeType.StringList */ && prevNode === curNode.typeAnnotation) {
             isQuoted = true;
         }
-        if (curNode.nodeType === 30 /* ParseNodeType.Lambda */ ||
-            curNode.nodeType === 28 /* ParseNodeType.Function */ ||
+        if (curNode.nodeType === 33 /* ParseNodeType.Lambda */ ||
+            curNode.nodeType === 31 /* ParseNodeType.Function */ ||
             curNode.nodeType === 10 /* ParseNodeType.Class */ ||
             curNode.nodeType === 36 /* ParseNodeType.Module */) {
             return false;
@@ -1212,7 +1212,7 @@ function isWithinAnnotationComment(node) {
     let curNode = node;
     let prevNode;
     while (curNode) {
-        if (curNode.nodeType === 28 /* ParseNodeType.Function */ && prevNode === curNode.functionAnnotationComment) {
+        if (curNode.nodeType === 31 /* ParseNodeType.Function */ && prevNode === curNode.functionAnnotationComment) {
             // Type comments are always considered forward declarations even though
             // they're not "quoted".
             return true;
@@ -1222,8 +1222,8 @@ function isWithinAnnotationComment(node) {
             // they're not "quoted".
             return true;
         }
-        if (curNode.nodeType === 30 /* ParseNodeType.Lambda */ ||
-            curNode.nodeType === 28 /* ParseNodeType.Function */ ||
+        if (curNode.nodeType === 33 /* ParseNodeType.Lambda */ ||
+            curNode.nodeType === 31 /* ParseNodeType.Function */ ||
             curNode.nodeType === 10 /* ParseNodeType.Class */ ||
             curNode.nodeType === 36 /* ParseNodeType.Module */) {
             return false;
@@ -1238,7 +1238,7 @@ function isWithinLoop(node) {
     let curNode = node;
     while (curNode) {
         switch (curNode.nodeType) {
-            case 26 /* ParseNodeType.For */:
+            case 29 /* ParseNodeType.For */:
             case 57 /* ParseNodeType.While */: {
                 return true;
             }
@@ -1297,7 +1297,7 @@ function isDocString(statementList) {
         return false;
     }
     // Any f-strings invalidate the entire docstring.
-    if (strings.some((n) => n.nodeType === 27 /* ParseNodeType.FormatString */)) {
+    if (strings.some((n) => n.nodeType === 30 /* ParseNodeType.FormatString */)) {
         return false;
     }
     // It's up to the user to convert normalize/convert this as needed.
@@ -1404,7 +1404,7 @@ function getEnclosingParameter(node) {
         if (curNode.nodeType === 41 /* ParseNodeType.Parameter */) {
             return curNode;
         }
-        if (curNode.nodeType === 28 /* ParseNodeType.Function */) {
+        if (curNode.nodeType === 31 /* ParseNodeType.Function */) {
             return undefined;
         }
         curNode = curNode.parent;
@@ -1626,54 +1626,54 @@ function printParseNodeType(type) {
             return 'Call';
         case 10 /* ParseNodeType.Class */:
             return 'Class';
-        case 11 /* ParseNodeType.Constant */:
+        case 14 /* ParseNodeType.Constant */:
             return 'Constant';
-        case 12 /* ParseNodeType.Continue */:
+        case 15 /* ParseNodeType.Continue */:
             return 'Continue';
-        case 13 /* ParseNodeType.Decorator */:
+        case 16 /* ParseNodeType.Decorator */:
             return 'Decorator';
-        case 14 /* ParseNodeType.Del */:
+        case 17 /* ParseNodeType.Del */:
             return 'Del';
-        case 15 /* ParseNodeType.Dictionary */:
+        case 18 /* ParseNodeType.Dictionary */:
             return 'Dictionary';
-        case 16 /* ParseNodeType.DictionaryExpandEntry */:
+        case 19 /* ParseNodeType.DictionaryExpandEntry */:
             return 'DictionaryExpandEntry';
-        case 17 /* ParseNodeType.DictionaryKeyEntry */:
+        case 20 /* ParseNodeType.DictionaryKeyEntry */:
             return 'DictionaryKeyEntry';
-        case 18 /* ParseNodeType.Ellipsis */:
+        case 21 /* ParseNodeType.Ellipsis */:
             return 'Ellipsis';
-        case 19 /* ParseNodeType.If */:
+        case 22 /* ParseNodeType.If */:
             return 'If';
-        case 20 /* ParseNodeType.Import */:
+        case 23 /* ParseNodeType.Import */:
             return 'Import';
-        case 21 /* ParseNodeType.ImportAs */:
+        case 24 /* ParseNodeType.ImportAs */:
             return 'ImportAs';
-        case 22 /* ParseNodeType.ImportFrom */:
+        case 25 /* ParseNodeType.ImportFrom */:
             return 'ImportFrom';
-        case 23 /* ParseNodeType.ImportFromAs */:
+        case 26 /* ParseNodeType.ImportFromAs */:
             return 'ImportFromAs';
-        case 24 /* ParseNodeType.Index */:
+        case 27 /* ParseNodeType.Index */:
             return 'Index';
-        case 25 /* ParseNodeType.Except */:
+        case 28 /* ParseNodeType.Except */:
             return 'Except';
-        case 26 /* ParseNodeType.For */:
+        case 29 /* ParseNodeType.For */:
             return 'For';
-        case 27 /* ParseNodeType.FormatString */:
+        case 30 /* ParseNodeType.FormatString */:
             return 'FormatString';
-        case 28 /* ParseNodeType.Function */:
+        case 31 /* ParseNodeType.Function */:
             return 'Function';
-        case 29 /* ParseNodeType.Global */:
+        case 32 /* ParseNodeType.Global */:
             return 'Global';
-        case 30 /* ParseNodeType.Lambda */:
+        case 33 /* ParseNodeType.Lambda */:
             return 'Lambda';
-        case 31 /* ParseNodeType.List */:
+        case 34 /* ParseNodeType.List */:
             return 'List';
-        case 32 /* ParseNodeType.ListComprehension */:
-            return 'ListComprehension';
-        case 33 /* ParseNodeType.ListComprehensionFor */:
-            return 'ListComprehensionFor';
-        case 34 /* ParseNodeType.ListComprehensionIf */:
-            return 'ListComprehensionIf';
+        case 11 /* ParseNodeType.Comprehension */:
+            return 'Comprehension';
+        case 12 /* ParseNodeType.ComprehensionFor */:
+            return 'ComprehensionFor';
+        case 13 /* ParseNodeType.ComprehensionIf */:
+            return 'ComprehensionIf';
         case 35 /* ParseNodeType.MemberAccess */:
             return 'MemberAccess';
         case 36 /* ParseNodeType.Module */:
@@ -1778,17 +1778,17 @@ function isWriteAccess(node) {
             case 4 /* ParseNodeType.AssignmentExpression */: {
                 return prevNode === curNode.name;
             }
-            case 14 /* ParseNodeType.Del */: {
+            case 17 /* ParseNodeType.Del */: {
                 return true;
             }
-            case 26 /* ParseNodeType.For */: {
+            case 29 /* ParseNodeType.For */: {
                 return prevNode === curNode.targetExpression;
             }
-            case 21 /* ParseNodeType.ImportAs */: {
+            case 24 /* ParseNodeType.ImportAs */: {
                 return (prevNode === curNode.alias ||
                     (curNode.module.nameParts.length > 0 && prevNode === curNode.module.nameParts[0]));
             }
-            case 23 /* ParseNodeType.ImportFromAs */: {
+            case 26 /* ParseNodeType.ImportFromAs */: {
                 return prevNode === curNode.alias || (!curNode.alias && prevNode === curNode.name);
             }
             case 35 /* ParseNodeType.MemberAccess */: {
@@ -1797,13 +1797,13 @@ function isWriteAccess(node) {
                 }
                 break;
             }
-            case 25 /* ParseNodeType.Except */: {
+            case 28 /* ParseNodeType.Except */: {
                 return prevNode === curNode.name;
             }
             case 58 /* ParseNodeType.With */: {
                 return curNode.withItems.some((item) => item === prevNode);
             }
-            case 33 /* ParseNodeType.ListComprehensionFor */: {
+            case 12 /* ParseNodeType.ComprehensionFor */: {
                 return prevNode === curNode.targetExpression;
             }
             case 54 /* ParseNodeType.TypeAnnotation */: {
@@ -1812,7 +1812,7 @@ function isWriteAccess(node) {
                 }
                 break;
             }
-            case 28 /* ParseNodeType.Function */:
+            case 31 /* ParseNodeType.Function */:
             case 10 /* ParseNodeType.Class */:
             case 36 /* ParseNodeType.Module */: {
                 return false;
@@ -1846,7 +1846,7 @@ function isFunctionSuiteEmpty(node) {
         else if (statement.nodeType === 47 /* ParseNodeType.StatementList */) {
             statement.statements.forEach((subStatement) => {
                 // Allow docstrings, ellipsis, and pass statements.
-                if (subStatement.nodeType !== 18 /* ParseNodeType.Ellipsis */ &&
+                if (subStatement.nodeType !== 21 /* ParseNodeType.Ellipsis */ &&
                     subStatement.nodeType !== 48 /* ParseNodeType.StringList */ &&
                     subStatement.nodeType !== 42 /* ParseNodeType.Pass */) {
                     isEmpty = false;
@@ -1888,27 +1888,27 @@ function getTypeAnnotationForParameter(node, paramIndex) {
 exports.getTypeAnnotationForParameter = getTypeAnnotationForParameter;
 function isImportModuleName(node) {
     var _a, _b;
-    return ((_b = (_a = getFirstAncestorOrSelfOfKind(node, 37 /* ParseNodeType.ModuleName */)) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 21 /* ParseNodeType.ImportAs */;
+    return ((_b = (_a = getFirstAncestorOrSelfOfKind(node, 37 /* ParseNodeType.ModuleName */)) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 24 /* ParseNodeType.ImportAs */;
 }
 exports.isImportModuleName = isImportModuleName;
 function isImportAlias(node) {
     var _a;
-    return ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 21 /* ParseNodeType.ImportAs */ && node.parent.alias === node;
+    return ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 24 /* ParseNodeType.ImportAs */ && node.parent.alias === node;
 }
 exports.isImportAlias = isImportAlias;
 function isFromImportModuleName(node) {
     var _a, _b;
-    return ((_b = (_a = getFirstAncestorOrSelfOfKind(node, 37 /* ParseNodeType.ModuleName */)) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 22 /* ParseNodeType.ImportFrom */;
+    return ((_b = (_a = getFirstAncestorOrSelfOfKind(node, 37 /* ParseNodeType.ModuleName */)) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 25 /* ParseNodeType.ImportFrom */;
 }
 exports.isFromImportModuleName = isFromImportModuleName;
 function isFromImportName(node) {
     var _a;
-    return ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 23 /* ParseNodeType.ImportFromAs */ && node.parent.name === node;
+    return ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 26 /* ParseNodeType.ImportFromAs */ && node.parent.name === node;
 }
 exports.isFromImportName = isFromImportName;
 function isFromImportAlias(node) {
     var _a;
-    return ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 23 /* ParseNodeType.ImportFromAs */ && node.parent.alias === node;
+    return ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 26 /* ParseNodeType.ImportFromAs */ && node.parent.alias === node;
 }
 exports.isFromImportAlias = isFromImportAlias;
 function isLastNameOfModuleName(node) {
@@ -2120,7 +2120,7 @@ function isValidLocationForFutureImport(node) {
                 }
                 sawDocString = true;
             }
-            else if (simpleStatement.nodeType === 22 /* ParseNodeType.ImportFrom */) {
+            else if (simpleStatement.nodeType === 25 /* ParseNodeType.ImportFrom */) {
                 if (simpleStatement.module.leadingDots !== 0 ||
                     simpleStatement.module.nameParts.length !== 1 ||
                     simpleStatement.module.nameParts[0].value !== '__future__') {
@@ -2302,7 +2302,7 @@ function getScopeIdForNode(node) {
     if (node.nodeType === 10 /* ParseNodeType.Class */) {
         name = node.name.value;
     }
-    else if (node.nodeType === 28 /* ParseNodeType.Function */) {
+    else if (node.nodeType === 31 /* ParseNodeType.Function */) {
         name = node.name.value;
     }
     const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
@@ -2332,7 +2332,7 @@ exports.checkDecorator = checkDecorator;
 function isSimpleDefault(node) {
     switch (node.nodeType) {
         case 40 /* ParseNodeType.Number */:
-        case 11 /* ParseNodeType.Constant */:
+        case 14 /* ParseNodeType.Constant */:
         case 35 /* ParseNodeType.MemberAccess */:
             return true;
         case 49 /* ParseNodeType.String */: