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

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":";AAAA;;;;;;;GAOG;;;AA2bH,oEAEC;AA1YD,gEAAgE;AAChE,kDAAkD;AACrC,QAAA,0BAA0B,GAAG,EAAE,CAAC;AAE7C,2EAA2E;AAC3E,4EAA4E;AAC5E,yBAAyB;AACZ,QAAA,yBAAyB,GAAG,CAAC,CAAC;AAE3C,IAAkB,SA0IjB;AA1ID,WAAkB,SAAS;IACvB,yCAAQ,CAAA;IAER,uDAAuD;IACvD,yEAA6B,CAAA;IAE7B,0DAA0D;IAC1D,gEAAgE;IAChE,SAAS;IACT,yDAAqB,CAAA;IAErB,yDAAyD;IACzD,uDAAoB,CAAA;IAEpB,kCAAkC;IAClC,iEAAyB,CAAA;IAEzB,0CAA0C;IAC1C,gDAAgB,CAAA;IAEhB,6CAA6C;IAC7C,wDAAoB,CAAA;IAEpB,gDAAgD;IAChD,8DAAuB,CAAA;IAEvB,2DAA2D;IAC3D,4BAA4B;IAC5B,mEAAyB,CAAA;IAEzB,kEAAkE;IAClE,gEAAgE;IAChE,qBAAqB;IACrB,+DAAuB,CAAA;IAEvB,qEAAqE;IACrE,2EAA6B,CAAA;IAE7B,2DAA2D;IAC3D,gDAAgD;IAChD,4DAAsB,CAAA;IAEtB,8DAA8D;IAC9D,0BAA0B;IAC1B,4EAA8B,CAAA;IAE9B,oEAAoE;IACpE,0BAA0B;IAC1B,wFAAoC,CAAA;IAEpC,yDAAyD;IACzD,2DAA2D;IAC3D,mCAAmC;IACnC,0EAA6B,CAAA;IAE7B,yDAAyD;IACzD,6DAA6D;IAC7D,uDAAuD;IACvD,yFAAoC,CAAA;IAEpC,oDAAoD;IACpD,uEAA2B,CAAA;IAE3B,wDAAwD;IACxD,+DAAuB,CAAA;IAEvB,6CAA6C;IAC7C,0DAAoB,CAAA;IAEpB,mEAAmE;IACnE,kEAAwB,CAAA;IAExB,iEAAiE;IACjE,iCAAiC;IACjC,wDAAmB,CAAA;IAEnB,wDAAwD;IACxD,iEAAuB,CAAA;IAEvB,uCAAuC;IACvC,iEAAuB,CAAA;IAEvB,uDAAuD;IACvD,2EAA4B,CAAA;IAE5B,yCAAyC;IACzC,mFAAgC,CAAA;IAEhC,6DAA6D;IAC7D,2DAA2D;IAC3D,oDAAoD;IACpD,8EAA6B,CAAA;IAE7B,8DAA8D;IAC9D,iDAAiD;IACjD,gFAA8B,CAAA;IAE9B,oEAAoE;IACpE,mBAAmB;IACnB,kFAA+B,CAAA;IAE/B,6CAA6C;IAC7C,yEAA0B,CAAA;IAE1B,2EAA2E;IAC3E,4BAA4B;IAC5B,6EAA4B,CAAA;IAE5B,sEAAsE;IACtE,+DAA+D;IAC/D,mEAAuB,CAAA;IAEvB,yEAAyE;IACzE,+BAA+B;IAC/B,gEAAqB,CAAA;IAErB,yEAAyE;IACzE,8CAA8C;IAC9C,2FAAkC,CAAA;IAElC,6DAA6D;IAC7D,iEAA+B,CAAA;IAE/B,sEAAsE;IACtE,mEAAgC,CAAA;IAEhC,sEAAsE;IACtE,iFAAuC,CAAA;IAEvC,sEAAsE;IACtE,wBAAwB;IACxB,mFAMiB,CAAA;AACrB,CAAC,EA1IiB,SAAS,yBAAT,SAAS,QA0I1B;AAqPD,SAAgB,4BAA4B,CAAI,IAAO,EAAE,UAAwB;IAC7E,OAAO,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;AAC5D,CAAC;AAwFD,IAAY,YAiBX;AAjBD,WAAY,YAAY;IACpB,yDAAS,CAAA;IAET,qDAAqD;IACrD,2DAA2D;IAC3D,qCAAqC;IACrC,iFAAqB,CAAA;IAErB,wDAAwD;IACxD,0DAA0D;IAC1D,2BAA2B;IAC3B,2FAA0B,CAAA;IAE1B,2DAA2D;IAC3D,2DAA2D;IAC3D,SAAS;IACT,iFAAqB,CAAA;AACzB,CAAC,EAjBW,YAAY,4BAAZ,YAAY,QAiBvB;AAgDD,IAAkB,eA8EjB;AA9ED,WAAkB,eAAe;IAC7B,2DAAW,CAAA;IAEX,8DAA8D;IAC9D,0BAA0B;IAC1B,+DAAkB,CAAA;IAElB,2DAA2D;IAC3D,yDAAyD;IACzD,iDAAiD;IACjD,uEAAsB,CAAA;IAEtB,sEAAsE;IACtE,sEAAsE;IACtE,6DAA6D;IAC7D,yFAA+B,CAAA;IAE/B,kEAAkE;IAClE,sEAAsE;IACtE,0BAA0B;IAC1B,yFAA+B,CAAA;IAE/B,sDAAsD;IACtD,4DAA4D;IAC5D,4DAA4D;IAC5D,uCAAuC;IACvC,4EAAwB,CAAA;IAExB,2DAA2D;IAC3D,2DAA2D;IAC3D,8BAA8B;IAC9B,0FAA+B,CAAA;IAE/B,kDAAkD;IAClD,oFAA4B,CAAA;IAE5B,2DAA2D;IAC3D,uDAAuD;IACvD,+FAAiC,CAAA;IAEjC,6DAA6D;IAC7D,mEAAmE;IACnE,mEAAmE;IACnE,UAAU;IACV,uFAA6B,CAAA;IAE7B,oEAAoE;IACpE,kEAAkE;IAClE,mEAAmE;IACnE,iEAAiE;IACjE,wFAA8B,CAAA;IAE9B,uEAAuE;IACvE,gDAAgD;IAChD,8GAAyC,CAAA;IAEzC,sEAAsE;IACtE,kEAAkE;IAClE,gEAAgE;IAChE,aAAa;IACb,gGAAkC,CAAA;IAElC,mEAAmE;IACnE,gEAAgE;IAChE,sBAAsB;IACtB,uGAAqC,CAAA;IAErC,0EAA0E;IAC1E,kEAAkE;IAClE,2FAA+B,CAAA;IAE/B,yEAAyE;IACzE,kCAAkC;IAClC,iGAAkC,CAAA;IAElC,uEAAuE;IACvE,sEAAsE;IACtE,kGAAkC,CAAA;AACtC,CAAC,EA9EiB,eAAe,+BAAf,eAAe,QA8EhC"}
+{"version":3,"file":"typeEvaluatorTypes.js","sourceRoot":"","sources":["../../../../../src/analyzer/typeEvaluatorTypes.ts"],"names":[],"mappings":"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"}

