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

package/dist/analyzer/typeEvaluatorTypes.d.ts

@@ -16,7 +16,7 @@ import { SpeculativeModeOptions } from './typeCacheUtils';
 import { PrintTypeFlags } from './typePrinter';
 import { AnyType, ClassType, FunctionParam, FunctionType, OverloadedType, TupleTypeArg, Type, TypeCondition, TypeVarType, UnknownType, Variance } from './types';
 import { ApplyTypeVarOptions, ClassMember, InferenceContext, MemberAccessFlags } from './typeUtils';
-export declare const maxSubtypesForInferredType = 64;
+export { maxSubtypesForInferredType } from './types';
 export declare const maxInferredContainerDepth = 8;
 export declare const enum EvalFlags {
     None = 0,

package/dist/analyzer/typeEvaluatorTypes.js

@@ -10,9 +10,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AssignTypeFlags = exports.Reachability = exports.EvalFlags = exports.maxInferredContainerDepth = exports.maxSubtypesForInferredType = void 0;
 exports.ensureExpectedTypeCandidates = ensureExpectedTypeCandidates;
-// Maximum number of unioned subtypes for an inferred type (e.g.
-// a list) before the type is considered an "Any".
-exports.maxSubtypesForInferredType = 64;
+var types_1 = require("./types");
+Object.defineProperty(exports, "maxSubtypesForInferredType", { enumerable: true, get: function () { return types_1.maxSubtypesForInferredType; } });
 // In certain loops, it's possible to construct arbitrarily-deep containers
 // (tuples, lists, sets, or dicts) which can lead to infinite type analysis.
 // This limits the depth.

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.d.ts

@@ -11,6 +11,7 @@ export interface IsInstanceClassTypeInfo {
     negativeClassTypes: (ClassType | TypeVarType | FunctionType)[];
 }
 export type TypeNarrowingCallback = (type: Type) => TypeNarrowingResult | undefined;
+export declare function applyTypeNarrowingCallback(callback: 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, 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;

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) {
@@ -1692,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) {
@@ -1703,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);
@@ -1721,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) {
@@ -1991,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
@@ -2030,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;
@@ -2054,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) ||