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

package/dist/analyzer/typeGuards.js

@@ -43,6 +43,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyTypeNarrowingCallback = applyTypeNarrowingCallback;
 exports.getTypeNarrowingCallback = getTypeNarrowingCallback;
 exports.getIsInstanceClassTypes = getIsInstanceClassTypes;
 exports.narrowTypeForInstanceOrSubclass = narrowTypeForInstanceOrSubclass;
@@ -66,6 +67,23 @@ const symbol_1 = require("./symbol");
 const typedDicts_1 = require("./typedDicts");
 const types_1 = require("./types");
 const typeUtils_1 = require("./typeUtils");
+function applyTypeNarrowingCallback(callback, type) {
+    const result = callback(type);
+    const baseType = (0, types_1.getInferredTupleLiteralBase)(type);
+    if (baseType === type) {
+        return result;
+    }
+    // Narrow both views at the flow boundary, not recursively within a guard.
+    // Independently established literals must survive mutable inference too.
+    const baseResult = callback(baseType);
+    if (!result && !baseResult) {
+        return undefined;
+    }
+    return {
+        type: (0, types_1.retainInferredTupleLiterals)(result?.type ?? type, (0, types_1.getInferredTupleLiteralBase)(baseResult?.type ?? baseType)),
+        isIncomplete: !!result?.isIncomplete || !!baseResult?.isIncomplete,
+    };
+}
 // Given a reference expression and a test expression, returns a callback that
 // can be used to narrow the type described by the reference expression.
 // If the specified flow node is not associated with the test expression,
@@ -135,37 +153,77 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                     };
                 }
             }
