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

package/dist/analyzer/typeEvaluatorTypes.d.ts

@@ -332,7 +332,8 @@ export declare const enum AssignTypeFlags {
     AllowIsinstanceSpecialForms = 16384,
     SkipSelfClsParamCheck = 32768,
     AllowProtocolClassSource = 65536,
-    DisallowExtraKwargsForTd = 131072
+    DisallowExtraKwargsForTd = 131072,
+    RejectCyclicLowerBound = 262144
 }
 export interface TypeEvaluator {
     runWithCancellationToken<T>(token: CancellationToken, callback: () => T): T;

package/dist/analyzer/typeEvaluatorTypes.js

@@ -197,5 +197,9 @@ var AssignTypeFlags;
     // When assigning callables, should a kwargs with an unpacked TypedDict
     // disallow additional named arguments if it does not have extraItems?
     AssignTypeFlags[AssignTypeFlags["DisallowExtraKwargsForTd"] = 131072] = "DisallowExtraKwargsForTd";
+    // Reject a cyclic TypeVar lower bound even when no constraint tracker
+    // records it. Overload consistency validation uses this when comparing
+    // return types.
+    AssignTypeFlags[AssignTypeFlags["RejectCyclicLowerBound"] = 262144] = "RejectCyclicLowerBound";
 })(AssignTypeFlags || (exports.AssignTypeFlags = AssignTypeFlags = {}));
 //# sourceMappingURL=typeEvaluatorTypes.js.map

package/dist/analyzer/typeEvaluatorTypes.js.map

@@ -1 +1 @@
-{"version":3,"file":"typeEvaluatorTypes.js","sourceRoot":"","sources":["../../../../../src/analyzer/typeEvaluatorTypes.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"typeEvaluatorTypes.js","sourceRoot":"","sources":["../../../../../src/analyzer/typeEvaluatorTypes.ts"],"names":[],"mappings":"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"}

package/dist/analyzer/typeGuards.js

@@ -58,6 +58,8 @@ const analyzerNodeInfo_1 = require("./analyzerNodeInfo");
 const constraintSolver_1 = require("./constraintSolver");
 const constraintTracker_1 = require("./constraintTracker");
 const enums_1 = require("./enums");
+const operations_1 = require("./operations");
+const parameterUtils_1 = require("./parameterUtils");
 const ParseTreeUtils = __importStar(require("./parseTreeUtils"));
 const scopeUtils_1 = require("./scopeUtils");
 const symbol_1 = require("./symbol");
@@ -250,6 +252,16 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                             };
                         };
                     }
+                    // Look for X == <class> or X != <class>.
+                    if ((0, types_1.isInstantiableClass)(rightType)) {
+                        return (type) => {
+                            return {
+                                type: narrowTypeForClassComparison(evaluator, type, rightType, adjIsPositiveTest, 
+                                /* isIsOperator */ false),
+                                isIncomplete: !!rightTypeResult.isIncomplete,
+                            };
+                        };
+                    }
                 }
                 // Look for X[<literal>] == <literal> or X[<literal>] != <literal>
                 if (testExpression.d.leftExpr.nodeType === 27 /* ParseNodeType.Index */ &&
@@ -456,82 +468,155 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
             }
         }
         // Look for a TypeGuard function.
