@zzzen/pyright-internal 1.2.0-dev.20260927 → 1.2.0-dev.20261011

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;
@@ -148,7 +147,6 @@ export declare class Checker extends ParseTreeWalker {
     private _validateTypedDictOverrides;
     private _validateBaseClassOverrides;
     private _validateOverrideDecoratorPresent;
-    private _isMethodExemptFromLsp;
     private _validateOverrideDecoratorNotPresent;
     private _getCallableVariableOverrideComparison;
     private _markFunctionStatic;

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;
             }
         }
     }
@@ -2803,7 +2804,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         const action = rule === diagnosticRules_1.DiagnosticRule.reportUnusedImport ? { action: "pyright.unusedImport" /* Commands.unusedImport */ } : undefined;
         if (nameNode) {
-            this._fileInfo.diagnosticSink.addUnusedCodeWithTextRange(localize_1.LocMessage.unaccessedSymbol().format({ name: nameNode.d.value }), nameNode, action);
+            const isAllowedUnusedVariable = rule === diagnosticRules_1.DiagnosticRule.reportUnusedVariable && nameNode.d.value.startsWith('_');
+            if (!isAllowedUnusedVariable) {
+                this._fileInfo.diagnosticSink.addUnusedCodeWithTextRange(localize_1.LocMessage.unaccessedSymbol().format({ name: nameNode.d.value }), nameNode, action);
+            }
             if (rule !== undefined && message && diagnosticLevel !== 'none') {
                 this._evaluator.addDiagnostic(rule, message, nameNode);
             }
@@ -2887,7 +2891,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // 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.
@@ -2916,29 +2920,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) {
@@ -4706,7 +4687,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         // Constructors are exempt.
-        if (this._isMethodExemptFromLsp(overrideFunction.shared.name)) {
+        if (SymbolNameUtils.isMethodExemptFromLsp(overrideFunction.shared.name)) {
             return;
         }
         // If the declaration for the override function is not the same as the
@@ -4724,11 +4705,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             className: this._evaluator.printType((0, typeUtils_1.convertToInstance)(baseMember.classType)),
         }), funcNode.d.name);
     }
-    // Determines whether the name is exempt from Liskov Substitution Principle rules.
-    _isMethodExemptFromLsp(name) {
-        const exemptMethods = ['__init__', '__new__', '__init_subclass__', '__post_init__'];
-        return exemptMethods.some((n) => n === name);
-    }
     // Determines whether the type is a function or overloaded function with an @override
     // decorator. In this case, an error is reported because no base class has declared
     // a method of the same name.
@@ -4877,7 +4853,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // Also, skip this check if the class is a TypedDict. The methods for a TypedDict
             // are synthesized, and they can result in many overloads. We assume they
             // are correct and will not produce any errors.
-            if (this._isMethodExemptFromLsp(memberName) ||
+            if (SymbolNameUtils.isMethodExemptFromLsp(memberName) ||
                 SymbolNameUtils.isPrivateName(memberName) ||
                 types_1.ClassType.isTypedDictClass(childClassType)) {
                 return;