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

package/dist/analyzer/typeEvaluator/typeGuardNarrowing.js

@@ -0,0 +1,1683 @@
+"use strict";
+/*
+ * typeGuardNarrowing.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ *
+ * Helper logic shared by type narrowing entry points.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNoneEllipsisNarrowingInfo = getNoneEllipsisNarrowingInfo;
+exports.getTypeIsCallNarrowingInfo = getTypeIsCallNarrowingInfo;
+exports.getIsLiteralOrClassNarrowingInfo = getIsLiteralOrClassNarrowingInfo;
+exports.getIndexedLiteralNarrowingInfo = getIndexedLiteralNarrowingInfo;
+exports.getIsInstanceCallNarrowingInfo = getIsInstanceCallNarrowingInfo;
+exports.getBoolCallNarrowingInfo = getBoolCallNarrowingInfo;
+exports.getNotExpressionNarrowingInfo = getNotExpressionNarrowingInfo;
+exports.getEqualsNarrowingInfo = getEqualsNarrowingInfo;
+exports.getMemberAccessNarrowingInfo = getMemberAccessNarrowingInfo;
+exports.getLenComparisonNarrowingInfo = getLenComparisonNarrowingInfo;
+exports.getInOperatorNarrowingInfo = getInOperatorNarrowingInfo;
+exports.narrowTypeForTruthiness = narrowTypeForTruthiness;
+exports.narrowTupleTypeForIsNone = narrowTupleTypeForIsNone;
+exports.narrowTypeForIsNone = narrowTypeForIsNone;
+exports.narrowTypeForIsEllipsis = narrowTypeForIsEllipsis;
+exports.getIsInstanceClassTypes = getIsInstanceClassTypes;
+exports.narrowTypeForInstanceOrSubclass = narrowTypeForInstanceOrSubclass;
+exports.narrowTypeForTupleLength = narrowTypeForTupleLength;
+exports.narrowTypeForContainerType = narrowTypeForContainerType;
+exports.getElementTypeForContainerNarrowing = getElementTypeForContainerNarrowing;
+exports.narrowTypeForContainerElementType = narrowTypeForContainerElementType;
+exports.narrowTypeForTypedDictKey = narrowTypeForTypedDictKey;
+exports.narrowTypeForDiscriminatedDictEntryComparison = narrowTypeForDiscriminatedDictEntryComparison;
+exports.narrowTypeForDiscriminatedTupleComparison = narrowTypeForDiscriminatedTupleComparison;
+exports.narrowTypeForDiscriminatedLiteralFieldComparison = narrowTypeForDiscriminatedLiteralFieldComparison;
+exports.narrowTypeForDiscriminatedFieldNoneComparison = narrowTypeForDiscriminatedFieldNoneComparison;
+exports.narrowTypeForTypeIs = narrowTypeForTypeIs;
+exports.narrowTypeForClassComparison = narrowTypeForClassComparison;
+exports.narrowTypeForLiteralComparison = narrowTypeForLiteralComparison;
+exports.enumerateLiteralsForType = enumerateLiteralsForType;
+exports.isNameSameScope = isNameSameScope;
+exports.narrowTypeForUserDefinedTypeGuard = narrowTypeForUserDefinedTypeGuard;
+const debug_1 = require("../../common/debug");
+const analyzerNodeInfo_1 = require("../analyzerNodeInfo");
+const constraintTracker_1 = require("../constraintTracker");
+const enums_1 = require("../enums");
+const operations_1 = require("../operations");
+const scopeUtils_1 = require("../scopeUtils");
+const typedDicts_1 = require("../typedDicts");
+const types_1 = require("../types");
+const typeUtils_1 = require("../typeUtils");
+function getNoneEllipsisNarrowingInfo(ctx, reference, testExpression, isPositiveTest) {
+    if (testExpression.nodeType !== 7 /* ParseNodeType.BinaryOperation */) {
+        return undefined;
+    }
+    const isOrIsNotOperator = testExpression.d.operator === 39 /* OperatorType.Is */ || testExpression.d.operator === 40 /* OperatorType.IsNot */;
+    const equalsOrNotEqualsOperator = testExpression.d.operator === 12 /* OperatorType.Equals */ || testExpression.d.operator === 28 /* OperatorType.NotEquals */;
+    if (!isOrIsNotOperator && !equalsOrNotEqualsOperator) {
+        return undefined;
+    }
+    const adjIsPositiveTest = testExpression.d.operator === 39 /* OperatorType.Is */ || testExpression.d.operator === 12 /* OperatorType.Equals */
+        ? isPositiveTest
+        : !isPositiveTest;
+    if (testExpression.d.rightExpr.nodeType === 14 /* ParseNodeType.Constant */ &&
+        testExpression.d.rightExpr.d.constType === 27 /* KeywordType.None */) {
+        if (ctx.isMatchingExpressionOrWalrusRhs(reference, testExpression.d.leftExpr)) {
+            return { kind: 'none', adjIsPositiveTest };
+        }
+        const leftExpression = testExpression.d.leftExpr;
+        if (leftExpression.nodeType === 27 /* ParseNodeType.Index */ &&
+            ctx.isMatchingExpression(reference, leftExpression.d.leftExpr) &&
+            leftExpression.d.items.length === 1 &&
+            !leftExpression.d.trailingComma &&
+            leftExpression.d.items[0].d.argCategory === 0 /* ArgCategory.Simple */ &&
+            !leftExpression.d.items[0].d.name &&
+            leftExpression.d.items[0].d.valueExpr.nodeType === 40 /* ParseNodeType.Number */ &&
+            leftExpression.d.items[0].d.valueExpr.d.isInteger &&
+            !leftExpression.d.items[0].d.valueExpr.d.isImaginary) {
+            const indexValue = leftExpression.d.items[0].d.valueExpr.d.value;
+            if (typeof indexValue === 'number') {
+                return { kind: 'tuple-none', adjIsPositiveTest, tupleIndex: indexValue };
+            }
+        }
+    }
+    if (testExpression.d.rightExpr.nodeType === 21 /* ParseNodeType.Ellipsis */ &&
+        ctx.isMatchingExpressionOrWalrusRhs(reference, testExpression.d.leftExpr)) {
+        return { kind: 'ellipsis', adjIsPositiveTest };
+    }
+    return undefined;
+}
+function isTypeCallBase(callType) {
+    return (0, types_1.isInstantiableClass)(callType) && types_1.ClassType.isBuiltIn(callType, 'type');
+}
+function getTypeIsCallNarrowingInfo(ctx, reference, testExpression, isPositiveTest) {
+    if (testExpression.nodeType !== 7 /* ParseNodeType.BinaryOperation */) {
+        return undefined;
+    }
+    const isOrIsNotOperator = testExpression.d.operator === 39 /* OperatorType.Is */ || testExpression.d.operator === 40 /* OperatorType.IsNot */;
+    const equalsOrNotEqualsOperator = testExpression.d.operator === 12 /* OperatorType.Equals */ || testExpression.d.operator === 28 /* OperatorType.NotEquals */;
+    if (!isOrIsNotOperator && !equalsOrNotEqualsOperator) {
+        return undefined;
+    }
+    const adjIsPositiveTest = testExpression.d.operator === 39 /* OperatorType.Is */ || testExpression.d.operator === 12 /* OperatorType.Equals */
+        ? isPositiveTest
+        : !isPositiveTest;
+    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 || ctx.isMatchingExpressionOrWalrusRhs(referenceExpr, expr.d.args[0].d.valueExpr)) &&
+        isTypeCallBase(ctx.getTypeOfExpression(expr.d.leftExpr, 2 /* EvalFlags.CallBaseDefaults */).type);
+    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) {
+        return undefined;
+    }
+    const otherResult = ctx.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];
+    }
+    ctx.mapSubtypesExpandTypeVars(otherResult.type, (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 = expandedSubtype.priv.typeArgs[0];
+                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) {
+        return undefined;
+    }
+    const allowLegacyEquality = !isOrIsNotOperator &&
+        typeCallNode === testExpression.d.leftExpr &&
+        (((0, types_1.isInstantiableClass)(otherResult.type) &&
+            !otherResult.type.priv.includeSubclasses &&
+            !otherResult.type.priv.isTypeArgExplicit) ||
+            isTypeCall(otherExpr));
+    return {
+        classTypes,
+        classTypeVar,
+        adjIsPositiveTest,
+        isOrIsNotOperator,
+        allowLegacyEquality,
+        isIncomplete: !!otherResult.isIncomplete,
+    };
+}
+function getIsLiteralOrClassNarrowingInfo(ctx, reference, testExpression, isPositiveTest) {
+    if (testExpression.nodeType !== 7 /* ParseNodeType.BinaryOperation */) {
+        return undefined;
+    }
+    if (testExpression.d.operator !== 39 /* OperatorType.Is */ && testExpression.d.operator !== 40 /* OperatorType.IsNot */) {
+        return undefined;
+    }
+    if (!ctx.isMatchingExpressionOrWalrusRhs(reference, testExpression.d.leftExpr)) {
+        return undefined;
+    }
+    const adjIsPositiveTest = testExpression.d.operator === 39 /* OperatorType.Is */ ? isPositiveTest : !isPositiveTest;
+    const rightTypeResult = ctx.getTypeOfExpression(testExpression.d.rightExpr);
+    const rightType = rightTypeResult.type;
+    if ((0, types_1.isClassInstance)(rightType) && rightType.priv.literalValue !== undefined) {
+        return {
+            kind: 'literal',
+            rightType,
+            adjIsPositiveTest,
+            isIncomplete: !!rightTypeResult.isIncomplete,
+        };
+    }
+    if ((0, types_1.isInstantiableClass)(rightType)) {
+        return {
+            kind: 'class',
+            rightType,
+            adjIsPositiveTest,
+            isIncomplete: !!rightTypeResult.isIncomplete,
+        };
+    }
+    return undefined;
+}
+function getIndexedLiteralNarrowingInfo(ctx, reference, testExpression, isPositiveTest) {
+    if (testExpression.nodeType !== 7 /* ParseNodeType.BinaryOperation */) {
+        return undefined;
+    }
+    if (testExpression.d.operator !== 39 /* OperatorType.Is */ && testExpression.d.operator !== 40 /* OperatorType.IsNot */) {
+        return undefined;
+    }
+    if (testExpression.d.leftExpr.nodeType !== 27 /* ParseNodeType.Index */ ||
+        testExpression.d.leftExpr.d.items.length !== 1 ||
+        testExpression.d.leftExpr.d.trailingComma ||
+        testExpression.d.leftExpr.d.items[0].d.argCategory !== 0 /* ArgCategory.Simple */ ||
+        !ctx.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr)) {
+        return undefined;
+    }
+    const indexTypeResult = ctx.getTypeOfExpression(testExpression.d.leftExpr.d.items[0].d.valueExpr);
+    const indexType = indexTypeResult.type;
+    if (!(0, types_1.isClassInstance)(indexType) || !(0, typeUtils_1.isLiteralType)(indexType)) {
+        return undefined;
+    }
+    const rightTypeResult = ctx.getTypeOfExpression(testExpression.d.rightExpr);
+    const rightType = rightTypeResult.type;
+    if (!(0, types_1.isClassInstance)(rightType) || rightType.priv.literalValue === undefined) {
+        return undefined;
+    }
+    const adjIsPositiveTest = testExpression.d.operator === 39 /* OperatorType.Is */ ? isPositiveTest : !isPositiveTest;
+    if (types_1.ClassType.isBuiltIn(indexType, 'str')) {
+        return {
+            kind: 'dict',
+            indexType,
+            rightType,
+            adjIsPositiveTest,
+            isIncomplete: !!indexTypeResult.isIncomplete,
+        };
+    }
+    if (types_1.ClassType.isBuiltIn(indexType, 'int')) {
+        let canNarrow = false;
+        if (types_1.ClassType.isBuiltIn(rightType, 'bool')) {
+            canNarrow = true;
+        }
+        else if (rightType.priv.literalValue instanceof types_1.EnumLiteral) {
+            canNarrow = true;
+        }
+        if (canNarrow) {
+            return {
+                kind: 'tuple',
+                indexType,
+                rightType,
+                adjIsPositiveTest,
+                isIncomplete: !!rightTypeResult.isIncomplete,
+            };
+        }
+    }
+    return undefined;
+}
+function getIsInstanceCallNarrowingInfo(ctx, reference, testExpression, isPositiveTest) {
+    if (testExpression.nodeType !== 9 /* ParseNodeType.Call */ || testExpression.d.args.length !== 2) {
+        return undefined;
+    }
+    const arg0Expr = testExpression.d.args[0].d.valueExpr;
+    const arg1Expr = testExpression.d.args[1].d.valueExpr;
+    if (!ctx.isMatchingExpressionOrWalrusRhs(reference, arg0Expr)) {
+        return undefined;
+    }
+    const callTypeResult = ctx.getTypeOfExpression(testExpression.d.leftExpr, 2 /* EvalFlags.CallBaseDefaults */);
+    const callType = callTypeResult.type;
+    if (!(0, types_1.isFunction)(callType) || !types_1.FunctionType.isBuiltIn(callType, ['isinstance', 'issubclass'])) {
+        return undefined;
+    }
+    const isInstanceCheck = types_1.FunctionType.isBuiltIn(callType, 'isinstance');
+    const arg1TypeResult = ctx.getTypeOfExpression(arg1Expr, 536871546 /* EvalFlags.IsInstanceArgDefaults */);
+    const classTypeInfo = ctx.getIsInstanceClassTypes(arg1TypeResult.type, arg1Expr);
+    const isIncomplete = !!callTypeResult.isIncomplete || !!arg1TypeResult.isIncomplete;
+    if (classTypeInfo) {
+        return {
+            kind: 'narrow',
+            classTypeList: isPositiveTest ? classTypeInfo.classTypes : classTypeInfo.negativeClassTypes,
+            isInstanceCheck,
+            isIncomplete,
+        };
+    }
+    if (isIncomplete) {
+        return { kind: 'incomplete', isIncomplete: true };
+    }
+    return undefined;
+}
+function getBoolCallNarrowingInfo(ctx, reference, testExpression) {
+    if (testExpression.nodeType !== 9 /* ParseNodeType.Call */ ||
+        testExpression.d.args.length !== 1 ||
+        testExpression.d.args[0].d.name) {
+        return undefined;
+    }
+    if (!ctx.isMatchingExpressionOrWalrusRhs(reference, testExpression.d.args[0].d.valueExpr)) {
+        return undefined;
+    }
+    const callTypeResult = ctx.getTypeOfExpression(testExpression.d.leftExpr, 2 /* EvalFlags.CallBaseDefaults */);
+    const callType = callTypeResult.type;
+    if ((0, types_1.isInstantiableClass)(callType) && types_1.ClassType.isBuiltIn(callType, 'bool')) {
+        return { isIncomplete: !!callTypeResult.isIncomplete };
+    }
+    return undefined;
+}
+function getNotExpressionNarrowingInfo(reference, testExpression, isPositiveTest) {
+    if (testExpression.nodeType === 55 /* ParseNodeType.UnaryOperation */ &&
+        testExpression.d.operator === 38 /* OperatorType.Not */ &&
+        reference !== testExpression) {
+        return {
+            innerExpression: testExpression.d.expr,
+            adjIsPositiveTest: !isPositiveTest,
+        };
+    }
+    return undefined;
+}
+function getEqualsNarrowingInfo(ctx, reference, testExpression, isPositiveTest) {
+    if (testExpression.nodeType !== 7 /* ParseNodeType.BinaryOperation */) {
+        return undefined;
+    }
+    const equalsOrNotEqualsOperator = testExpression.d.operator === 12 /* OperatorType.Equals */ || testExpression.d.operator === 28 /* OperatorType.NotEquals */;
+    if (!equalsOrNotEqualsOperator) {
+        return undefined;
+    }
+    const adjIsPositiveTest = testExpression.d.operator === 12 /* OperatorType.Equals */ ? isPositiveTest : !isPositiveTest;
+    if (ctx.isMatchingExpressionOrWalrusRhs(reference, testExpression.d.leftExpr)) {
+        const rightTypeResult = ctx.getTypeOfExpression(testExpression.d.rightExpr);
+        const rightType = rightTypeResult.type;
+        if ((0, types_1.isClassInstance)(rightType) && rightType.priv.literalValue !== undefined) {
+            return {
+                kind: 'literal',
+                rightType,
+                adjIsPositiveTest,
+                isIncomplete: !!rightTypeResult.isIncomplete,
+            };
+        }
+        if ((0, types_1.isInstantiableClass)(rightType)) {
+            return {
+                kind: 'class',
+                rightType,
+                adjIsPositiveTest,
+                isIncomplete: !!rightTypeResult.isIncomplete,
+            };
+        }
+    }
+    if (testExpression.d.leftExpr.nodeType === 27 /* ParseNodeType.Index */ &&
+        testExpression.d.leftExpr.d.items.length === 1 &&
+        !testExpression.d.leftExpr.d.trailingComma &&
+        testExpression.d.leftExpr.d.items[0].d.argCategory === 0 /* ArgCategory.Simple */ &&
+        ctx.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr)) {
+        const indexTypeResult = ctx.getTypeOfExpression(testExpression.d.leftExpr.d.items[0].d.valueExpr);
+        const indexType = indexTypeResult.type;
+        if ((0, types_1.isClassInstance)(indexType) && (0, typeUtils_1.isLiteralType)(indexType) && types_1.ClassType.isBuiltIn(indexType, ['str', 'int'])) {
+            const rightTypeResult = ctx.getTypeOfExpression(testExpression.d.rightExpr);
+            const rightType = rightTypeResult.type;
+            if ((0, typeUtils_1.isLiteralTypeOrUnion)(rightType)) {
+                return {
+                    kind: 'index',
+                    indexType,
+                    rightType,
+                    adjIsPositiveTest,
+                    isIncomplete: !!indexTypeResult.isIncomplete || !!rightTypeResult.isIncomplete,
+                };
+            }
+        }
+    }
+    return undefined;
+}
+function getMemberAccessNarrowingInfo(ctx, reference, testExpression, isPositiveTest) {
+    if (testExpression.nodeType !== 7 /* ParseNodeType.BinaryOperation */) {
+        return undefined;
+    }
+    const isOrIsNotOperator = testExpression.d.operator === 39 /* OperatorType.Is */ || testExpression.d.operator === 40 /* OperatorType.IsNot */;
+    const equalsOrNotEqualsOperator = testExpression.d.operator === 12 /* OperatorType.Equals */ || testExpression.d.operator === 28 /* OperatorType.NotEquals */;
+    if (!isOrIsNotOperator && !equalsOrNotEqualsOperator) {
+        return undefined;
+    }
+    if (testExpression.d.leftExpr.nodeType !== 35 /* ParseNodeType.MemberAccess */ ||
+        !ctx.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr)) {
+        return undefined;
+    }
+    const adjIsPositiveTest = testExpression.d.operator === 39 /* OperatorType.Is */ || testExpression.d.operator === 12 /* OperatorType.Equals */
+        ? isPositiveTest
+        : !isPositiveTest;
+    if (isOrIsNotOperator &&
+        testExpression.d.rightExpr.nodeType === 14 /* ParseNodeType.Constant */ &&
+        testExpression.d.rightExpr.d.constType === 27 /* KeywordType.None */) {
+        return {
+            kind: 'none',
+            memberName: testExpression.d.leftExpr.d.member.d.value,
+            adjIsPositiveTest,
+            isIncomplete: false,
+        };
+    }
+    const rightTypeResult = ctx.getTypeOfExpression(testExpression.d.rightExpr);
+    const rightType = rightTypeResult.type;
+    if ((0, types_1.isClassInstance)(rightType)) {
+        const isLiteralEqualsCase = equalsOrNotEqualsOperator && (rightType.priv.literalValue !== undefined || (0, typeUtils_1.isNoneInstance)(rightType));
+        const isLiteralIdentityCase = isOrIsNotOperator &&
+            (types_1.ClassType.isEnumClass(rightType) || types_1.ClassType.isBuiltIn(rightType, 'bool')) &&
+            rightType.priv.literalValue !== undefined;
+        if (isLiteralEqualsCase || isLiteralIdentityCase) {
+            return {
+                kind: 'literal',
+                memberName: testExpression.d.leftExpr.d.member.d.value,
+                rightType,
+                adjIsPositiveTest,
+                isIncomplete: !!rightTypeResult.isIncomplete,
+            };
+        }
+    }
+    return undefined;
+}
+function getLenComparisonNarrowingInfo(ctx, reference, testExpression, isPositiveTest) {
+    if (testExpression.nodeType !== 7 /* ParseNodeType.BinaryOperation */) {
+        return undefined;
+    }
+    const comparisonOperator = testExpression.d.operator === 12 /* OperatorType.Equals */ ||
+        testExpression.d.operator === 28 /* OperatorType.NotEquals */ ||
+        testExpression.d.operator === 20 /* OperatorType.LessThan */ ||
+        testExpression.d.operator === 21 /* OperatorType.LessThanOrEqual */ ||
+        testExpression.d.operator === 15 /* OperatorType.GreaterThan */ ||
+        testExpression.d.operator === 16 /* OperatorType.GreaterThanOrEqual */;
+    if (!comparisonOperator ||
+        testExpression.d.leftExpr.nodeType !== 9 /* ParseNodeType.Call */ ||
+        testExpression.d.leftExpr.d.args.length !== 1) {
+        return undefined;
+    }
+    const arg0Expr = testExpression.d.leftExpr.d.args[0].d.valueExpr;
+    if (!ctx.isMatchingExpression(reference, arg0Expr)) {
+        return undefined;
+    }
+    const callTypeResult = ctx.getTypeOfExpression(testExpression.d.leftExpr.d.leftExpr, 2 /* EvalFlags.CallBaseDefaults */);
+    const callType = callTypeResult.type;
+    if (!(0, types_1.isFunction)(callType) || callType.shared.fullName !== 'builtins.len') {
+        return undefined;
+    }
+    const rightTypeResult = ctx.getTypeOfExpression(testExpression.d.rightExpr);
+    const rightType = rightTypeResult.type;
+    if (!(0, types_1.isClassInstance)(rightType) ||
+        typeof rightType.priv.literalValue !== 'number' ||
+        rightType.priv.literalValue < 0) {
+        return undefined;
+    }
+    let tupleLength = rightType.priv.literalValue;
+    const isLessOrEqual = testExpression.d.operator === 12 /* OperatorType.Equals */ ||
+        testExpression.d.operator === 20 /* OperatorType.LessThan */ ||
+        testExpression.d.operator === 21 /* OperatorType.LessThanOrEqual */;
+    const adjIsPositiveTest = isLessOrEqual ? isPositiveTest : !isPositiveTest;
+    if (testExpression.d.operator === 21 /* OperatorType.LessThanOrEqual */ ||
+        testExpression.d.operator === 15 /* OperatorType.GreaterThan */) {
+        tupleLength++;
+    }
+    const isEqualityCheck = testExpression.d.operator === 12 /* OperatorType.Equals */ || testExpression.d.operator === 28 /* OperatorType.NotEquals */;
+    return {
+        tupleLength,
+        adjIsPositiveTest,
+        isLessThanCheck: !isEqualityCheck,
+        isIncomplete: !!callTypeResult.isIncomplete || !!rightTypeResult.isIncomplete,
+    };
+}
+function getInOperatorNarrowingInfo(ctx, reference, testExpression, isPositiveTest) {
+    if (testExpression.nodeType !== 7 /* ParseNodeType.BinaryOperation */ ||
+        (testExpression.d.operator !== 41 /* OperatorType.In */ && testExpression.d.operator !== 42 /* OperatorType.NotIn */)) {
+        return undefined;
+    }
+    const adjIsPositiveTest = testExpression.d.operator === 41 /* OperatorType.In */ ? isPositiveTest : !isPositiveTest;
+    if (ctx.isMatchingExpressionOrWalrusRhs(reference, testExpression.d.leftExpr)) {
+        const rightTypeResult = ctx.getTypeOfExpression(testExpression.d.rightExpr);
+        return {
+            kind: 'container',
+            containerType: rightTypeResult.type,
+            adjIsPositiveTest,
+            isIncomplete: !!rightTypeResult.isIncomplete,
+        };
+    }
+    if (ctx.isMatchingExpression(reference, testExpression.d.rightExpr)) {
+        const leftTypeResult = ctx.getTypeOfExpression(testExpression.d.leftExpr);
+        const leftType = leftTypeResult.type;
+        if ((0, types_1.isClassInstance)(leftType) && types_1.ClassType.isBuiltIn(leftType, 'str') && (0, typeUtils_1.isLiteralType)(leftType)) {
+            return {
+                kind: 'typedDictKey',
+                typedDictKeyType: types_1.ClassType.cloneAsInstantiable(leftType),
+                adjIsPositiveTest,
+                isIncomplete: !!leftTypeResult.isIncomplete,
+            };
+        }
+    }
+    return undefined;
+    return undefined;
+}
+function narrowTypeForTruthiness(evaluator, type, isPositiveTest) {
+    return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
+        if (isPositiveTest) {
+            if (evaluator.canBeTruthy(subtype)) {
+                return evaluator.removeFalsinessFromType(subtype);
+            }
+        }
+        else {
+            if (evaluator.canBeFalsy(subtype)) {
+                return evaluator.removeTruthinessFromType(subtype);
+            }
+        }
+        return undefined;
+    });
+}
+function narrowTupleTypeForIsNone(evaluator, type, isPositiveTest, indexValue) {
+    return evaluator.mapSubtypesExpandTypeVars(type, /* options */ undefined, (subtype) => {
+        const tupleType = (0, typeUtils_1.getSpecializedTupleType)(subtype);
+        if (!tupleType || (0, typeUtils_1.isUnboundedTupleClass)(tupleType) || !tupleType.priv.tupleTypeArgs) {
+            return subtype;
+        }
+        const tupleLength = tupleType.priv.tupleTypeArgs.length;
+        if (indexValue < 0 || indexValue >= tupleLength) {
+            return subtype;
+        }
+        const typeOfEntry = evaluator.makeTopLevelTypeVarsConcrete(tupleType.priv.tupleTypeArgs[indexValue].type);
+        if (isPositiveTest) {
+            if (!evaluator.assignType(typeOfEntry, evaluator.getNoneType())) {
+                return undefined;
+            }
+        }
+        else {
+            if ((0, typeUtils_1.isNoneInstance)(typeOfEntry)) {
+                return undefined;
+            }
+        }
+        return subtype;
+    });
+}
+function narrowTypeForIsNone(evaluator, type, isPositiveTest) {
+    const expandedType = (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
+        return (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(subtype);
+    });
+    let resultIncludesNoneSubtype = false;
+    const result = evaluator.mapSubtypesExpandTypeVars(expandedType, 
+    /* options */ undefined, (subtype, unexpandedSubtype) => {
+        if ((0, types_1.isAnyOrUnknown)(subtype)) {
+            if (isPositiveTest) {
+                resultIncludesNoneSubtype = true;
+                return (0, typeUtils_1.addConditionToType)(evaluator.getNoneType(), subtype.props?.condition);
+            }
+            return subtype;
+        }
+        let useExpandedSubtype = false;
+        if ((0, types_1.isTypeVar)(unexpandedSubtype) && !types_1.TypeVarType.isSelf(unexpandedSubtype)) {
+            if (unexpandedSubtype.shared.constraints.some((constraint) => {
+                return evaluator.assignType(constraint, evaluator.getNoneType());
+            })) {
+                useExpandedSubtype = true;
+            }
+            if (unexpandedSubtype.shared.boundType &&
+                evaluator.assignType(unexpandedSubtype.shared.boundType, evaluator.getNoneType())) {
+                useExpandedSubtype = true;
+            }
+        }
+        const adjustedSubtype = useExpandedSubtype ? subtype : unexpandedSubtype;
+        const newTypeBaseInstance = getInnermostNewTypeBaseInstance(adjustedSubtype);
+        if (newTypeBaseInstance && (0, typeUtils_1.isNoneInstance)(newTypeBaseInstance)) {
+            resultIncludesNoneSubtype = true;
+            return isPositiveTest ? adjustedSubtype : undefined;
+        }
+        if ((0, typeUtils_1.isNoneInstance)(subtype)) {
+            resultIncludesNoneSubtype = true;
+            return isPositiveTest ? adjustedSubtype : undefined;
+        }
+        if (evaluator.assignType(subtype, evaluator.getNoneType())) {
+            resultIncludesNoneSubtype = true;
+            return isPositiveTest
+                ? (0, typeUtils_1.addConditionToType)(evaluator.getNoneType(), subtype.props?.condition)
+                : adjustedSubtype;
+        }
+        return isPositiveTest ? undefined : adjustedSubtype;
+    });
+    if (isPositiveTest && resultIncludesNoneSubtype) {
+        return (0, typeUtils_1.mapSubtypes)(result, (subtype) => {
+            const baseInstance = getInnermostNewTypeBaseInstance(subtype);
+            return (0, typeUtils_1.isNoneInstance)(subtype) || (baseInstance && (0, typeUtils_1.isNoneInstance)(baseInstance)) ? subtype : undefined;
+        });
+    }
+    return result;
+}
+function narrowTypeForIsEllipsis(evaluator, node, type, isPositiveTest) {
+    const expandedType = (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
+        return (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(subtype);
+    });
+    let resultIncludesEllipsisSubtype = false;
+    const ellipsisType = evaluator.getBuiltInObject(node, 'EllipsisType') ??
+        evaluator.getBuiltInObject(node, 'ellipsis') ??
+        types_1.AnyType.create();
+    const isEllipsisInstance = (subtype) => {
+        return (0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, ['EllipsisType', 'ellipsis']);
+    };
+    const result = evaluator.mapSubtypesExpandTypeVars(expandedType, 
+    /* options */ undefined, (subtype, unexpandedSubtype) => {
+        if ((0, types_1.isAnyOrUnknown)(subtype)) {
+            return subtype;
+        }
+        const adjustedSubtype = (0, types_1.isTypeVar)(unexpandedSubtype) && !types_1.TypeVarType.hasConstraints(unexpandedSubtype)
+            ? unexpandedSubtype
+            : subtype;
+        const newTypeBaseInstance = getInnermostNewTypeBaseInstance(adjustedSubtype);
+        if (newTypeBaseInstance && isEllipsisInstance(newTypeBaseInstance)) {
+            resultIncludesEllipsisSubtype = true;
+            return isPositiveTest ? adjustedSubtype : undefined;
+        }
+        if (isEllipsisInstance(subtype)) {
+            resultIncludesEllipsisSubtype = true;
+            return isPositiveTest ? adjustedSubtype : undefined;
+        }
+        if (evaluator.assignType(subtype, ellipsisType)) {
+            resultIncludesEllipsisSubtype = true;
+            return isPositiveTest ? (0, typeUtils_1.addConditionToType)(ellipsisType, subtype.props?.condition) : adjustedSubtype;
+        }
+        return isPositiveTest ? undefined : adjustedSubtype;
+    });
+    if (isPositiveTest && resultIncludesEllipsisSubtype) {
+        return (0, typeUtils_1.mapSubtypes)(result, (subtype) => {
+            const baseInstance = getInnermostNewTypeBaseInstance(subtype);
+            return isEllipsisInstance(subtype) || (baseInstance && isEllipsisInstance(baseInstance))
+                ? subtype
+                : undefined;
+        });
+    }
+    return result;
+}
+function getIsInstanceClassTypes(evaluator, argType, argExpr) {
+    let foundNonClassType = false;
+    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, 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
+                // isinstance check).
+                if (!subtype.priv.includeSubclasses && subtype.priv.includePromotions) {
+                    subtype = types_1.ClassType.cloneRemoveTypePromotions(subtype);
+                }
+                classType = subtype;
+            }
+            else if ((0, types_1.isTypeVar)(subtype) && types_1.TypeBase.isInstantiable(subtype)) {
+                classType = subtype;
+            }
+            else if ((0, typeUtils_1.isNoneTypeClass)(subtype)) {
+                (0, debug_1.assert)((0, types_1.isInstantiableClass)(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 */) {
+                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, isAmbiguous, isUnboundedEntry, recursionCount, expression) => {
+        if (recursionCount > types_1.maxTypeRecursionCount) {
+            return;
+        }
+        // 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 {
+                addClassTypesToList([subtype], isAmbiguousType, isUnboundedEntry);
+            }
+        });
+    };
+    addClassTypesRecursive(argType, /* isAmbiguous */ false, /* isUnboundedEntry */ false, 0, argExpr);
+    return foundNonClassType ? undefined : { classTypes, negativeClassTypes };
+}
+function narrowTypeForInstanceOrSubclass(evaluator, type, filterTypes, isInstanceCheck, isTypeIsCheck, isPositiveTest, errorNode, nodeInfo, narrowTypeForInstanceOrSubclassInternalCallback) {
+    if (!isInstanceCheck && !isTypeIsCheck && !isPositiveTest) {
+        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;
+    }
+    const narrowedType = narrowTypeForInstanceOrSubclassInternalCallback(evaluator, type, filterTypes, isInstanceCheck, isTypeIsCheck, isPositiveTest, 
+    /* allowIntersections */ false, errorNode, nodeInfo);
+    if (!(0, types_1.isNever)(narrowedType)) {
+        return narrowedType;
+    }
+    return narrowTypeForInstanceOrSubclassInternalCallback(evaluator, type, filterTypes, isInstanceCheck, isTypeIsCheck, isPositiveTest, 
+    /* allowIntersections */ true, errorNode, nodeInfo);
+}
+function narrowTypeForTupleLength(evaluator, referenceType, lengthValue, isPositiveTest, isLessThanCheck) {
+    return (0, typeUtils_1.mapSubtypes)(referenceType, (subtype) => {
+        const concreteSubtype = evaluator.makeTopLevelTypeVarsConcrete(subtype);
+        // If it's not a tuple, we can't narrow it.
+        if (!(0, types_1.isClassInstance)(concreteSubtype) ||
+            !(0, typeUtils_1.isTupleClass)(concreteSubtype) ||
+            !concreteSubtype.priv.tupleTypeArgs) {
+            return subtype;
+        }
+        // If the tuple contains a TypeVarTuple, we can't narrow it.
+        if (concreteSubtype.priv.tupleTypeArgs.some((typeArg) => (0, types_1.isUnpackedTypeVarTuple)(typeArg.type))) {
+            return subtype;
+        }
+        // If the tuple contains no unbounded elements, then we know its length exactly.
+        if (!concreteSubtype.priv.tupleTypeArgs.some((typeArg) => typeArg.isUnbounded)) {
+            const tupleLengthMatches = isLessThanCheck
+                ? concreteSubtype.priv.tupleTypeArgs.length < lengthValue
+                : concreteSubtype.priv.tupleTypeArgs.length === lengthValue;
+            return tupleLengthMatches === isPositiveTest ? subtype : undefined;
+        }
+        // The tuple contains a "...". We'll expand this into as many elements as
+        // necessary to match the lengthValue.
+        const elementsToAdd = lengthValue - concreteSubtype.priv.tupleTypeArgs.length + 1;
+        if (!isLessThanCheck) {
+            // If the specified length is smaller than the minimum length of this tuple,
+            // we can rule it out for a positive test and rule it in for a negative test.
+            if (elementsToAdd < 0) {
+                return isPositiveTest ? undefined : subtype;
+            }
+            if (!isPositiveTest) {
+                // If this is an equality check for the minimum length (e.g.
+                // "len(x) == 0"), we can expand the minimum length by one).
+                const minLen = concreteSubtype.priv.tupleTypeArgs.length - 1;
+                if (lengthValue === minLen) {
+                    return expandUnboundedTupleElement(concreteSubtype, 1, /* keepUnbounded */ true);
+                }
+                return subtype;
+            }
+            return expandUnboundedTupleElement(concreteSubtype, elementsToAdd, /* keepUnbounded */ false);
+        }
+        // If this is a tuple related to an "*args: P.args" parameter, don't expand it.
+        if ((0, types_1.isParamSpec)(subtype) && subtype.priv.paramSpecAccess) {
+            return subtype;
+        }
+        // Place an upper limit on the number of union subtypes we
+        // will expand the tuple to.
+        const maxTupleUnionExpansion = 32;
+        if (elementsToAdd > maxTupleUnionExpansion) {
+            return subtype;
+        }
+        if (isPositiveTest) {
+            if (elementsToAdd < 1) {
+                return undefined;
+            }
+            const typesToCombine = [];
+            for (let i = 0; i < elementsToAdd; i++) {
+                typesToCombine.push(expandUnboundedTupleElement(concreteSubtype, i, /* keepUnbounded */ false));
+            }
+            return (0, types_1.combineTypes)(typesToCombine);
+        }
+        return expandUnboundedTupleElement(concreteSubtype, elementsToAdd, /* keepUnbounded */ true);
+    });
+}
+function expandUnboundedTupleElement(tupleType, elementsToAdd, keepUnbounded) {
+    const tupleTypeArgs = [];
+    tupleType.priv.tupleTypeArgs.forEach((typeArg) => {
+        if (!typeArg.isUnbounded) {
+            tupleTypeArgs.push(typeArg);
+        }
+        else {
+            for (let i = 0; i < elementsToAdd; i++) {
+                tupleTypeArgs.push({ isUnbounded: false, type: typeArg.type });
+            }
+            if (keepUnbounded) {
+                tupleTypeArgs.push(typeArg);
+            }
+        }
+    });
+    return (0, typeUtils_1.specializeTupleClass)(tupleType, tupleTypeArgs);
+}
+function narrowTypeForContainerType(evaluator, referenceType, containerType, isPositiveTest) {
+    if (isPositiveTest) {
+        const elementType = getElementTypeForContainerNarrowing(containerType);
+        if (!elementType) {
+            return referenceType;
+        }
+        return narrowTypeForContainerElementType(evaluator, referenceType, evaluator.makeTopLevelTypeVarsConcrete(elementType));
+    }
+    // Narrowing in the negative case is possible only with tuples
+    // with a known length.
+    if (!(0, types_1.isClassInstance)(containerType) ||
+        !types_1.ClassType.isBuiltIn(containerType, 'tuple') ||
+        !containerType.priv.tupleTypeArgs) {
+        return referenceType;
+    }
+    // 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) {
+            if ((0, typeUtils_1.isNoneInstance)(tupleEntry.type)) {
+                typesToEliminate.push(tupleEntry.type);
+            }
+            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;
+    }
+    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);
+            if (allLiteralTypes && allLiteralTypes.length > 0) {
+                return (0, types_1.combineTypes)(allLiteralTypes.filter((type) => !typesToEliminate.some((t) => (0, types_1.isTypeSame)(t, type))));
+            }
+        }
+        if (typesToEliminate.some((t) => (0, types_1.isTypeSame)(t, referenceSubtype))) {
+            return undefined;
+        }
+        return unexpandedSubtype;
+    });
+}
+function getElementTypeForContainerNarrowing(containerType) {
+    // We support contains narrowing only for certain built-in types that have been specialized.
+    const supportedContainers = ['list', 'set', 'frozenset', 'deque', 'tuple', 'dict', 'defaultdict', 'OrderedDict'];
+    if (!(0, types_1.isClassInstance)(containerType) || !types_1.ClassType.isBuiltIn(containerType, supportedContainers)) {
+        return undefined;
+    }
+    if (!containerType.priv.typeArgs || containerType.priv.typeArgs.length < 1) {
+        return undefined;
+    }
+    let elementType = containerType.priv.typeArgs[0];
+    if ((0, typeUtils_1.isTupleClass)(containerType) && containerType.priv.tupleTypeArgs) {
+        elementType = (0, types_1.combineTypes)(containerType.priv.tupleTypeArgs.map((t) => t.type));
+    }
+    return elementType;
+}
+function narrowTypeForContainerElementType(evaluator, referenceType, elementType) {
+    return evaluator.mapSubtypesExpandTypeVars(referenceType, /* options */ undefined, (referenceSubtype) => {
+        return (0, typeUtils_1.mapSubtypes)(elementType, (elementSubtype) => {
+            if ((0, types_1.isAnyOrUnknown)(elementSubtype)) {
+                return referenceSubtype;
+            }
+            // If the two types are disjoint (i.e. are not comparable), eliminate this subtype.
+            if (!evaluator.isTypeComparable(elementSubtype, referenceSubtype)) {
+                return undefined;
+            }
+            // If one of the two types is a literal, we can narrow to that type.
+            if ((0, types_1.isClassInstance)(elementSubtype) &&
+                ((0, typeUtils_1.isLiteralLikeType)(elementSubtype) || (0, typeUtils_1.isNoneInstance)(elementSubtype)) &&
+                evaluator.assignType(referenceSubtype, elementSubtype)) {
+                return (0, typeUtils_1.stripTypeForm)((0, typeUtils_1.addConditionToType)(elementSubtype, referenceSubtype.props?.condition));
+            }
+            if ((0, types_1.isClassInstance)(referenceSubtype) &&
+                ((0, typeUtils_1.isLiteralLikeType)(referenceSubtype) || (0, typeUtils_1.isNoneInstance)(referenceSubtype)) &&
+                evaluator.assignType(elementSubtype, referenceSubtype)) {
+                return (0, typeUtils_1.stripTypeForm)((0, typeUtils_1.addConditionToType)(referenceSubtype, elementSubtype.props?.condition));
+            }
+            // If the element type is a known class object that is assignable to
+            // the reference type, we can narrow to that class object.
+            if ((0, types_1.isInstantiableClass)(elementSubtype) &&
+                !elementSubtype.priv.includeSubclasses &&
+                evaluator.assignType(referenceSubtype, elementSubtype)) {
+                return (0, typeUtils_1.stripTypeForm)((0, typeUtils_1.addConditionToType)(elementSubtype, referenceSubtype.props?.condition));
+            }
+            // It's not safe to narrow.
+            return referenceSubtype;
+        });
+    });
+}
+function narrowTypeForTypedDictKey(evaluator, referenceType, literalKey, isPositiveTest) {
+    const narrowedType = evaluator.mapSubtypesExpandTypeVars(referenceType, 
+    /* options */ undefined, (subtype, unexpandedSubtype) => {
+        if ((0, types_1.isParamSpec)(unexpandedSubtype)) {
+            return unexpandedSubtype;
+        }
+        if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isTypedDictClass(subtype)) {
+            const entries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluator, subtype, /* allowNarrowed */ true);
+            const knownEntry = entries.knownItems.get(literalKey.priv.literalValue);
+            const tdEntry = knownEntry ?? entries.extraItems;
+            if (isPositiveTest) {
+                // The code that is commented out below implements the behavior that is technically
+                // correct, but until we PEP 728 is ratified and we have a way to express "extra items"
+                // and closed TypedDicts, we'll preserve the older (less correct) behavior to enable
+                // narrowing of TypedDicts based on checks for specific keys.
+                // TODO - remove this behavior once PEP 728 is accepted and the feature is no
+                // longer experimental.
+                if (!tdEntry) {
+                    return undefined;
+                }
+                // if (!tdEntry) {
+                //     // If there is no TD entry for this key and no "extra items" defined,
+                //     // we have to assume that the TypedDict may contain extra items, so
+                //     // narrowing it isn't possible in this case.
+                //     return subtype;
+                // }
+                if ((0, types_1.isNever)(tdEntry.valueType)) {
+                    // If the entry is typed as Never or the "extra items" is typed as Never,
+                    // then this key cannot be present in the TypedDict, and we can eliminate it.
+                    // A closed TypedDict has an "extra items" of Never, so this is what allows
+                    // a key check to discriminate between closed TypedDicts.
+                    return undefined;
+                }
+                // If the entry is currently not required and not marked provided, we can mark
+                // it as provided after this guard expression confirms it is.
+                if (tdEntry.isRequired || tdEntry.isProvided) {
+                    return subtype;
+                }
+                const newNarrowedEntriesMap = new Map(subtype.priv.typedDictNarrowedEntries ?? []);
+                // Add the new entry.
+                newNarrowedEntriesMap.set(literalKey.priv.literalValue, {
+                    valueType: tdEntry.valueType,
+                    isReadOnly: tdEntry.isReadOnly,
+                    isRequired: false,
+                    isProvided: true,
+                });
+                // Clone the TypedDict object with the new entries.
+                return types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForNarrowedTypedDictEntries(types_1.ClassType.cloneAsInstantiable(subtype), newNarrowedEntriesMap));
+            }
+            else {
+                if (!knownEntry) {
+                    // The key is not one of the known items, so it can be supplied
+                    // only through an "extra items" entry, which says nothing about
+                    // whether this particular key is present. Its absence is therefore
+                    // consistent with the type, and the subtype cannot be eliminated.
+                    return subtype;
+                }
+                return knownEntry.isRequired || knownEntry.isProvided ? undefined : subtype;
+            }
+        }
+        return subtype;
+    });
+    return narrowedType;
+}
+function narrowTypeForDiscriminatedDictEntryComparison(evaluator, referenceType, indexLiteralType, literalType, isPositiveTest) {
+    let canNarrow = true;
+    const narrowedType = (0, typeUtils_1.mapSubtypes)(referenceType, (subtype) => {
+        if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isTypedDictClass(subtype)) {
+            const symbolMap = (0, typedDicts_1.getTypedDictMembersForClass)(evaluator, subtype);
+            const tdEntry = symbolMap.knownItems.get(indexLiteralType.priv.literalValue);
+            if (tdEntry && (0, typeUtils_1.isLiteralTypeOrUnion)(tdEntry.valueType)) {
+                if (isPositiveTest) {
+                    let foundMatch = false;
+                    (0, typeUtils_1.doForEachSubtype)(literalType, (literalSubtype) => {
+                        if (evaluator.assignType(tdEntry.valueType, literalSubtype)) {
+                            foundMatch = true;
+                        }
+                    });
+                    return foundMatch ? subtype : undefined;
+                }
+                else {
+                    let foundNonMatch = false;
+                    (0, typeUtils_1.doForEachSubtype)(literalType, (literalSubtype) => {
+                        if (!evaluator.assignType(literalSubtype, tdEntry.valueType)) {
+                            foundNonMatch = true;
+                        }
+                    });
+                    return foundNonMatch ? subtype : undefined;
+                }
+            }
+        }
+        canNarrow = false;
+        return subtype;
+    });
+    return canNarrow ? narrowedType : referenceType;
+}
+function narrowTypeForDiscriminatedTupleComparison(evaluator, referenceType, indexLiteralType, literalType, isPositiveTest) {
+    let canNarrow = true;
+    const narrowedType = (0, typeUtils_1.mapSubtypes)(referenceType, (subtype) => {
+        if ((0, types_1.isClassInstance)(subtype) &&
+            types_1.ClassType.isTupleClass(subtype) &&
+            !(0, typeUtils_1.isUnboundedTupleClass)(subtype) &&
+            typeof indexLiteralType.priv.literalValue === 'number' &&
+            (0, types_1.isClassInstance)(literalType)) {
+            const indexValue = indexLiteralType.priv.literalValue;
+            if (subtype.priv.tupleTypeArgs && indexValue >= 0 && indexValue < subtype.priv.tupleTypeArgs.length) {
+                const tupleEntryType = subtype.priv.tupleTypeArgs[indexValue]?.type;
+                if (tupleEntryType && (0, typeUtils_1.isLiteralTypeOrUnion)(tupleEntryType)) {
+                    if (isPositiveTest) {
+                        return evaluator.assignType(tupleEntryType, literalType) ? subtype : undefined;
+                    }
+                    else {
+                        return evaluator.assignType(literalType, tupleEntryType) ? undefined : subtype;
+                    }
+                }
+            }
+        }
+        canNarrow = false;
+        return subtype;
+    });
+    return canNarrow ? narrowedType : referenceType;
+}
+function narrowTypeForDiscriminatedLiteralFieldComparison(evaluator, referenceType, memberName, literalType, isPositiveTest) {
+    const narrowedType = (0, typeUtils_1.mapSubtypes)(referenceType, (subtype) => {
+        let memberInfo;
+        if ((0, types_1.isClassInstance)(subtype)) {
+            memberInfo = (0, typeUtils_1.lookUpObjectMember)(subtype, memberName);
+        }
+        else if ((0, types_1.isInstantiableClass)(subtype)) {
+            memberInfo = (0, typeUtils_1.lookUpClassMember)(subtype, memberName);
+        }
+        if (memberInfo && memberInfo.isTypeDeclared) {
+            let memberType = evaluator.getTypeOfMember(memberInfo);
+            // Handle the case where the field is a property
+            // that has a declared literal return type for its getter.
+            if ((0, types_1.isClassInstance)(subtype) && (0, types_1.isClassInstance)(memberType) && (0, typeUtils_1.isProperty)(memberType)) {
+                const getterType = memberType.priv.fgetInfo?.methodType;
+                if (getterType && (0, types_1.isFunction)(getterType) && getterType.shared.declaredReturnType) {
+                    const getterReturnType = types_1.FunctionType.getEffectiveReturnType(getterType);
+                    if (getterReturnType) {
+                        memberType = getterReturnType;
+                    }
+                }
+            }
+            if ((0, typeUtils_1.isLiteralTypeOrUnion)(memberType, /* allowNone */ true)) {
+                if (isPositiveTest) {
+                    return evaluator.assignType(memberType, literalType) ? subtype : undefined;
+                }
+                else {
+                    return evaluator.assignType(literalType, memberType) ? undefined : subtype;
+                }
+            }
+        }
+        return subtype;
+    });
+    return narrowedType;
+}
+function narrowTypeForDiscriminatedFieldNoneComparison(evaluator, referenceType, memberName, isPositiveTest) {
+    return (0, typeUtils_1.mapSubtypes)(referenceType, (subtype) => {
+        let memberInfo;
+        if ((0, types_1.isClassInstance)(subtype)) {
+            memberInfo = (0, typeUtils_1.lookUpObjectMember)(subtype, memberName);
+        }
+        else if ((0, types_1.isInstantiableClass)(subtype)) {
+            memberInfo = (0, typeUtils_1.lookUpClassMember)(subtype, memberName);
+        }
+        if (memberInfo && memberInfo.isTypeDeclared) {
+            // Check the declared type before narrowing, since the member type
+            // below will be concretized and lose descriptor identity.
+            const declaredType = evaluator.getDeclaredTypeOfSymbol(memberInfo.symbol)?.type;
+            if (!declaredType) {
+                // isTypeDeclared is true but the type couldn't be resolved (e.g. an
+                // unresolvable stub).  Conservatively skip narrowing rather than risk
+                // incorrectly eliminating a descriptor-typed member.
+                return subtype;
+            }
+            // Check if any subtype of the declared type is a descriptor or property.
+            // isMaybeDescriptorInstance handles declared types in instance form (ClassInstance),
+            // while isMaybeDescriptorClass handles declared types in instantiable form
+            // (InstantiableClass), which occurs when the annotation refers to the class object itself.
+            // This check applies to both positive and negative test paths: descriptor __get__
+            // return values don't reflect stored values regardless of test polarity.
+            const isDescriptorOrProperty = (0, typeUtils_1.someSubtypes)(declaredType, (declaredSubtype) => (0, typeUtils_1.isProperty)(declaredSubtype) ||
+                (0, typeUtils_1.isMaybeDescriptorInstance)(declaredSubtype) ||
+                (0, typeUtils_1.isMaybeDescriptorClass)(declaredSubtype));
+            if (isDescriptorOrProperty) {
+                return subtype;
+            }
+            const memberType = evaluator.makeTopLevelTypeVarsConcrete(evaluator.getTypeOfMember(memberInfo));
+            let canNarrow = true;
+            if (isPositiveTest) {
+                (0, typeUtils_1.doForEachSubtype)(memberType, (memberSubtype) => {
+                    memberSubtype = evaluator.makeTopLevelTypeVarsConcrete(memberSubtype);
+                    if ((0, types_1.isAnyOrUnknown)(memberSubtype) || (0, typeUtils_1.isNoneInstance)(memberSubtype) || (0, types_1.isNever)(memberSubtype)) {
+                        canNarrow = false;
+                    }
+                });
+            }
+            else {
+                canNarrow = (0, typeUtils_1.isNoneInstance)(memberType);
+            }
+            if (canNarrow) {
+                return undefined;
+            }
+        }
+        return subtype;
+    });
+}
+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 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(instantiableSubtype, classType)) {
+                            return (0, typeUtils_1.addConditionToType)(subtype, (0, typeUtils_1.getTypeCondition)(classType));
+                        }
+                        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);
+                    }
+                }
+                // 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 && (isLiteral || types_1.ClassType.isFinal(instantiableSubtype))) {
+                        return undefined;
+                    }
+                    // We can't eliminate the subtype in the negative
+                    // case because it could be a subclass of the type,
+                    // in which case `type(x) is y` would fail.
+                    return subtype;
+                }
+            }
+            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;
+            }
+            return unexpandedSubtype;
+        });
+    });
+    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 */));
+}
+function hasIdentityEqualitySemantics(classType, metaclassEqualityResults) {
+    if (classType.priv.includeSubclasses && !types_1.ClassType.isFinal(classType)) {
+        return false;
+    }
+    if (classType.shared.typeParams.length > 0) {
+        return false;
+    }
+    return hasDeclaredIdentityEqualitySemantics(classType, metaclassEqualityResults);
+}
+function hasDeclaredIdentityEqualitySemantics(classType, metaclassEqualityResults) {
+    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;
+}
+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) &&
+                types_1.ClassType.isBuiltIn(concreteSubtype, 'type')) {
+                concreteSubtype =
+                    concreteSubtype.priv.typeArgs && concreteSubtype.priv.typeArgs.length > 0
+                        ? (0, typeUtils_1.convertToInstantiable)(concreteSubtype.priv.typeArgs[0])
+                        : types_1.UnknownType.create();
+            }
+            if ((0, types_1.isAnyOrUnknown)(concreteSubtype)) {
+                return (0, typeUtils_1.addConditionToType)(classType, (0, typeUtils_1.getTypeCondition)(concreteSubtype));
+            }
+            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);
+                if (!classType.priv.includeSubclasses) {
+                    // Handle the case where the LHS and RHS operands are specific
+                    // classes, as opposed to types that represent classes and their
+                    // subclasses.
+                    if (!concreteSubtype.priv.includeSubclasses) {
+                        return types_1.ClassType.isSameGenericClass(concreteSubtype, classType) ? classType : undefined;
+                    }
+                    if (isSuperType) {
+                        return (0, typeUtils_1.addConditionToType)(classType, (0, typeUtils_1.getTypeCondition)(concreteSubtype));
+                    }
+                    const isSubType = types_1.ClassType.isDerivedFrom(classType, concreteSubtype);
+                    if (isSubType) {
+                        return (0, typeUtils_1.addConditionToType)(classType, (0, typeUtils_1.getTypeCondition)(concreteSubtype));
+                    }
+                    return undefined;
+                }
+                if (types_1.ClassType.isFinal(concreteSubtype) && !isSuperType) {
+                    return undefined;
+                }
+            }
+        }
+        else {
+            if ((0, types_1.isInstantiableClass)(concreteSubtype) &&
+                types_1.ClassType.isSameGenericClass(classType, concreteSubtype) &&
+                types_1.ClassType.isFinal(classType)) {
+                return undefined;
+            }
+        }
+        return subtype;
+    });
+}
+function isFilterSuperclass(varType, concreteVarType, filterType, concreteFilterType) {
+    if ((0, types_1.isTypeVar)(filterType) || concreteFilterType.priv.literalValue !== undefined) {
+        return (0, types_1.isTypeSame)((0, typeUtils_1.convertToInstance)(filterType), varType);
+    }
+    // If the filter type represents all possible subclasses
+    // of a type, we can't make any statements about its superclass
+    // relationship with concreteVarType.
+    if (concreteFilterType.priv.includeSubclasses) {
+        return false;
+    }
+    if (types_1.ClassType.isDerivedFrom(concreteVarType, concreteFilterType)) {
+        return true;
+    }
+    // Handle the special case where the variable type is a TypedDict and
+    // we're filtering against 'dict'. TypedDict isn't derived from dict,
+    // but at runtime, isinstance returns True.
+    if (types_1.ClassType.isBuiltIn(concreteFilterType, 'dict') && types_1.ClassType.isTypedDictClass(concreteVarType)) {
+        return true;
+    }
+    return false;
+}
+function isPrimitiveBackedEnumClass(classType) {
+    if (!types_1.ClassType.isEnumClass(classType)) {
+        return false;
+    }
+    return (0, typeUtils_1.derivesFromStdlibClass)(classType, 'int') || (0, typeUtils_1.derivesFromStdlibClass)(classType, 'str');
+}
+function isPrimitiveBackedEnumAndPrimitive(enumType, primitiveType) {
+    if (types_1.ClassType.isEnumClass(primitiveType) || !isPrimitiveBackedEnumClass(enumType)) {
+        return false;
+    }
+    // Exclude bool, which derives from int but whose literal values are distinct
+    // from the corresponding int literals.
+    if (types_1.ClassType.isBuiltIn(primitiveType, 'int')) {
+        return (0, typeUtils_1.derivesFromStdlibClass)(enumType, 'int');
+    }
+    if (types_1.ClassType.isBuiltIn(primitiveType, 'str')) {
+        return (0, typeUtils_1.derivesFromStdlibClass)(enumType, 'str');
+    }
+    return false;
+}
+function unwrapPrimitiveBackedEnumLiteral(classType) {
+    const literalValue = classType.priv.literalValue;
+    if (!(literalValue instanceof types_1.EnumLiteral) || !isPrimitiveBackedEnumClass(classType)) {
+        return classType;
+    }
+    const itemType = literalValue.itemType;
+    if ((0, types_1.isClassInstance)(itemType) && itemType.priv.literalValue !== undefined) {
+        return itemType;
+    }
+    return classType;
+}
+function isLiteralValueEqualAtRuntime(type1, type2) {
+    return types_1.ClassType.isLiteralValueSame(unwrapPrimitiveBackedEnumLiteral(type1), unwrapPrimitiveBackedEnumLiteral(type2));
+}
+function getInnermostNewTypeBaseInstance(subtype) {
+    if (!(0, types_1.isClassInstance)(subtype) || !types_1.ClassType.isNewTypeClass(subtype)) {
+        return undefined;
+    }
+    let currentType = subtype;
+    while ((0, types_1.isClassInstance)(currentType) && types_1.ClassType.isNewTypeClass(currentType)) {
+        if (currentType.shared.baseClasses.length === 0) {
+            return undefined;
+        }
+        const baseClass = currentType.shared.baseClasses[0];
+        if (!(0, types_1.isClass)(baseClass)) {
+            return undefined;
+        }
+        currentType = types_1.ClassType.cloneAsInstance(baseClass);
+    }
+    return currentType;
+}
+function narrowTypeForLiteralComparison(evaluator, referenceType, literalType, isPositiveTest, isIsOperator) {
+    return evaluator.mapSubtypesExpandTypeVars(referenceType, /* options */ undefined, (subtype) => {
+        subtype = evaluator.makeTopLevelTypeVarsConcrete(subtype);
+        if ((0, types_1.isAnyOrUnknown)(subtype)) {
+            if (isPositiveTest) {
+                return literalType;
+            }
+            return subtype;
+        }
+        // Determine whether this is a comparison between a primitive-backed enum
+        // (e.g. IntEnum or StrEnum) and its underlying primitive type. Such a
+        // comparison can be used for narrowing because the enum member compares
+        // equal to its underlying primitive value at runtime.
+        const isPrimitiveBackedEnumComparison = !isIsOperator &&
+            (0, types_1.isClassInstance)(subtype) &&
+            (isPrimitiveBackedEnumAndPrimitive(subtype, literalType) ||
+                isPrimitiveBackedEnumAndPrimitive(literalType, subtype));
+        if ((0, types_1.isClassInstance)(subtype) &&
+            (types_1.ClassType.isSameGenericClass(literalType, subtype) || isPrimitiveBackedEnumComparison)) {
+            if (subtype.priv.literalValue !== undefined) {
+                const literalValueMatches = isPrimitiveBackedEnumComparison
+                    ? isLiteralValueEqualAtRuntime(subtype, literalType)
+                    : types_1.ClassType.isLiteralValueSame(subtype, literalType);
+                if (isPositiveTest) {
+                    return literalValueMatches ? subtype : undefined;
+                }
+                const isSingleton = types_1.ClassType.isEnumClass(literalType) ||
+                    (0, typeUtils_1.isSentinelLiteral)(subtype) ||
+                    types_1.ClassType.isBuiltIn(literalType, 'bool');
+                // For negative tests, we can eliminate the literal value if it doesn't match,
+                // but only for equality tests or for 'is' tests that involve enums, bools, or sentinels.
+                return literalValueMatches && (isSingleton || !isIsOperator) ? undefined : subtype;
+            }
+            if (isPositiveTest) {
+                if (isPrimitiveBackedEnumComparison) {
+                    // If the reference type is the enum, attempt to find the member
+                    // whose value matches the primitive literal. If no member can be
+                    // identified (e.g. for an IntFlag class, whose members cannot be
+                    // enumerated), retain the reference type rather than narrowing it
+                    // to the primitive literal type.
+                    if (types_1.ClassType.isEnumClass(subtype)) {
+                        const allLiteralTypes = enumerateLiteralsForType(evaluator, subtype);
+                        const match = allLiteralTypes?.find((type) => isLiteralValueEqualAtRuntime(type, literalType));
+                        return match ?? subtype;
+                    }
+                    // The reference type is the primitive type, so narrowing it to the
+                    // enum literal would lose its (potentially derived) class. Retain
+                    // the reference type instead.
+                    return subtype;
+                }
+                return literalType;
+            }
+            // 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, subtype);
+            if (allLiteralTypes && allLiteralTypes.length > 0) {
+                return (0, types_1.combineTypes)(allLiteralTypes.filter((type) => isPrimitiveBackedEnumComparison
+                    ? !isLiteralValueEqualAtRuntime(type, literalType)
+                    : !types_1.ClassType.isLiteralValueSame(type, literalType)));
+            }
+            return subtype;
+        }
+        if (isPositiveTest) {
+            if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'LiteralString')) {
+                return literalType;
+            }
+            if (isIsOperator || (0, typeUtils_1.isNoneInstance)(subtype)) {
+                const compareType = getInnermostNewTypeBaseInstance(subtype) ?? subtype;
+                const isSubtype = evaluator.assignType(compareType, literalType);
+                if (isSubtype) {
+                    return (0, types_1.isClassInstance)(subtype) && types_1.ClassType.isNewTypeClass(subtype) ? subtype : literalType;
+                }
+                return undefined;
+            }
+        }
+        return subtype;
+    });
+}
+function enumerateLiteralsForType(evaluator, type) {
+    if (types_1.ClassType.isBuiltIn(type, 'bool')) {
+        // Booleans have only two types: True and False.
+        return [
+            types_1.ClassType.cloneWithLiteral(type, /* value */ true),
+            types_1.ClassType.cloneWithLiteral(type, /* value */ false),
+        ];
+    }
+    if (types_1.ClassType.isEnumClass(type)) {
+        // Enum expansion doesn't apply if the member set cannot be statically
+        // enumerated or if the class derives from enum.Flag.
+        if (types_1.ClassType.isEnumMemberSetMayBeDynamicallyModified(type) ||
+            type.shared.mro.some((mroClass) => (0, types_1.isClass)(mroClass) && types_1.ClassType.isBuiltIn(mroClass, 'Flag'))) {
+            return undefined;
+        }
+        // Enumerate all of the values in this enumeration.
+        const enumList = [];
+        const fields = types_1.ClassType.getSymbolTable(type);
+        fields.forEach((symbol, name) => {
+            if (!symbol.isIgnoredForProtocolMatch()) {
+                let symbolType = evaluator.getEffectiveTypeOfSymbol(symbol);
+                symbolType = (0, enums_1.transformTypeForEnumMember)(evaluator, type, name, (0, analyzerNodeInfo_1.getInfoReader)(evaluator)) ?? symbolType;
+                if ((0, types_1.isClassInstance)(symbolType) &&
+                    types_1.ClassType.isSameGenericClass(type, symbolType) &&
+                    symbolType.priv.literalValue !== undefined) {
+                    enumList.push(symbolType);
+                }
+            }
+        });
+        return enumList;
+    }
+    return undefined;
+}
+function isNameSameScope(evaluator, reference, expression) {
+    const refSymbol = evaluator.lookUpSymbolRecursive(reference, reference.d.value, /* honorCodeFlow */ false);
+    const exprSymbol = evaluator.lookUpSymbolRecursive(expression, expression.d.value, /* honorCodeFlow */ false);
+    if (!refSymbol || !exprSymbol) {
+        // This shouldn't happen, but just to be safe...
+        return true;
+    }
+    const refScope = refSymbol.scope;
+    const exprScope = exprSymbol.scope;
+    if (refScope === exprScope) {
+        return true;
+    }
+    return (0, scopeUtils_1.isScopeContainedWithin)(refScope, exprScope);
+}
+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]);
+}
+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;
+}
+function narrowTypeForUserDefinedTypeGuard(evaluator, type, typeGuardType, isPositiveTest, isStrictTypeGuard, errorNode, nodeInfo, narrowTypeForInstanceOrSubclassCallback) {
+    // For non-strict type guards, always narrow to the typeGuardType
+    // in the positive case and don't narrow in the negative case.
+    if (!isStrictTypeGuard) {
+        let result = type;
+        if (isPositiveTest) {
+            result = typeGuardType;
+            // If the type guard is a non-constrained TypeVar, add a
+            // condition to the resulting type.
+            if ((0, types_1.isTypeVar)(type) && !(0, types_1.isParamSpec)(type) && !types_1.TypeVarType.hasConstraints(type)) {
+                result = (0, typeUtils_1.addConditionToType)(result, [{ typeVar: type, constraintIndex: 0 }]);
+            }
+            return result;
+        }
+        return result;
+    }
+    const filterTypes = [];
+    (0, typeUtils_1.doForEachSubtype)(typeGuardType, (typeGuardSubtype) => {
+        filterTypes.push((0, typeUtils_1.convertToInstantiable)(typeGuardSubtype));
+    });
+    return narrowTypeForInstanceOrSubclassCallback(evaluator, type, filterTypes, 
+    /* isInstanceCheck */ true, 
+    /* isTypeIsCheck */ true, isPositiveTest, errorNode, nodeInfo);
+}
+//# sourceMappingURL=typeGuardNarrowing.js.map