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

package/dist/analyzer/checker.js

@@ -509,11 +509,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         this._validateIllegalDefaultParamInitializer(node);
         return true;
     }
-    visitListComprehension(node) {
+    visitComprehension(node) {
         this._scopedNodes.push(node);
         return true;
     }
-    visitListComprehensionIf(node) {
+    visitComprehensionIf(node) {
         this._validateConditionalIsBool(node.testExpression);
         this._reportUnnecessaryConditionExpression(node.testExpression);
         return true;
@@ -861,7 +861,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (this._fileInfo.executionEnvironment.pythonVersion.isLessThan(pythonVersion_1.pythonVersion3_12)) {
             let curNode = node;
             while (curNode) {
-                if (curNode.nodeType === 27 /* ParseNodeType.FormatString */) {
+                if (curNode.nodeType === 30 /* ParseNodeType.FormatString */) {
                     fStringContainers.push(curNode);
                 }
                 curNode = curNode.parent;
@@ -1024,7 +1024,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             break;
         }
         let isImportFromTyping = false;
-        if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 22 /* ParseNodeType.ImportFrom */) {
+        if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 25 /* ParseNodeType.ImportFrom */) {
             if (node.parent.module.leadingDots === 0 && node.parent.module.nameParts.length === 1) {
                 if (node.parent.module.nameParts[0].value === 'typing') {
                     isImportFromTyping = true;
@@ -1066,7 +1066,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     break;
                 }
             }
-            else if (typeVarScopeNode.nodeType === 28 /* ParseNodeType.Function */) {
+            else if (typeVarScopeNode.nodeType === 31 /* ParseNodeType.Function */) {
                 const functionType = (_d = this._evaluator.getTypeOfFunction(typeVarScopeNode)) === null || _d === void 0 ? void 0 : _d.functionType;
                 if (functionType === null || functionType === void 0 ? void 0 : functionType.details.typeParameters.some((param) => param.details.name === node.name.value)) {
                     foundDuplicate = true;
@@ -1228,7 +1228,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             55 /* ParseNodeType.UnaryOperation */,
             7 /* ParseNodeType.BinaryOperation */,
             40 /* ParseNodeType.Number */,
-            11 /* ParseNodeType.Constant */,
+            14 /* ParseNodeType.Constant */,
             38 /* ParseNodeType.Name */,
             52 /* ParseNodeType.Tuple */,
         ];
@@ -1236,11 +1236,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (simpleExpressionTypes.some((nodeType) => nodeType === node.nodeType)) {
             reportAsUnused = true;
         }
-        else if (node.nodeType === 31 /* ParseNodeType.List */ ||
+        else if (node.nodeType === 34 /* ParseNodeType.List */ ||
             node.nodeType === 45 /* ParseNodeType.Set */ ||
-            node.nodeType === 15 /* ParseNodeType.Dictionary */) {
+            node.nodeType === 18 /* ParseNodeType.Dictionary */) {
             // Exclude comprehensions.
-            if (!node.entries.some((entry) => entry.nodeType === 32 /* ParseNodeType.ListComprehension */)) {
+            if (!node.entries.some((entry) => entry.nodeType === 11 /* ParseNodeType.Comprehension */)) {
                 reportAsUnused = true;
             }
         }
@@ -1605,7 +1605,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         }
                     }
                     const existingEntry = localTypeVarUsage.get(nameType.details.name);
-                    const isParamTypeWithEllipsisUsage = ((_a = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.defaultValue) === null || _a === void 0 ? void 0 : _a.nodeType) === 18 /* ParseNodeType.Ellipsis */;
+                    const isParamTypeWithEllipsisUsage = ((_a = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.defaultValue) === null || _a === void 0 ? void 0 : _a.nodeType) === 21 /* ParseNodeType.Ellipsis */;
                     if (!existingEntry) {
                         localTypeVarUsage.set(nameType.details.name, {
                             nodes: [nameNode],
@@ -1637,7 +1637,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 // this constructor method?
                 if (constructorClass && nameType.scopeId === constructorClass.details.typeVarScopeId) {
                     const existingEntry = classTypeVarUsage.get(nameType.details.name);
-                    const isParamTypeWithEllipsisUsage = ((_d = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.defaultValue) === null || _d === void 0 ? void 0 : _d.nodeType) === 18 /* ParseNodeType.Ellipsis */;
+                    const isParamTypeWithEllipsisUsage = ((_d = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.defaultValue) === null || _d === void 0 ? void 0 : _d.nodeType) === 21 /* ParseNodeType.Ellipsis */;
                     const isExempt = !!nameType.details.isDefaultExplicit;
                     if (!existingEntry) {
                         classTypeVarUsage.set(nameType.details.name, {
@@ -1901,15 +1901,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     _validateStubStatement(statement) {
         switch (statement.nodeType) {
-            case 19 /* ParseNodeType.If */:
-            case 28 /* ParseNodeType.Function */:
+            case 22 /* ParseNodeType.If */:
+            case 31 /* ParseNodeType.Function */:
             case 10 /* ParseNodeType.Class */:
             case 0 /* ParseNodeType.Error */: {
                 // These are allowed in a stub file.
                 break;
             }
             case 57 /* ParseNodeType.While */:
-            case 26 /* ParseNodeType.For */:
+            case 29 /* ParseNodeType.For */:
             case 53 /* ParseNodeType.Try */:
             case 58 /* ParseNodeType.With */: {
                 // These are not allowed.
@@ -1924,15 +1924,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         case 4 /* ParseNodeType.AssignmentExpression */:
                         case 6 /* ParseNodeType.Await */:
                         case 7 /* ParseNodeType.BinaryOperation */:
-                        case 11 /* ParseNodeType.Constant */:
-                        case 14 /* ParseNodeType.Del */:
-                        case 15 /* ParseNodeType.Dictionary */:
-                        case 24 /* ParseNodeType.Index */:
-                        case 26 /* ParseNodeType.For */:
-                        case 27 /* ParseNodeType.FormatString */:
-                        case 29 /* ParseNodeType.Global */:
-                        case 30 /* ParseNodeType.Lambda */:
-                        case 31 /* ParseNodeType.List */:
+                        case 14 /* ParseNodeType.Constant */:
+                        case 17 /* ParseNodeType.Del */:
+                        case 18 /* ParseNodeType.Dictionary */:
+                        case 27 /* ParseNodeType.Index */:
+                        case 29 /* ParseNodeType.For */:
+                        case 30 /* ParseNodeType.FormatString */:
+                        case 32 /* ParseNodeType.Global */:
+                        case 33 /* ParseNodeType.Lambda */:
+                        case 34 /* ParseNodeType.List */:
                         case 35 /* ParseNodeType.MemberAccess */:
                         case 38 /* ParseNodeType.Name */:
                         case 39 /* ParseNodeType.Nonlocal */:
@@ -2175,7 +2175,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             // the assignment is within an `__init__` method, so ignore class
                             // scopes here.
                             const classOrFunc = ParseTreeUtils.getEnclosingClassOrFunction(decl.node);
-                            if ((classOrFunc === null || classOrFunc === void 0 ? void 0 : classOrFunc.nodeType) === 28 /* ParseNodeType.Function */) {
+                            if ((classOrFunc === null || classOrFunc === void 0 ? void 0 : classOrFunc.nodeType) === 31 /* ParseNodeType.Function */) {
                                 exemptAssignment = true;
                             }
                         }
@@ -2454,7 +2454,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             case 8 /* DeclarationType.Alias */:
                 diagnosticLevel = this._fileInfo.diagnosticRuleSet.reportUnusedImport;
                 rule = diagnosticRules_1.DiagnosticRule.reportUnusedImport;
-                if (decl.node.nodeType === 21 /* ParseNodeType.ImportAs */) {
+                if (decl.node.nodeType === 24 /* ParseNodeType.ImportAs */) {
                     if (decl.node.alias) {
                         // For statements of the form "import x as x", don't mark "x" as unaccessed
                         // because it's assumed to be re-exported.
@@ -2476,7 +2476,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         }
                     }
                 }
-                else if (decl.node.nodeType === 23 /* ParseNodeType.ImportFromAs */) {
+                else if (decl.node.nodeType === 26 /* ParseNodeType.ImportFromAs */) {
                     const importFrom = decl.node.parent;
                     // For statements of the form "from y import x as x", don't mark "x" as
                     // unaccessed because it's assumed to be re-exported.
@@ -2908,7 +2908,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     _isSymbolPrivate(nameValue, scopeType) {
         // All variables within the scope of a function or a list
         // comprehension are considered private.
-        if (scopeType === 2 /* ScopeType.Function */ || scopeType === 1 /* ScopeType.ListComprehension */) {
+        if (scopeType === 2 /* ScopeType.Function */ || scopeType === 1 /* ScopeType.Comprehension */) {
             return true;
         }
         // See if the symbol is private.
@@ -2966,7 +2966,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         let deprecatedMessage;
         function getDeprecatedMessageForFunction(functionType) {
             if (functionType.details.declaration &&
-                functionType.details.declaration.node.nodeType === 28 /* ParseNodeType.Function */) {
+                functionType.details.declaration.node.nodeType === 31 /* ParseNodeType.Function */) {
                 const containingClass = ParseTreeUtils.getEnclosingClass(functionType.details.declaration.node, 
                 /* stopAtFunction */ true);
                 if (containingClass) {
@@ -3155,8 +3155,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         // Skip this check for relative imports.
-        const nodeModule = node.nodeType === 23 /* ParseNodeType.ImportFromAs */
-            ? ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 22 /* ParseNodeType.ImportFrom */
+        const nodeModule = node.nodeType === 26 /* ParseNodeType.ImportFromAs */
+            ? ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 25 /* ParseNodeType.ImportFrom */
                 ? (_b = node.parent) === null || _b === void 0 ? void 0 : _b.module
                 : undefined
             : node.module;
@@ -3164,9 +3164,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         // Otherwise use the name to determine if a match for a stdlib module.
-        const namePartNodes = node.nodeType === 21 /* ParseNodeType.ImportAs */
+        const namePartNodes = node.nodeType === 24 /* ParseNodeType.ImportAs */
             ? node.module.nameParts
-            : node.nodeType === 23 /* ParseNodeType.ImportFromAs */
+            : node.nodeType === 26 /* ParseNodeType.ImportFromAs */
                 ? [node.name]
                 : node.module.nameParts;
         const nameParts = namePartNodes.map((n) => n.value);
@@ -3321,7 +3321,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 if (statement.nodeType === 47 /* ParseNodeType.StatementList */) {
                     for (const substatement of statement.statements) {
                         if (substatement.nodeType !== 54 /* ParseNodeType.TypeAnnotation */ &&
-                            substatement.nodeType !== 18 /* ParseNodeType.Ellipsis */ &&
+                            substatement.nodeType !== 21 /* ParseNodeType.Ellipsis */ &&
                             substatement.nodeType !== 48 /* ParseNodeType.StringList */ &&
                             substatement.nodeType !== 42 /* ParseNodeType.Pass */) {
                             emitBadStatementError(substatement);
@@ -3997,7 +3997,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             const newDecl = newMemberType.details.declaration;
             if (initDecl && newDecl) {
                 const mainDecl = displayOnInit ? initDecl : newDecl;
-                const mainDeclNode = mainDecl.node.nodeType === 28 /* ParseNodeType.Function */ ? mainDecl.node.name : mainDecl.node;
+                const mainDeclNode = mainDecl.node.nodeType === 31 /* ParseNodeType.Function */ ? mainDecl.node.name : mainDecl.node;
                 const diagAddendum = new diagnostic_1.DiagnosticAddendum();
                 const initSignature = this._evaluator.printType(initMemberType);
                 const newSignature = this._evaluator.printType(newMemberType);
@@ -5178,7 +5178,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const importStatements = (0, importStatementUtils_1.getTopLevelImports)(this._moduleNode);
         const importModuleMap = new Map();
         importStatements.orderedImports.forEach((importStatement) => {
-            if (importStatement.node.nodeType === 22 /* ParseNodeType.ImportFrom */) {
+            if (importStatement.node.nodeType === 25 /* ParseNodeType.ImportFrom */) {
                 const symbolMap = new Map();
                 importStatement.node.imports.forEach((importFromAs) => {
                     // Ignore duplicates if they're aliased.