package/dist/analyzer/typeGuards.d.ts

@@ -6,9 +6,13 @@ export interface TypeNarrowingResult {
     type: Type;
     isIncomplete: boolean;
 }
+export interface IsInstanceClassTypeInfo {
+    classTypes: (ClassType | TypeVarType | FunctionType)[];
+    negativeClassTypes: (ClassType | TypeVarType | FunctionType)[];
+}
 export type TypeNarrowingCallback = (type: Type) => TypeNarrowingResult | undefined;
 export declare function getTypeNarrowingCallback(evaluator: TypeEvaluator, reference: ExpressionNode, testExpression: ExpressionNode, isPositiveTest: boolean, nodeInfo: AnalyzerNodeInfoAccessor, recursionCount?: number): TypeNarrowingCallback | undefined;
-export declare function getIsInstanceClassTypes(evaluator: TypeEvaluator, argType: Type): (ClassType | TypeVarType | FunctionType)[] | undefined;
+export declare function getIsInstanceClassTypes(evaluator: TypeEvaluator, argType: Type, argExpr: ExpressionNode): IsInstanceClassTypeInfo | undefined;
 export declare function narrowTypeForInstanceOrSubclass(evaluator: TypeEvaluator, type: Type, filterTypes: Type[], isInstanceCheck: boolean, isTypeIsCheck: boolean, isPositiveTest: boolean, errorNode: ExpressionNode, nodeInfo: AnalyzerNodeInfoAccessor): import("./types").UnboundType | UnknownType | AnyType | FunctionType | OverloadedType | ClassType | import("./types").ModuleType | TypeVarType | import("./types").OverloadResultType | import("./types").NeverType | import("./types").UnionType;
 export declare function getElementTypeForContainerNarrowing(containerType: Type): Type | undefined;
 export declare function narrowTypeForContainerElementType(evaluator: TypeEvaluator, referenceType: Type, elementType: Type): Type;

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 */ &&
@@ -416,9 +428,12 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                     const isInstanceCheck = types_1.FunctionType.isBuiltIn(callType, 'isinstance');
                     const arg1TypeResult = evaluator.getTypeOfExpression(arg1Expr, 536871546 /* EvalFlags.IsInstanceArgDefaults */);
                     const arg1Type = arg1TypeResult.type;