-        if (testExpression.d.args.length >= 1) {
-            const arg0Expr = testExpression.d.args[0].d.valueExpr;
-            if (isMatchingExpressionOrWalrusRhs(evaluator, reference, arg0Expr)) {
-                // Does this look like it's a custom type guard function?
-                let isPossiblyTypeGuard = false;
-                const isFunctionReturnTypeGuard = (type) => {
-                    const returnType = type.shared.declaredReturnType;
-                    if (!returnType) {
-                        return false;
+        const isFunctionReturnTypeGuard = (type) => {
+            const returnType = type.shared.declaredReturnType;
+            if (!returnType) {
+                return false;
+            }
+            if ((0, types_1.isClassInstance)(returnType)) {
+                return types_1.ClassType.isBuiltIn(returnType, ['TypeGuard', 'TypeIs']);
+            }
+            if ((0, types_1.isUnion)(returnType)) {
+                let isAllGuards = true;
+                (0, typeUtils_1.doForEachSubtype)(returnType, (subtype) => {
+                    if (!(0, types_1.isClassInstance)(subtype) || !types_1.ClassType.isBuiltIn(subtype, ['TypeGuard', 'TypeIs'])) {
+                        isAllGuards = false;
                     }
-                    if ((0, types_1.isClassInstance)(returnType)) {
-                        return types_1.ClassType.isBuiltIn(returnType, ['TypeGuard', 'TypeIs']);
-                    }
-                    if ((0, types_1.isUnion)(returnType)) {
-                        let isAllGuards = true;
-                        (0, typeUtils_1.doForEachSubtype)(returnType, (subtype) => {
-                            if (!(0, types_1.isClassInstance)(subtype) || !types_1.ClassType.isBuiltIn(subtype, ['TypeGuard', 'TypeIs'])) {
-                                isAllGuards = false;
-                            }
-                        });
-                        return isAllGuards;
-                    }
-                    return false;
-                };
-                const callTypeResult = evaluator.getTypeOfExpression(testExpression.d.leftExpr, 2 /* EvalFlags.CallBaseDefaults */);
-                const callType = callTypeResult.type;
-                if ((0, types_1.isFunction)(callType) && isFunctionReturnTypeGuard(callType)) {
-                    isPossiblyTypeGuard = true;
-                }
-                else if ((0, types_1.isOverloaded)(callType) &&
-                    types_1.OverloadedType.getOverloads(callType).some((o) => isFunctionReturnTypeGuard(o))) {
-                    isPossiblyTypeGuard = true;
-                }
-                else if ((0, types_1.isClassInstance)(callType)) {
-                    isPossiblyTypeGuard = true;
+                });
+                return isAllGuards;
+            }
+            return false;
+        };
+        // Reject unrelated references before evaluating the callee.
+        if (testExpression.d.args.some((arg) => isMatchingExpressionOrWalrusRhs(evaluator, reference, arg.d.valueExpr))) {
+            const callTypeResult = evaluator.getTypeOfExpression(testExpression.d.leftExpr, 2 /* EvalFlags.CallBaseDefaults */);
+            const callType = callTypeResult.type;
+            let isPossiblyTypeGuard = false;
+            if ((0, types_1.isFunction)(callType)) {
+                isPossiblyTypeGuard = isFunctionReturnTypeGuard(callType);
+            }
+            else if ((0, types_1.isOverloaded)(callType)) {
+                isPossiblyTypeGuard = types_1.OverloadedType.getOverloads(callType).some(isFunctionReturnTypeGuard);
+            }
+            else if ((0, types_1.isClassInstance)(callType)) {
+                // A callable object's __call__ may be overloaded, a property or have
+                // an inferred return type, so rely on the evaluated call below.
+                isPossiblyTypeGuard = true;
+            }
+            if (isPossiblyTypeGuard) {
+                const functionReturnTypeResult = evaluator.getTypeOfExpression(testExpression);
+                const functionReturnType = functionReturnTypeResult.type;
+                let typeGuardType;
+                let isStrictTypeGuard = false;
+                if ((0, types_1.isClassInstance)(functionReturnType) &&
+                    types_1.ClassType.isBuiltIn(functionReturnType, ['TypeGuard', 'TypeIs']) &&
+                    functionReturnType.priv.typeArgs &&
+                    functionReturnType.priv.typeArgs.length > 0) {
+                    isStrictTypeGuard = types_1.ClassType.isBuiltIn(functionReturnType, 'TypeIs');
+                    typeGuardType = functionReturnType.priv.typeArgs[0];
                 }
-                if (isPossiblyTypeGuard) {
-                    // Evaluate the type guard call expression.
-                    const functionReturnTypeResult = evaluator.getTypeOfExpression(testExpression);
-                    const functionReturnType = functionReturnTypeResult.type;
-                    let typeGuardType;
-                    let isStrictTypeGuard = false;
-                    if ((0, types_1.isClassInstance)(functionReturnType) &&
-                        types_1.ClassType.isBuiltIn(functionReturnType, ['TypeGuard', 'TypeIs']) &&
-                        functionReturnType.priv.typeArgs &&
-                        functionReturnType.priv.typeArgs.length > 0) {
-                        isStrictTypeGuard = types_1.ClassType.isBuiltIn(functionReturnType, 'TypeIs');
-                        typeGuardType = functionReturnType.priv.typeArgs[0];
+                else if ((0, types_1.isUnion)(functionReturnType)) {
+                    const typeGuardSubtypes = [];
+                    let isAllGuards = true;
+                    (0, typeUtils_1.doForEachSubtype)(functionReturnType, (subtype) => {
+                        if ((0, types_1.isClassInstance)(subtype) &&
+                            types_1.ClassType.isBuiltIn(subtype, ['TypeGuard', 'TypeIs']) &&
+                            subtype.priv.typeArgs &&
+                            subtype.priv.typeArgs.length > 0) {
+                            typeGuardSubtypes.push(subtype);
+                        }
+                        else {
+                            isAllGuards = false;
+                        }
+                    });
+                    if (isAllGuards && typeGuardSubtypes.length > 0) {
+                        // A union of type guards cannot be strict in the negative case because at runtime
+                        // only one arm of the overload/union is selected. Treating it as strict would
+                        // unsoundly eliminate types in the negative branch.
+                        isStrictTypeGuard = false;
+                        typeGuardType = (0, types_1.combineTypes)(typeGuardSubtypes.map((subtype) => subtype.priv.typeArgs[0]));
                     }
-                    else if ((0, types_1.isUnion)(functionReturnType)) {
-                        const typeGuardSubtypes = [];
-                        let isAllGuards = true;
-                        (0, typeUtils_1.doForEachSubtype)(functionReturnType, (subtype) => {
-                            if ((0, types_1.isClassInstance)(subtype) &&
-                                types_1.ClassType.isBuiltIn(subtype, ['TypeGuard', 'TypeIs']) &&
-                                subtype.priv.typeArgs &&
-                                subtype.priv.typeArgs.length > 0) {
-                                typeGuardSubtypes.push(subtype);
+                }
+                if (typeGuardType) {
+                    // Map only guard-returning calls. Ordinary callable predicates
+                    // do not need their virtual parameter lists expanded.
+                    const getTargetArgExpr = (fnType) => {
+                        // Callable-valued attributes can have binding metadata without a method receiver.
+                        const isUnbound = fnType.shared.methodClass !== undefined &&
+                            !types_1.FunctionType.isStaticMethod(fnType) &&
+                            fnType.priv.strippedFirstParamType === undefined;
+                        const targetIndex = isUnbound ? 1 : 0;
+                        const getPositionalArgExpr = () => {
+                            // Unpacking before the guarded position obscures its argument expression.
+                            let positionalIndex = 0;
+                            for (const arg of testExpression.d.args) {
+                                if (arg.d.name) {
+                                    continue;
+                                }
+                                if (arg.d.argCategory !== 0 /* ArgCategory.Simple */) {
+                                    return undefined;
+                                }
+                                if (positionalIndex === targetIndex) {
+                                    return arg.d.valueExpr;
+                                }
+                                positionalIndex++;
                             }
-                            else {
-                                isAllGuards = false;
+                            return undefined;
+                        };
+                        // Simple leading parameters bind positionally without expanding the rest of the signature.
+                        const firstParam = fnType.shared.parameters[0];
+                        const targetParam = fnType.shared.parameters[targetIndex];
+                        if (firstParam?.category === 0 /* ParamCategory.Simple */ &&
+                            firstParam.name &&
+                            targetParam?.category === 0 /* ParamCategory.Simple */ &&
+                            targetParam.name) {
+                            const positionalArgExpr = getPositionalArgExpr();
+                            if (positionalArgExpr) {
+                                return positionalArgExpr;
+                            }
+                        }
+                        const paramDetails = (0, parameterUtils_1.getParamListDetails)(fnType);
+                        if (targetIndex >= paramDetails.params.length) {
+                            return undefined;
+                        }
+                        const target = paramDetails.params[targetIndex];
+                        if (target.param.category !== 0 /* ParamCategory.Simple */ &&
+                            target.param.category !== 1 /* ParamCategory.ArgsList */) {
+                            return undefined;
+                        }
+                        if ((target.kind === parameterUtils_1.ParamKind.Standard || target.kind === parameterUtils_1.ParamKind.Keyword) &&
+                            target.param.name) {
+                            const kwArg = testExpression.d.args.find((arg) => arg.d.argCategory === 0 /* ArgCategory.Simple */ &&
+                                arg.d.name?.d.value === target.param.name);
+                            if (kwArg) {
+                                return kwArg.d.valueExpr;
                             }
-                        });
-                        if (isAllGuards && typeGuardSubtypes.length > 0) {
-                            // A union of type guards cannot be strict in the negative case because at runtime
-                            // only one arm of the overload/union is selected. Treating it as strict would
-                            // unsoundly eliminate types in the negative branch.
-                            isStrictTypeGuard = false;
-                            typeGuardType = (0, types_1.combineTypes)(typeGuardSubtypes.map((subtype) => subtype.priv.typeArgs[0]));
                         }
+                        if (target.kind === parameterUtils_1.ParamKind.Keyword) {
+                            return undefined;
+                        }
+                        return getPositionalArgExpr();
+                    };
+                    let arg0Expr;
+                    const overloadsUsed = functionReturnTypeResult.overloadsUsedForCall;
+                    if (overloadsUsed && overloadsUsed.length > 0) {
+                        arg0Expr = getTargetArgExpr(overloadsUsed[0]);
+                        for (let i = 1; arg0Expr && i < overloadsUsed.length; i++) {
+                            if (getTargetArgExpr(overloadsUsed[i]) !== arg0Expr) {
+                                arg0Expr = undefined;
+                                break;
+                            }
+                        }
+                    }
+                    else if ((0, types_1.isFunction)(callType)) {
+                        arg0Expr = getTargetArgExpr(callType);
                     }
-                    if (typeGuardType) {
+                    if (arg0Expr && isMatchingExpressionOrWalrusRhs(evaluator, reference, arg0Expr)) {
                         const isIncomplete = !!callTypeResult.isIncomplete || !!functionReturnTypeResult.isIncomplete;
+                        const guardType = typeGuardType;
                         return (type) => {
                             return {
-                                type: narrowTypeForUserDefinedTypeGuard(evaluator, type, typeGuardType, isPositiveTest, isStrictTypeGuard, testExpression, nodeInfo),
+                                type: narrowTypeForUserDefinedTypeGuard(evaluator, type, guardType, isPositiveTest, isStrictTypeGuard, testExpression, nodeInfo),
                                 isIncomplete,
                             };
                         };
@@ -1869,11 +1954,63 @@ function narrowTypeForTypeIs(evaluator, type, classTypes, isPositiveTest) {
     });
     return (0, types_1.combineTypes)(typesToCombine);
 }
+function hasUnresolvedMetaclassInMro(classType) {
+    return classType.shared.mro.some((baseClass) => !(0, types_1.isInstantiableClass)(baseClass) || !!(baseClass.shared.flags & 134217728 /* ClassTypeFlags.HasUnresolvedMetaclass */));
+}
+// Determines whether an equality comparison ("==" or "!=") involving the
+// specified class object is guaranteed to have identity semantics. This
+// requires that the class is statically closed (it cannot be a subclass
+// with a different metaclass), is not generic (specialized aliases compare
+// by value), and its metaclass does not override "__eq__" or "__ne__".
+function hasIdentityEqualitySemantics(classType, metaclassEqualityResults) {
+    if (classType.priv.includeSubclasses && !types_1.ClassType.isFinal(classType)) {
+        return false;
+    }
+    if (classType.shared.typeParams.length > 0) {
+        return false;
+    }
+    const metaclass = classType.shared.effectiveMetaclass;
+    if (!metaclass ||
+        !(0, types_1.isInstantiableClass)(metaclass) ||
+        hasUnresolvedMetaclassInMro(classType) ||
+        hasUnresolvedMetaclassInMro(metaclass)) {
+        return false;
+    }
+    if (types_1.ClassType.isBuiltIn(metaclass, 'type')) {
+        return true;
+    }
+    // Cloned metaclasses share method definitions, but the class-specific checks above cannot be shared.
+    const cachedResult = metaclassEqualityResults.get(metaclass.shared);
+    if (cachedResult !== undefined) {
+        return cachedResult;
+    }
+    const result = !(0, operations_1.customMetaclassSupportsMethod)(classType, '__eq__') && !(0, operations_1.customMetaclassSupportsMethod)(classType, '__ne__');
+    metaclassEqualityResults.set(metaclass.shared, result);
+    return result;
+}
 // Attempts to narrow a type based on a comparison with a class using "is" or
-// "is not". This pattern is sometimes used for sentinels.
-function narrowTypeForClassComparison(evaluator, referenceType, classType, isPositiveTest) {
+// "is not", or "==" or "!=".
+function narrowTypeForClassComparison(evaluator, referenceType, classType, isPositiveTest, isIsOperator = true) {
+    // Limit reuse to this invocation so results cannot outlive the evaluation that established them.
+    const metaclassEqualityResults = isIsOperator ? undefined : new Map();
+    if (metaclassEqualityResults && !hasIdentityEqualitySemantics(classType, metaclassEqualityResults)) {
+        return referenceType;
+    }
     return (0, typeUtils_1.mapSubtypes)(referenceType, (subtype) => {
+        // Multiple class constraints expand to a union with distinct conditions, which equality cannot narrow.
+        if (metaclassEqualityResults &&
+            (0, types_1.isTypeVar)(subtype) &&
+            !subtype.shared.recursiveAlias &&
+            subtype.shared.constraints.length > 1 &&
+            subtype.shared.constraints.every(types_1.isClassInstance)) {
+            return subtype;
+        }
         let concreteSubtype = evaluator.makeTopLevelTypeVarsConcrete(subtype);
+        if (metaclassEqualityResults &&
+            (!(0, types_1.isInstantiableClass)(concreteSubtype) ||
+                !hasIdentityEqualitySemantics(concreteSubtype, metaclassEqualityResults))) {
+            return subtype;
+        }
         if (isPositiveTest) {
             if ((0, types_1.isClassInstance)(concreteSubtype) &&
                 types_1.TypeBase.isInstance(subtype) &&
@@ -1888,6 +2025,9 @@ function narrowTypeForClassComparison(evaluator, referenceType, classType, isPos
             }
             if ((0, types_1.isClass)(concreteSubtype)) {
                 if (types_1.TypeBase.isInstance(concreteSubtype)) {
+                    if (!isIsOperator) {
+                        return subtype;
+                    }
                     return types_1.ClassType.isBuiltIn(concreteSubtype, 'object') ? classType : undefined;
                 }
                 const isSuperType = isFilterSuperclass(subtype, concreteSubtype, classType, classType);