@zzzen/pyright-internal 1.2.0-dev.20240428 → 1.2.0-dev.20240512

package/dist/analyzer/checker.js

@@ -767,31 +767,37 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (baseType) {
             (0, typeUtils_1.doForEachSubtype)(baseType, (subtype) => {
                 const tupleType = (0, typeUtils_1.getSpecializedTupleType)(subtype);
-                if ((0, types_1.isClassInstance)(subtype) &&
-                    (tupleType === null || tupleType === void 0 ? void 0 : tupleType.tupleTypeArguments) &&
-                    !(0, typeUtils_1.isUnboundedTupleClass)(tupleType) &&
-                    !this._evaluator.isTypeSubsumedByOtherType(tupleType, baseType, /* allowAnyToSubsume */ false)) {
-                    const tupleLength = tupleType.tupleTypeArguments.length;
-                    if (node.items.length === 1 &&
-                        !node.trailingComma &&
-                        node.items[0].argumentCategory === 0 /* ArgumentCategory.Simple */ &&
-                        !node.items[0].name) {
-                        const subscriptType = this._evaluator.getType(node.items[0].valueExpression);
-                        if (subscriptType &&
-                            (0, types_1.isClassInstance)(subscriptType) &&
-                            types_1.ClassType.isBuiltIn(subscriptType, 'int') &&
-                            (0, typeUtils_1.isLiteralType)(subscriptType) &&
-                            typeof subscriptType.literalValue === 'number') {
-                            if ((subscriptType.literalValue >= 0 && subscriptType.literalValue >= tupleLength) ||
-                                (subscriptType.literalValue < 0 && subscriptType.literalValue + tupleLength < 0)) {
-                                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.tupleIndexOutOfRange().format({
-                                    index: subscriptType.literalValue,
-                                    type: this._evaluator.printType(subtype),
-                                }), node);
-                            }
-                        }
-                    }
+                if (!(0, types_1.isClassInstance)(subtype) || !(tupleType === null || tupleType === void 0 ? void 0 : tupleType.tupleTypeArguments) || (0, typeUtils_1.isUnboundedTupleClass)(tupleType)) {
+                    return;
+                }
+                const tupleLength = tupleType.tupleTypeArguments.length;
+                if (node.items.length !== 1 ||
+                    node.trailingComma ||
+                    node.items[0].argumentCategory !== 0 /* ArgumentCategory.Simple */ ||
+                    node.items[0].name) {
+                    return;
+                }
+                const subscriptType = this._evaluator.getType(node.items[0].valueExpression);
+                if (!subscriptType ||
+                    !(0, types_1.isClassInstance)(subscriptType) ||
+                    !types_1.ClassType.isBuiltIn(subscriptType, 'int') ||
+                    !(0, typeUtils_1.isLiteralType)(subscriptType) ||
+                    typeof subscriptType.literalValue !== 'number') {
+                    return;
+                }
+                if ((subscriptType.literalValue < 0 || subscriptType.literalValue < tupleLength) &&
+                    (subscriptType.literalValue >= 0 || subscriptType.literalValue + tupleLength >= 0)) {
+                    return;
                 }
+                // This can be an expensive check, so we save it for the end once we
+                // are about to emit a diagnostic.
+                if (this._evaluator.isTypeSubsumedByOtherType(tupleType, baseType, /* allowAnyToSubsume */ false)) {
+                    return;
+                }
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.tupleIndexOutOfRange().format({
+                    index: subscriptType.literalValue,
+                    type: this._evaluator.printType(subtype),
+                }), node);
             });
         }
         return true;
@@ -1196,14 +1202,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         const exprTypeResult = this._evaluator.getTypeOfExpression(expression);
         let isExprFunction = true;
-        let isCoroutine = false;
+        let isCoroutine = true;
         (0, typeUtils_1.doForEachSubtype)(exprTypeResult.type, (subtype) => {
             subtype = this._evaluator.makeTopLevelTypeVarsConcrete(subtype);
             if (!(0, types_1.isFunction)(subtype) && !(0, types_1.isOverloadedFunction)(subtype)) {
                 isExprFunction = false;
             }
-            if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'Coroutine')) {
-                isCoroutine = true;
+            if (!(0, types_1.isClassInstance)(subtype) || !types_1.ClassType.isBuiltIn(subtype, 'Coroutine')) {
+                isCoroutine = false;
             }
         });
         if (isExprFunction) {
@@ -1675,6 +1681,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             exemptBoundTypeVar = false;
             nameWalker.walk(node.returnTypeAnnotation);
         }
+        if (node.functionAnnotationComment) {
+            node.functionAnnotationComment.paramTypeAnnotations.forEach((expr) => {
+                nameWalker.walk(expr);
+            });
+            if (node.functionAnnotationComment.returnTypeAnnotation) {
+                exemptBoundTypeVar = false;
+                nameWalker.walk(node.functionAnnotationComment.returnTypeAnnotation);
+            }
+        }
         localTypeVarUsage.forEach((usage) => {
             var _a;
             // Report error for local type variable that appears only once.
@@ -2153,11 +2168,18 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (decl.type === 1 /* DeclarationType.Variable */) {
                 if (decl.inferredTypeSource) {
                     if (sawAssignment) {
-                        // We check for assignment of Final instance and class variables
-                        // the type evaluator because we need to take into account whether
-                        // the assignment is within an `__init__` method, so ignore class
-                        // scopes here.
-                        if (scopeType !== 3 /* ScopeType.Class */) {
+                        let exemptAssignment = false;
+                        if (scopeType === 3 /* ScopeType.Class */) {
+                            // We check for assignment of Final instance and class variables
+                            // in the type evaluator because we need to take into account whether
+                            // 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 */) {
+                                exemptAssignment = true;
+                            }
+                        }
+                        if (!exemptAssignment) {
                             reportRedeclaration = true;
                         }
                     }
@@ -2700,7 +2722,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const filterType = (varType) => {
             const filteredTypes = [];
             for (const filterType of classTypeList) {
-                const filterIsSuperclass = (0, typeGuards_1.isIsinstanceFilterSuperclass)(this._evaluator, varType, varType, filterType, filterType, isInstanceCheck);
+                const filterIsSuperclass = (0, typeGuards_1.isIsinstanceFilterSuperclass)(this._evaluator, varType, varType, filterType, filterType, isInstanceCheck, 
+                /* isTypeIsCheck */ false);
                 const filterIsSubclass = (0, typeGuards_1.isIsinstanceFilterSubclass)(this._evaluator, varType, filterType, isInstanceCheck);
                 // Normally, a class should never be both a subclass and a
                 // superclass. However, this can happen if one of the classes
@@ -3181,7 +3204,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
     }
     _conditionallyReportPrivateUsage(node) {
-        var _a;
+        var _a, _b;
         if (this._fileInfo.diagnosticRuleSet.reportPrivateUsage === 'none') {
             return;
         }
@@ -3201,7 +3224,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (!isPrivateName && !isProtectedName) {
             return;
         }
-        const declarations = this._evaluator.getDeclarationsForNameNode(node);
+        // Get the declarations for this name node, but filter out
+        // any variable declarations that are bound using nonlocal
+        // or global explicit bindings.
+        const declarations = (_b = this._evaluator
+            .getDeclarationsForNameNode(node)) === null || _b === void 0 ? void 0 : _b.filter((decl) => decl.type !== 1 /* DeclarationType.Variable */ || !decl.isExplicitBinding);
         let primaryDeclaration = declarations && declarations.length > 0 ? declarations[declarations.length - 1] : undefined;
         if (!primaryDeclaration || primaryDeclaration.node === node) {
             return;