@zzzen/pyright-internal 1.2.0-dev.20261004 → 1.2.0-dev.20261018

package/dist/analyzer/checker.d.ts

@@ -110,7 +110,6 @@ export declare class Checker extends ParseTreeWalker {
     private _conditionallyReportUnusedSymbol;
     private _conditionallyReportUnusedDeclaration;
     private _validateIsInstanceCall;
-    private _validateUnsafeProtocolOverlap;
     private _isTypeSupportedTypeForIsInstance;
     private _validateNotDataProtocol;
     private _isSymbolPrivate;

package/dist/analyzer/checker.js

@@ -1836,22 +1836,23 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         for (let i = 0; i < prevOverloads.length; i++) {
             const prevOverload = prevOverloads[i];
+            const prevReturnType = types_1.FunctionType.getEffectiveReturnType(prevOverload);
+            const returnType = types_1.FunctionType.getEffectiveReturnType(functionType);
+            if (!prevReturnType ||
+                !returnType ||
+                this._evaluator.assignType(returnType, prevReturnType, 
+                /* diag */ undefined, 
+                /* constraints */ undefined, 262144 /* AssignTypeFlags.RejectCyclicLowerBound */)) {
+                continue;
+            }
             if (this._isOverlappingOverload(prevOverload, functionType, /* partialOverlap */ true)) {
-                const prevReturnType = types_1.FunctionType.getEffectiveReturnType(prevOverload);
-                const returnType = types_1.FunctionType.getEffectiveReturnType(functionType);
-                if (prevReturnType &&
-                    returnType &&
-                    !this._evaluator.assignType(returnType, prevReturnType, 
-                    /* diag */ undefined, 
-                    /* constraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
-                    const altNode = this._findNodeForOverload(node, prevOverload);
-                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOverlappingOverload, localize_1.LocMessage.overloadReturnTypeMismatch().format({
-                        name: node.d.name.d.value,
-                        newIndex: prevOverloads.length + 1,
-                        prevIndex: i + 1,
-                    }), (altNode || node).d.name);
-                    break;
-                }
+                const altNode = this._findNodeForOverload(node, prevOverload);
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOverlappingOverload, localize_1.LocMessage.overloadReturnTypeMismatch().format({
+                    name: node.d.name.d.value,
+                    newIndex: prevOverloads.length + 1,
+                    prevIndex: i + 1,
+                }), (altNode || node).d.name);
+                break;
             }
         }
     }
@@ -2883,19 +2884,20 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (ParseTreeUtils.isWithinAssertExpression(node)) {
             return;
         }
-        const classTypeList = (0, typeGuards_1.getIsInstanceClassTypes)(this._evaluator, arg1Type);
-        if (!classTypeList) {
+        const classTypeInfo = (0, typeGuards_1.getIsInstanceClassTypes)(this._evaluator, arg1Type, node.d.args[1].d.valueExpr);
+        if (!classTypeInfo) {
             return;
         }
+        const classTypeList = classTypeInfo.classTypes;
         // Check for unsafe protocol overlaps.
         classTypeList.forEach((filterType) => {
             if ((0, types_1.isInstantiableClass)(filterType)) {
-                this._validateUnsafeProtocolOverlap(node.d.args[0].d.valueExpr, types_1.ClassType.cloneAsInstance(filterType), isInstanceCheck ? arg0Type : (0, typeUtils_1.convertToInstance)(arg0Type));
+                (0, protocols_1.validateProtocolUnsafeOverlap)(this._evaluator, node.d.args[0].d.valueExpr, types_1.ClassType.cloneAsInstance(filterType), isInstanceCheck ? arg0Type : (0, typeUtils_1.convertToInstance)(arg0Type));
             }
         });
         // Check for unnecessary isinstance or issubclass calls.
         if (this._fileInfo.diagnosticRuleSet.reportUnnecessaryIsInstance !== 'none') {
-            const narrowedTypeNegative = (0, typeGuards_1.narrowTypeForInstanceOrSubclass)(this._evaluator, arg0Type, classTypeList, isInstanceCheck, 
+            const narrowedTypeNegative = (0, typeGuards_1.narrowTypeForInstanceOrSubclass)(this._evaluator, arg0Type, classTypeInfo.negativeClassTypes, isInstanceCheck, 
             /* isTypeIsCheck */ false, 
             /* isPositiveTest */ false, node, this._nodeInfo);
             const narrowedTypePositive = (0, typeGuards_1.narrowTypeForInstanceOrSubclass)(this._evaluator, arg0Type, classTypeList, isInstanceCheck, 
@@ -2919,29 +2921,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
     }
-    _validateUnsafeProtocolOverlap(errorNode, protocol, testType) {
-        // If this is a protocol class, check for an "unsafe overlap"
-        // with the arg0 type.
-        if (types_1.ClassType.isProtocolClass(protocol)) {
-            let isUnsafeOverlap = false;
-            const diag = new diagnostic_1.DiagnosticAddendum();
-            (0, typeUtils_1.doForEachSubtype)(testType, (testSubtype) => {
-                if ((0, types_1.isClassInstance)(testSubtype)) {
-                    if ((0, protocols_1.isProtocolUnsafeOverlap)(this._evaluator, protocol, testSubtype)) {
-                        isUnsafeOverlap = true;
-                        diag.addMessage(localize_1.LocAddendum.protocolUnsafeOverlap().format({
-                            name: testSubtype.shared.name,
-                        }));
-                    }
-                }
-            });
-            if (isUnsafeOverlap) {
-                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.protocolUnsafeOverlap().format({
-                    name: protocol.shared.name,
-                }) + diag.getString(), errorNode);
-            }
-        }
-    }
     // Determines whether the specified type is allowed as the second argument
     // to an isinstance or issubclass check.
     _isTypeSupportedTypeForIsInstance(type, isInstanceCheck, diag) {