-                    const classTypeList = getIsInstanceClassTypes(evaluator, arg1Type);
+                    const classTypeInfo = getIsInstanceClassTypes(evaluator, arg1Type, arg1Expr);
                     const isIncomplete = !!callTypeResult.isIncomplete || !!arg1TypeResult.isIncomplete;
-                    if (classTypeList) {
+                    if (classTypeInfo) {
+                        const classTypeList = isPositiveTest
+                            ? classTypeInfo.classTypes
+                            : classTypeInfo.negativeClassTypes;
                         return (type) => {
                             return {
                                 type: narrowTypeForInstanceOrSubclass(evaluator, type, classTypeList, isInstanceCheck, 
@@ -456,82 +471,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;
-                    }
-                    if ((0, types_1.isClassInstance)(returnType)) {
-                        return types_1.ClassType.isBuiltIn(returnType, ['TypeGuard', 'TypeIs']);
+        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.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;
                             }
-                        });
-                        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]));
                         }
+                        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 (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,
                             };
                         };
@@ -871,23 +959,40 @@ function narrowTypeForIsEllipsis(evaluator, node, type, isPositiveTest) {
     }
     return result;
 }
-// The "isinstance" and "issubclass" calls support two forms - a simple form
-// that accepts a single class, and a more complex form that accepts a tuple
-// of classes (including arbitrarily-nested tuples). This method determines
-// which form and returns a list of classes or undefined.
-function getIsInstanceClassTypes(evaluator, argType) {
+// The "isinstance" and "issubclass" calls accept classes, runtime unions,
+// and arbitrarily-nested tuples of these. This method extracts possible
+// classes and guaranteed negative filters,
+// or undefined if the filter contains a non-class type.
+function getIsInstanceClassTypes(evaluator, argType, argExpr) {
     let foundNonClassType = false;
-    const classTypeList = [];
+    const classTypes = [];
+    const negativeClassTypes = [];
     // Create a helper function that returns a list of class types or
     // undefined if any of the types are not valid.
-    const addClassTypesToList = (types) => {
+    const addClassTypesToList = (types, isAmbiguous, isUnboundedEntry) => {
         types.forEach((subtype) => {
             if ((0, types_1.isClass)(subtype)) {
                 subtype = (0, typeUtils_1.specializeWithUnknownTypeArgs)(subtype, evaluator.getTupleClassType());
                 if ((0, types_1.isInstantiableClass)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'Callable')) {
                     subtype = (0, typeUtils_1.convertToInstantiable)((0, typeUtils_1.getUnknownTypeForCallable)());
                 }
+                else if (types_1.TypeBase.isInstance(subtype) && types_1.ClassType.isBuiltIn(subtype, 'type')) {
+                    if (subtype.priv.typeArgs && subtype.priv.typeArgs.length > 0) {
+                        const typeArg = subtype.priv.typeArgs[0];
+                        if ((0, types_1.isAnyOrUnknown)(typeArg)) {
+                            foundNonClassType = true;
+                            return;
+                        }
+                        if ((0, types_1.isInstantiableClass)(typeArg)) {
+                            subtype = types_1.ClassType.cloneIncludeSubclasses(typeArg);
+                        }
+                        else if ((0, types_1.isClassInstance)(typeArg)) {
+                            subtype = types_1.ClassType.cloneAsInstantiable(typeArg);
+                        }
+                    }
+                }
             }
+            let classType;
             if ((0, types_1.isInstantiableClass)(subtype)) {
                 // If this is a reference to a class that has type promotions (e.g.
                 // float or complex), remove the promotions for purposes of the
@@ -895,49 +1000,112 @@ function getIsInstanceClassTypes(evaluator, argType) {
                 if (!subtype.priv.includeSubclasses && subtype.priv.includePromotions) {
                     subtype = types_1.ClassType.cloneRemoveTypePromotions(subtype);
                 }
-                classTypeList.push(subtype);
+                classType = subtype;
             }
             else if ((0, types_1.isTypeVar)(subtype) && types_1.TypeBase.isInstantiable(subtype)) {
-                classTypeList.push(subtype);
+                classType = subtype;
             }
             else if ((0, typeUtils_1.isNoneTypeClass)(subtype)) {
                 (0, debug_1.assert)((0, types_1.isInstantiableClass)(subtype));
-                classTypeList.push(subtype);
+                classType = subtype;
             }
             else if ((0, types_1.isFunction)(subtype) &&
                 subtype.shared.parameters.length === 2 &&
                 subtype.shared.parameters[0].category === 1 /* ParamCategory.ArgsList */ &&
                 subtype.shared.parameters[1].category === 2 /* ParamCategory.KwargsDict */) {
-                classTypeList.push(subtype);
+                classType = subtype;
             }
             else {
                 foundNonClassType = true;
+                return;
+            }
+            classTypes.push(classType);
+            // Unbounded entries may be absent, and alternative class objects
+            // are not all guaranteed to participate in the runtime check.
+            if (!isUnboundedEntry && !isAmbiguous) {
+                negativeClassTypes.push(classType);
             }
         });
     };
-    const addClassTypesRecursive = (type, recursionCount = 0) => {
+    const addClassTypesRecursive = (type, isAmbiguous, isUnboundedEntry, recursionCount, expression) => {
         if (recursionCount > types_1.maxTypeRecursionCount) {
             return;
         }
-        if ((0, types_1.isClass)(type) && types_1.TypeBase.isInstance(type) && (0, typeUtils_1.isTupleClass)(type)) {
-            if (type.priv.tupleTypeArgs) {
-                type.priv.tupleTypeArgs.forEach((tupleEntry) => {
-                    addClassTypesRecursive(tupleEntry.type, recursionCount + 1);
-                });
+        // A runtime union checks both operands, but either operand can itself
+        // be an alternative class object. Keep their certainty separate.
+        if ((0, types_1.isUnion)(type) &&
+            expression?.nodeType === 7 /* ParseNodeType.BinaryOperation */ &&
+            expression.d.operator === 6 /* OperatorType.BitwiseOr */) {
+            const leftType = evaluator.getCachedType(expression.d.leftExpr);
+            const rightType = evaluator.getCachedType(expression.d.rightExpr);
+            if (leftType &&
+                rightType &&
+                !(0, operations_1.customMetaclassSupportsMethod)(leftType, '__or__') &&
+                !(0, operations_1.customMetaclassSupportsMethod)(rightType, '__ror__')) {
+                // Match the union evaluator's normalization of None operands to NoneType.
+                const adjustedLeftType = (0, typeUtils_1.isNoneInstance)(leftType)
+                    ? (0, typeUtils_1.convertToInstantiable)(evaluator.getNoneType())
+                    : leftType;
+                const adjustedRightType = (0, typeUtils_1.isNoneInstance)(rightType)
+                    ? (0, typeUtils_1.convertToInstantiable)(evaluator.getNoneType())
+                    : rightType;
+                addClassTypesRecursive(adjustedLeftType, isAmbiguous, isUnboundedEntry, recursionCount, expression.d.leftExpr);
+                addClassTypesRecursive(adjustedRightType, isAmbiguous, isUnboundedEntry, recursionCount, expression.d.rightExpr);
+                return;
+            }
+        }
+        const isRuntimeUnion = type.props?.specialForm && types_1.ClassType.isBuiltIn(type.props.specialForm, 'UnionType');
+        const isAmbiguousType = isAmbiguous || ((0, types_1.isUnion)(type) && !isRuntimeUnion);
+        (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
+            if ((0, types_1.isClassInstance)(subtype) && (0, typeUtils_1.isTupleClass)(subtype)) {
+                if (subtype.priv.tupleTypeArgs) {
+                    let entryExpressions;
+                    if (expression?.nodeType === 52 /* ParseNodeType.Tuple */) {
+                        const expressions = [];
+                        expression.d.items.forEach((item) => {
+                            if (item.nodeType !== 56 /* ParseNodeType.Unpack */) {
+                                expressions.push(item);
+                                return;
+                            }
+                            const unpackedType = evaluator.getCachedType(item.d.expr);
+                            const entryCount = unpackedType && (0, types_1.isClassInstance)(unpackedType) && (0, typeUtils_1.isTupleClass)(unpackedType)
+                                ? unpackedType.priv.tupleTypeArgs?.length ?? 1
+                                : 1;
+                            for (let index = 0; index < entryCount; index++) {
+                                expressions.push(undefined);
+                            }
+                        });
+                        if (expressions.length === subtype.priv.tupleTypeArgs.length) {
+                            entryExpressions = expressions;
+                        }
+                    }
+                    subtype.priv.tupleTypeArgs.forEach((tupleEntry, index) => {
+                        addClassTypesRecursive(tupleEntry.type, isAmbiguousType, isUnboundedEntry || tupleEntry.isUnbounded, recursionCount + 1, entryExpressions?.[index]);
+                    });
+                }
             }
-        }
-        else {
-            (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
-                addClassTypesToList([subtype]);
-            });
-        }
+            else {
+                addClassTypesToList([subtype], isAmbiguousType, isUnboundedEntry);
+            }
+        });
     };
-    (0, typeUtils_1.doForEachSubtype)(argType, (subtype) => {
-        addClassTypesRecursive(subtype);
-    });
-    return foundNonClassType ? undefined : classTypeList;
+    addClassTypesRecursive(argType, /* isAmbiguous */ false, /* isUnboundedEntry */ false, 0, argExpr);
+    return foundNonClassType ? undefined : { classTypes, negativeClassTypes };
 }
 function narrowTypeForInstanceOrSubclass(evaluator, type, filterTypes, isInstanceCheck, isTypeIsCheck, isPositiveTest, errorNode, nodeInfo) {
+    if (!isInstanceCheck && !isTypeIsCheck && !isPositiveTest) {
+        // A custom subclass check can reject even the exact same final class.
+        // Preserve the existing narrowing policy for non-final classes, including ABCs.
+        filterTypes = filterTypes.filter((filterType) => {
+            const concreteFilterType = evaluator.makeTopLevelTypeVarsConcrete(filterType);
+            return (!(0, types_1.isInstantiableClass)(concreteFilterType) ||
+                !types_1.ClassType.isFinal(concreteFilterType) ||
+                !(0, operations_1.customMetaclassSupportsMethod)(concreteFilterType, '__subclasscheck__'));
+        });
+    }
+    if (!isPositiveTest && filterTypes.length === 0) {
+        return type;
+    }
     // First try with intersection types disallowed.
     const narrowedType = narrowTypeForInstanceOrSubclassInternal(evaluator, type, filterTypes, isInstanceCheck, isTypeIsCheck, isPositiveTest, 
     /* allowIntersections */ false, errorNode, nodeInfo);
@@ -1077,8 +1245,10 @@ function narrowTypeForInstance(evaluator, type, filterTypes, isTypeIsCheck, isPo
                 // note this case specially so we don't do any narrowing, which
                 // will generate false positives.
                 if (filterIsSuperclass) {
-                    if (!isTypeIsCheck && concreteFilterType.priv.includeSubclasses) {
-                        // If the filter type includes subclasses, we can't eliminate
+                    if (!isTypeIsCheck &&
+                        concreteFilterType.priv.includeSubclasses &&
+                        !types_1.ClassType.isFinal(concreteFilterType)) {
+                        // If the filter type includes subclasses and is not final, we can't eliminate
                         // this type in the negative direction. We'll relax this for
                         // TypeIs checks.
                         isClassRelationshipIndeterminate = true;
@@ -1869,11 +2039,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 +2110,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);