-            // Look for "type(X) is Y", "type(X) is not Y", "type(X) == Y" or "type(X) != Y".
-            if (testExpression.d.leftExpr.nodeType === 9 /* ParseNodeType.Call */) {
-                if (testExpression.d.leftExpr.d.args.length === 1 &&
-                    testExpression.d.leftExpr.d.args[0].d.argCategory === 0 /* ArgCategory.Simple */) {
-                    const arg0Expr = testExpression.d.leftExpr.d.args[0].d.valueExpr;
-                    if (isMatchingExpressionOrWalrusRhs(evaluator, reference, arg0Expr)) {
-                        const callType = evaluator.getTypeOfExpression(testExpression.d.leftExpr.d.leftExpr, 2 /* EvalFlags.CallBaseDefaults */).type;
-                        if ((0, types_1.isInstantiableClass)(callType) && types_1.ClassType.isBuiltIn(callType, 'type')) {
-                            const rhsResult = evaluator.getTypeOfExpression(testExpression.d.rightExpr);
-                            const classTypes = [];
-                            let isClassType = true;
-                            evaluator.mapSubtypesExpandTypeVars(rhsResult.type, 
-                            /* options */ undefined, (expandedSubtype) => {
-                                if ((0, types_1.isInstantiableClass)(expandedSubtype)) {
-                                    classTypes.push(expandedSubtype);
-                                }
-                                else {
-                                    isClassType = false;
-                                }
-                                return undefined;
-                            });
-                            if (isClassType && classTypes.length > 0) {
-                                return (type) => {
-                                    return {
-                                        type: narrowTypeForTypeIs(evaluator, type, classTypes, adjIsPositiveTest),
-                                        isIncomplete: !!rhsResult.isIncomplete,
-                                    };
-                                };
+            // Look for "type(X) is Y", "type(X) is not Y", "type(X) == Y" or "type(X) != Y",
+            // as well as reverse forms "Y is type(X)", "Y is not type(X)", "Y == type(X)", "Y != type(X)".
+            let typeCallNode;
+            let otherExpr;
+            const isTypeCall = (expr, referenceExpr) => expr.nodeType === 9 /* ParseNodeType.Call */ &&
+                expr.d.args.length === 1 &&
+                expr.d.args[0].d.argCategory === 0 /* ArgCategory.Simple */ &&
+                (!referenceExpr ||
+                    isMatchingExpressionOrWalrusRhs(evaluator, referenceExpr, expr.d.args[0].d.valueExpr)) &&
+                isTypeCallBase(evaluator.getTypeOfExpression(expr.d.leftExpr, 2 /* EvalFlags.CallBaseDefaults */).type);
+            // Either operand may be the call; pick the one whose argument matches the reference.
+            if (isTypeCall(testExpression.d.leftExpr, reference)) {
+                typeCallNode = testExpression.d.leftExpr;
+                otherExpr = testExpression.d.rightExpr;
+            }
+            else if (isTypeCall(testExpression.d.rightExpr, reference)) {
+                typeCallNode = testExpression.d.rightExpr;
+                otherExpr = testExpression.d.leftExpr;
+            }
+            if (typeCallNode && otherExpr) {
+                const otherResult = evaluator.getTypeOfExpression(otherExpr);
+                const classTypes = [];
+                let isClassType = true;
+                let classTypeVar;
+                if ((0, types_1.isTypeVar)(otherResult.type) && types_1.TypeBase.isInstantiable(otherResult.type)) {
+                    classTypeVar = (0, typeUtils_1.convertToInstance)(otherResult.type);
+                }
+                else if ((0, types_1.isClassInstance)(otherResult.type) &&
+                    types_1.ClassType.isBuiltIn(otherResult.type, 'type') &&
+                    otherResult.type.priv.typeArgs?.length === 1 &&
+                    (0, types_1.isTypeVar)(otherResult.type.priv.typeArgs[0])) {
+                    classTypeVar = otherResult.type.priv.typeArgs[0];
+                }
+                evaluator.mapSubtypesExpandTypeVars(otherResult.type, /* options */ undefined, (expandedSubtype) => {
+                    let instantiable;
+                    if ((0, types_1.isClass)(expandedSubtype)) {
+                        if ((0, types_1.isClassInstance)(expandedSubtype) &&
+                            types_1.ClassType.isBuiltIn(expandedSubtype, 'type') &&
+                            expandedSubtype.priv.typeArgs &&
+                            expandedSubtype.priv.typeArgs.length > 0) {
+                            const extracted = (0, typeUtils_1.convertToInstantiable)(expandedSubtype.priv.typeArgs[0], 
+                            /* includeSubclasses */ true);
+                            if ((0, types_1.isInstantiableClass)(extracted)) {
+                                instantiable = extracted;
                             }
                         }
+                        else if ((0, types_1.isInstantiableClass)(expandedSubtype)) {
+                            instantiable = expandedSubtype;
+                        }
+                    }
+                    if (instantiable) {
+                        classTypes.push(instantiable);
                     }
+                    else {
+                        isClassType = false;
+                    }
+                    return undefined;
+                });
+                if (isClassType && classTypes.length > 0) {
+                    const allowLegacyEquality = !isOrIsNotOperator &&
+                        typeCallNode === testExpression.d.leftExpr &&
+                        (((0, types_1.isInstantiableClass)(otherResult.type) &&
+                            !otherResult.type.priv.includeSubclasses &&
+                            !otherResult.type.priv.isTypeArgExplicit) ||
+                            isTypeCall(otherExpr));
+                    return (type) => {
+                        return {
+                            type: narrowTypeForTypeIs(evaluator, type, classTypes, adjIsPositiveTest, isOrIsNotOperator, classTypeVar, allowLegacyEquality),
+                            isIncomplete: !!otherResult.isIncomplete,
+                        };
+                    };
                 }
             }
             if (isOrIsNotOperator) {
@@ -428,9 +486,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, 
@@ -956,23 +1017,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
@@ -980,49 +1058,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);
@@ -1162,8 +1303,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;
@@ -1607,8 +1750,14 @@ function narrowTypeForContainerType(evaluator, referenceType, containerType, isP
         !containerType.priv.tupleTypeArgs) {
         return referenceType;
     }
-    // Determine which tuple types can be eliminated. Only "None" and
-    // literal types can be handled here.
+    // Determine which tuple types can be eliminated. Only "None",
+    // literal types, and final instantiable classes can be handled here.
+    // Non-final instantiable classes (type[A]) cannot be eliminated in negative
+    // tests because a subclass SubA(A) reaches the negative branch at runtime
+    // (since SubA != A). Generic classes are also excluded because a
+    // specialized class object like Box[int] is not the same runtime object
+    // as Box. Classes that define or inherit __class_getitem__ are excluded
+    // for the same reason.
     const typesToEliminate = [];
     containerType.priv.tupleTypeArgs.forEach((tupleEntry) => {
         if (!tupleEntry.isUnbounded) {
@@ -1618,14 +1767,23 @@ function narrowTypeForContainerType(evaluator, referenceType, containerType, isP
             else if ((0, types_1.isClassInstance)(tupleEntry.type) && (0, typeUtils_1.isLiteralType)(tupleEntry.type)) {
                 typesToEliminate.push(tupleEntry.type);
             }
+            else if ((0, types_1.isInstantiableClass)(tupleEntry.type) &&
+                types_1.ClassType.isFinal(tupleEntry.type) &&
+                tupleEntry.type.shared.typeParams.length === 0 &&
+                !(0, typeUtils_1.lookUpClassMember)(tupleEntry.type, '__class_getitem__')) {
+                typesToEliminate.push(tupleEntry.type);
+            }
         }
     });
     if (typesToEliminate.length === 0) {
         return referenceType;
     }
-    return (0, typeUtils_1.mapSubtypes)(referenceType, (referenceSubtype) => {
-        referenceSubtype = evaluator.makeTopLevelTypeVarsConcrete(referenceSubtype);
-        if ((0, types_1.isClassInstance)(referenceSubtype) && referenceSubtype.priv.literalValue === undefined) {
+    const canNarrowLiterals = typesToEliminate.some(types_1.isClassInstance);
+    return (0, typeUtils_1.mapSubtypes)(referenceType, (unexpandedSubtype) => {
+        const referenceSubtype = evaluator.makeTopLevelTypeVarsConcrete(unexpandedSubtype);
+        if (canNarrowLiterals &&
+            (0, types_1.isClassInstance)(referenceSubtype) &&
+            referenceSubtype.priv.literalValue === undefined) {
             // If we're able to enumerate all possible literal values
             // (for bool or enum), we can eliminate all others in a negative test.
             const allLiteralTypes = enumerateLiteralsForType(evaluator, referenceSubtype);
@@ -1636,7 +1794,7 @@ function narrowTypeForContainerType(evaluator, referenceType, containerType, isP
         if (typesToEliminate.some((t) => (0, types_1.isTypeSame)(t, referenceSubtype))) {
             return undefined;
         }
-        return referenceSubtype;
+        return unexpandedSubtype;
     });
 }
 function getElementTypeForContainerNarrowing(containerType) {
@@ -1906,36 +2064,172 @@ function narrowTypeForDiscriminatedFieldNoneComparison(evaluator, referenceType,
         return subtype;
     });
 }
+function isTypeCallBase(callType) {
+    return (0, types_1.isInstantiableClass)(callType) && types_1.ClassType.isBuiltIn(callType, 'type');
+}
+// Determines whether two classes have incompatible disjoint bases (PEP 800),
+// in which case no class can derive from both of them.
+function areDisjointBasesIncompatible(classType1, classType2) {
+    const base1 = types_1.ClassType.getDisjointBase(classType1);
+    const base2 = types_1.ClassType.getDisjointBase(classType2);
+    return !!base1 && !!base2 && !types_1.ClassType.getMostDerivedDisjointBase([base1, base2]);
+}
+// Fill gradual holes without replacing facts inferred from the guarded value.
+function fillTypeGuardGradualArgs(input, hint, results, recursionCount = 0) {
+    if (!hint || input === hint || recursionCount > types_1.maxTypeRecursionCount) {
+        return input;
+    }
+    if ((0, types_1.isAnyOrUnknown)(input)) {
+        return (0, types_1.isAnyOrUnknown)(hint) ? ((0, types_1.isAny)(hint) ? hint : input) : hint;
+    }
+    if (!(0, types_1.isClass)(input) || !(0, types_1.isClass)(hint) || !types_1.ClassType.isSameGenericClass(input, hint)) {
+        return input;
+    }
+    let inputResults = results.get(input);
+    const cachedResult = inputResults?.get(hint);
+    if (cachedResult !== undefined) {
+        return cachedResult;
+    }
+    if (!inputResults) {
+        inputResults = new Map();
+        results.set(input, inputResults);
+    }
+    // Bound recursive aliases and reuse shared argument graphs within this narrowing operation.
+    inputResults.set(hint, input);
+    const inputTuple = input.priv.tupleTypeArgs;
+    const hintTuple = hint.priv.tupleTypeArgs;
+    if (inputTuple || hintTuple) {
+        if (!inputTuple ||
+            !hintTuple ||
+            inputTuple.length !== hintTuple.length ||
+            inputTuple.some((arg, index) => arg.isUnbounded !== hintTuple[index].isUnbounded ||
+                !!arg.isOptional !== !!hintTuple[index].isOptional)) {
+            return input;
+        }
+        const tupleArgs = inputTuple.map((arg, index) => ({
+            ...arg,
+            type: fillTypeGuardGradualArgs(arg.type, hintTuple[index].type, results, recursionCount + 1),
+        }));
+        const result = tupleArgs.every((arg, index) => arg.type === inputTuple[index].type)
+            ? input
+            : (0, typeUtils_1.specializeTupleClass)(input, tupleArgs, input.priv.isTypeArgExplicit, input.priv.isUnpacked);
+        inputResults.set(hint, result);
+        return result;
+    }
+    const inputArgs = input.priv.typeArgs;
+    const hintArgs = hint.priv.typeArgs;
+    if (!inputArgs || !hintArgs || inputArgs.length !== hintArgs.length) {
+        return input;
+    }
+    const typeArgs = inputArgs.map((arg, index) => fillTypeGuardGradualArgs(arg, hintArgs[index], results, recursionCount + 1));
+    const result = typeArgs.every((arg, index) => arg === inputArgs[index])
+        ? input
+        : types_1.ClassType.specialize(input, typeArgs, input.priv.isTypeArgExplicit);
+    inputResults.set(hint, result);
+    return result;
+}
 // Attempts to narrow a type based on a "type(x) is y" or "type(x) is not y" check.
-function narrowTypeForTypeIs(evaluator, type, classTypes, isPositiveTest) {
+function narrowTypeForTypeIs(evaluator, type, classTypes, isPositiveTest, isIsOperator, classTypeVar, allowLegacyEquality) {
+    const metaclassEqualityResults = isIsOperator ? undefined : new Map();
+    const hasEqualitySemantics = allowLegacyEquality
+        ? hasDeclaredIdentityEqualitySemantics
+        : hasIdentityEqualitySemantics;
+    if (metaclassEqualityResults &&
+        classTypes.some((classType) => !hasEqualitySemantics(classType, metaclassEqualityResults))) {
+        return type;
+    }
     // We currently don't support narrowing in the negative direction
     // when there are more than one class types.
     if (!isPositiveTest && classTypes.length > 1) {
         return type;
     }
+    // Retain the TypeVar rather than its expanded constraints so assignments and loop joins preserve correlation.
+    if (isIsOperator && isPositiveTest && classTypeVar && (0, types_1.isAnyOrUnknown)(type)) {
+        return classTypeVar;
+    }
+    let gradualArgResults;
     const typesToCombine = classTypes.map((classType) => {
         return evaluator.mapSubtypesExpandTypeVars(type, 
         /* options */ undefined, (subtype, unexpandedSubtype) => {
             if ((0, types_1.isClassInstance)(subtype)) {
-                const matches = types_1.ClassType.isDerivedFrom(classType, types_1.ClassType.cloneAsInstantiable(subtype));
+                const isLiteral = subtype.priv.literalValue !== undefined;
+                const instantiableSubtype = isLiteral
+                    ? types_1.ClassType.cloneIncludeSubclasses(types_1.ClassType.cloneAsInstantiable(types_1.ClassType.cloneWithLiteral(subtype, undefined)), 
+                    /* includeSubclasses */ false)
+                    : types_1.ClassType.cloneAsInstantiable(subtype);
+                if (metaclassEqualityResults &&
+                    !hasEqualitySemantics(instantiableSubtype, metaclassEqualityResults)) {
+                    return unexpandedSubtype;
+                }
+                const matches = types_1.ClassType.isDerivedFrom(classType, instantiableSubtype);
+                // A literal has an exact runtime class, not an arbitrary subclass.
+                if (matches && isLiteral && !types_1.ClassType.isSameGenericClass(instantiableSubtype, classType)) {
+                    return isPositiveTest ? undefined : subtype;
+                }
                 if (isPositiveTest) {
                     if (matches) {
-                        if (types_1.ClassType.isSameGenericClass(types_1.ClassType.cloneAsInstantiable(subtype), classType)) {
+                        if (types_1.ClassType.isSameGenericClass(instantiableSubtype, classType)) {
                             return (0, typeUtils_1.addConditionToType)(subtype, (0, typeUtils_1.getTypeCondition)(classType));
                         }
-                        return (0, typeUtils_1.addConditionToType)(types_1.ClassType.cloneAsInstance(classType), subtype.props?.condition);
+                        let narrowedClass = classType;
+                        if (subtype.priv.typeArgs || subtype.priv.tupleTypeArgs) {
+                            if (classType.shared.typeParams.length > 0) {
+                                if ((0, typeUtils_1.containsAnyRecursive)(classType) ||
+                                    !evaluator.assignType(subtype, types_1.ClassType.cloneAsInstance(classType))) {
+                                    const genericClass = (0, typeUtils_1.selfSpecializeClass)(types_1.ClassType.specialize(classType, undefined));
+                                    const constraints = new constraintTracker_1.ConstraintTracker();
+                                    if (!evaluator.assignType(subtype, types_1.ClassType.cloneAsInstance(genericClass), undefined, constraints, 2 /* AssignTypeFlags.Contravariant */ |
+                                        2048 /* AssignTypeFlags.PopulateExpectedType */ |
+                                        4096 /* AssignTypeFlags.SkipPopulateUnknownExpectedType */)) {
+                                        return (0, typeUtils_1.addConditionToType)(subtype, (0, typeUtils_1.getTypeCondition)(classType));
+                                    }
+                                    const specializedClass = evaluator.solveAndApplyConstraints(genericClass, constraints, {
+                                        replaceUnsolved: {
+                                            scopeIds: (0, typeUtils_1.getTypeVarScopeIds)(classType),
+                                            useUnknown: true,
+                                            tupleClassType: evaluator.getTupleClassType(),
+                                        },
+                                    });
+                                    if (!(0, types_1.isInstantiableClass)(specializedClass)) {
+                                        return (0, typeUtils_1.addConditionToType)(subtype, (0, typeUtils_1.getTypeCondition)(classType));
+                                    }
+                                    const results = (gradualArgResults ?? (gradualArgResults = new Map()));
+                                    narrowedClass = types_1.ClassType.specialize(specializedClass, specializedClass.priv.typeArgs?.map((arg, index) => fillTypeGuardGradualArgs(arg, classType.priv.typeArgs?.[index], results)));
+                                }
+                            }
+                            else if (!evaluator.assignType(subtype, types_1.ClassType.cloneAsInstance(classType))) {
+                                return classType.priv.includeSubclasses && !types_1.ClassType.isFinal(classType)
+                                    ? (0, typeUtils_1.addConditionToType)(subtype, (0, typeUtils_1.getTypeCondition)(classType))
+                                    : undefined;
+                            }
+                        }
+                        return (0, typeUtils_1.addConditionToType)(types_1.ClassType.cloneAsInstance(narrowedClass), subtype.props?.condition);
                     }
                     if (!classType.priv.includeSubclasses) {
+                        if (evaluator.assignType(subtype, types_1.ClassType.cloneAsInstance(classType))) {
+                            return (0, typeUtils_1.addConditionToType)(types_1.ClassType.cloneAsInstance(classType), (0, typeUtils_1.getTypeCondition)(subtype));
+                        }
+                        return undefined;
+                    }
+                    // A subclass of both the subtype and the class could satisfy the
+                    // comparison, so eliminate the subtype only if no such class can exist.
+                    if ((types_1.ClassType.isFinal(classType) ||
+                        isLiteral ||
+                        types_1.ClassType.isFinal(instantiableSubtype) ||
+                        areDisjointBasesIncompatible(instantiableSubtype, classType)) &&
+                        !evaluator.assignType(types_1.ClassType.cloneAsInstance(classType), subtype) &&
+                        !evaluator.assignType(subtype, types_1.ClassType.cloneAsInstance(classType))) {
                         return undefined;
                     }
                     if (!(0, types_1.isTypeVar)(unexpandedSubtype) || !types_1.TypeVarType.isSelf(unexpandedSubtype)) {
                         return (0, typeUtils_1.addConditionToType)(subtype, classType.props?.condition);
                     }
                 }
-                if (!classType.priv.includeSubclasses) {
-                    // If the class if marked final and it matches, then
+                // A final class has no subclasses, so it is treated as an exact class.
+                if (!classType.priv.includeSubclasses || types_1.ClassType.isFinal(classType)) {
+                    // If the runtime class is exact and it matches, then
                     // we can eliminate it in the negative case.
-                    if (matches && types_1.ClassType.isFinal(subtype)) {
+                    if (matches && (isLiteral || types_1.ClassType.isFinal(instantiableSubtype))) {
                         return undefined;
                     }
                     // We can't eliminate the subtype in the negative
@@ -1945,6 +2239,9 @@ function narrowTypeForTypeIs(evaluator, type, classTypes, isPositiveTest) {
                 }
             }
             if ((0, types_1.isAnyOrUnknown)(subtype)) {
+                if (metaclassEqualityResults && !allowLegacyEquality) {
+                    return subtype;
+                }
                 return isPositiveTest
                     ? types_1.ClassType.cloneAsInstance((0, typeUtils_1.addConditionToType)(classType, (0, typeUtils_1.getTypeCondition)(subtype)))
                     : subtype;
@@ -1969,6 +2266,10 @@ function hasIdentityEqualitySemantics(classType, metaclassEqualityResults) {
     if (classType.shared.typeParams.length > 0) {
         return false;
     }
+    return hasDeclaredIdentityEqualitySemantics(classType, metaclassEqualityResults);
+}
+// Legacy forward type(x) equality guards check declared metaclasses without closing subclass hierarchies.
+function hasDeclaredIdentityEqualitySemantics(classType, metaclassEqualityResults) {
     const metaclass = classType.shared.effectiveMetaclass;
     if (!metaclass ||
         !(0, types_1.isInstantiableClass)(metaclass) ||