@zzzen/pyright-internal 1.1.254

package/dist/analyzer/typeGuards.js

@@ -0,0 +1,1293 @@
+"use strict";
+/*
+ * typeGuards.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ * Author: Eric Traut
+ *
+ * Provides logic for narrowing types based on conditional
+ * expressions. The logic handles both positive ("if") and
+ * negative ("else") narrowing cases.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enumerateLiteralsForType = exports.getTypeNarrowingCallback = void 0;
+const parseNodes_1 = require("../parser/parseNodes");
+const analyzerNodeInfo_1 = require("./analyzerNodeInfo");
+const constraintSolver_1 = require("./constraintSolver");
+const ParseTreeUtils = __importStar(require("./parseTreeUtils"));
+const scopeUtils_1 = require("./scopeUtils");
+const symbol_1 = require("./symbol");
+const typedDicts_1 = require("./typedDicts");
+const types_1 = require("./types");
+const typeUtils_1 = require("./typeUtils");
+const typeVarContext_1 = require("./typeVarContext");
+// 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,
+// it returns undefined.
+function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositiveTest, recursionCount = 0) {
+    if (recursionCount > types_1.maxTypeRecursionCount) {
+        return undefined;
+    }
+    recursionCount++;
+    if (testExpression.nodeType === 4 /* AssignmentExpression */) {
+        return getTypeNarrowingCallbackForAssignmentExpression(evaluator, reference, testExpression, isPositiveTest, recursionCount);
+    }
+    if (testExpression.nodeType === 7 /* BinaryOperation */) {
+        const isOrIsNotOperator = testExpression.operator === 39 /* Is */ || testExpression.operator === 40 /* IsNot */;
+        const equalsOrNotEqualsOperator = testExpression.operator === 12 /* Equals */ || testExpression.operator === 28 /* NotEquals */;
+        if (isOrIsNotOperator || equalsOrNotEqualsOperator) {
+            // Invert the "isPositiveTest" value if this is an "is not" operation.
+            const adjIsPositiveTest = testExpression.operator === 39 /* Is */ || testExpression.operator === 12 /* Equals */
+                ? isPositiveTest
+                : !isPositiveTest;
+            // Look for "X is None", "X is not None", "X == None", and "X != None".
+            // These are commonly-used patterns used in control flow.
+            if (testExpression.rightExpression.nodeType === 11 /* Constant */ &&
+                testExpression.rightExpression.constType === 26 /* None */) {
+                // Allow the LHS to be either a simple expression or an assignment
+                // expression that assigns to a simple name.
+                let leftExpression = testExpression.leftExpression;
+                if (leftExpression.nodeType === 4 /* AssignmentExpression */) {
+                    leftExpression = leftExpression.name;
+                }
+                if (ParseTreeUtils.isMatchingExpression(reference, leftExpression)) {
+                    return (type) => {
+                        return narrowTypeForIsNone(evaluator, type, adjIsPositiveTest);
+                    };
+                }
+                if (leftExpression.nodeType === 24 /* Index */ &&
+                    ParseTreeUtils.isMatchingExpression(reference, leftExpression.baseExpression) &&
+                    leftExpression.items.length === 1 &&
+                    !leftExpression.trailingComma &&
+                    leftExpression.items[0].argumentCategory === 0 /* Simple */ &&
+                    !leftExpression.items[0].name &&
+                    leftExpression.items[0].valueExpression.nodeType === 40 /* Number */ &&
+                    leftExpression.items[0].valueExpression.isInteger &&
+                    !leftExpression.items[0].valueExpression.isImaginary) {
+                    const indexValue = leftExpression.items[0].valueExpression.value;
+                    if (typeof indexValue === 'number') {
+                        return (type) => {
+                            return narrowTupleTypeForIsNone(evaluator, type, adjIsPositiveTest, indexValue);
+                        };
+                    }
+                }
+            }
+            // Look for "type(X) is Y" or "type(X) is not Y".
+            if (isOrIsNotOperator && testExpression.leftExpression.nodeType === 9 /* Call */) {
+                const callType = evaluator.getTypeOfExpression(testExpression.leftExpression.leftExpression, 2 /* DoNotSpecialize */).type;
+                if ((0, types_1.isInstantiableClass)(callType) &&
+                    types_1.ClassType.isBuiltIn(callType, 'type') &&
+                    testExpression.leftExpression.arguments.length === 1 &&
+                    testExpression.leftExpression.arguments[0].argumentCategory === 0 /* Simple */) {
+                    const arg0Expr = testExpression.leftExpression.arguments[0].valueExpression;
+                    if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
+                        const classType = evaluator.makeTopLevelTypeVarsConcrete(evaluator.getTypeOfExpression(testExpression.rightExpression).type);
+                        if ((0, types_1.isInstantiableClass)(classType)) {
+                            return (type) => {
+                                return narrowTypeForTypeIs(type, classType, adjIsPositiveTest);
+                            };
+                        }
+                    }
+                }
+            }
+            // Look for "X is Y" or "X is not Y" where Y is a an enum or bool literal.
+            if (isOrIsNotOperator) {
+                if (ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression)) {
+                    const rightType = evaluator.getTypeOfExpression(testExpression.rightExpression).type;
+                    if ((0, types_1.isClassInstance)(rightType) &&
+                        (types_1.ClassType.isEnumClass(rightType) || types_1.ClassType.isBuiltIn(rightType, 'bool')) &&
+                        rightType.literalValue !== undefined) {
+                        return (type) => {
+                            return narrowTypeForLiteralComparison(evaluator, type, rightType, adjIsPositiveTest, 
+                            /* isIsOperator */ true);
+                        };
+                    }
+                }
+            }
+            if (equalsOrNotEqualsOperator) {
+                // Look for X == <literal> or X != <literal>
+                const adjIsPositiveTest = testExpression.operator === 12 /* Equals */ ? isPositiveTest : !isPositiveTest;
+                if (ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression)) {
+                    const rightType = evaluator.getTypeOfExpression(testExpression.rightExpression).type;
+                    if ((0, types_1.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
+                        return (type) => {
+                            return narrowTypeForLiteralComparison(evaluator, type, rightType, adjIsPositiveTest, 
+                            /* isIsOperator */ false);
+                        };
+                    }
+                }
+                // Look for <literal> == X or <literal> != X
+                if (ParseTreeUtils.isMatchingExpression(reference, testExpression.rightExpression)) {
+                    const leftType = evaluator.getTypeOfExpression(testExpression.leftExpression).type;
+                    if ((0, types_1.isClassInstance)(leftType) && leftType.literalValue !== undefined) {
+                        return (type) => {
+                            return narrowTypeForLiteralComparison(evaluator, type, leftType, adjIsPositiveTest, 
+                            /* isIsOperator */ false);
+                        };
+                    }
+                }
+                // Look for X[<literal>] == <literal> or X[<literal>] != <literal>
+                if (testExpression.leftExpression.nodeType === 24 /* Index */ &&
+                    testExpression.leftExpression.items.length === 1 &&
+                    !testExpression.leftExpression.trailingComma &&
+                    testExpression.leftExpression.items[0].argumentCategory === 0 /* Simple */ &&
+                    ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression.baseExpression)) {
+                    const indexType = evaluator.getTypeOfExpression(testExpression.leftExpression.items[0].valueExpression).type;
+                    if ((0, types_1.isClassInstance)(indexType) && (0, typeUtils_1.isLiteralType)(indexType)) {
+                        if (types_1.ClassType.isBuiltIn(indexType, 'str')) {
+                            const rightType = evaluator.getTypeOfExpression(testExpression.rightExpression).type;
+                            if ((0, types_1.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
+                                return (type) => {
+                                    return narrowTypeForDiscriminatedDictEntryComparison(evaluator, type, indexType, rightType, adjIsPositiveTest);
+                                };
+                            }
+                        }
+                        else if (types_1.ClassType.isBuiltIn(indexType, 'int')) {
+                            const rightType = evaluator.getTypeOfExpression(testExpression.rightExpression).type;
+                            if ((0, types_1.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
+                                return (type) => {
+                                    return narrowTypeForDiscriminatedTupleComparison(evaluator, type, indexType, rightType, adjIsPositiveTest);
+                                };
+                            }
+                        }
+                    }
+                }
+            }
+            // Look for len(x) == <literal> or len(x) != <literal>
+            if (equalsOrNotEqualsOperator &&
+                testExpression.leftExpression.nodeType === 9 /* Call */ &&
+                testExpression.leftExpression.arguments.length === 1 &&
+                testExpression.rightExpression.nodeType === 40 /* Number */ &&
+                testExpression.rightExpression.isInteger) {
+                const arg0Expr = testExpression.leftExpression.arguments[0].valueExpression;
+                if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
+                    const callType = evaluator.getTypeOfExpression(testExpression.leftExpression.leftExpression, 2 /* DoNotSpecialize */).type;
+                    if ((0, types_1.isFunction)(callType) && callType.details.fullName === 'builtins.len') {
+                        const tupleLength = testExpression.rightExpression.value;
+                        if (typeof tupleLength === 'number') {
+                            return (type) => {
+                                return narrowTypeForTupleLength(evaluator, type, tupleLength, adjIsPositiveTest);
+                            };
+                        }
+                    }
+                }
+            }
+            // Look for X.Y == <literal> or X.Y != <literal>
+            if (equalsOrNotEqualsOperator &&
+                testExpression.leftExpression.nodeType === 35 /* MemberAccess */ &&
+                ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression.leftExpression)) {
+                const rightType = evaluator.getTypeOfExpression(testExpression.rightExpression).type;
+                const memberName = testExpression.leftExpression.memberName;
+                if ((0, types_1.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
+                    return (type) => {
+                        return narrowTypeForDiscriminatedLiteralFieldComparison(evaluator, type, memberName.value, rightType, adjIsPositiveTest);
+                    };
+                }
+            }
+            // Look for X.Y is <literal> or X.Y is not <literal> where <literal> is
+            // an enum or bool literal
+            if (testExpression.leftExpression.nodeType === 35 /* MemberAccess */ &&
+                ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression.leftExpression)) {
+                const rightType = evaluator.getTypeOfExpression(testExpression.rightExpression).type;
+                const memberName = testExpression.leftExpression.memberName;
+                if ((0, types_1.isClassInstance)(rightType) &&
+                    (types_1.ClassType.isEnumClass(rightType) || types_1.ClassType.isBuiltIn(rightType, 'bool')) &&
+                    rightType.literalValue !== undefined) {
+                    return (type) => {
+                        return narrowTypeForDiscriminatedLiteralFieldComparison(evaluator, type, memberName.value, rightType, adjIsPositiveTest);
+                    };
+                }
+            }
+            // Look for X.Y is None or X.Y is not None
+            // These are commonly-used patterns used in control flow.
+            if (testExpression.leftExpression.nodeType === 35 /* MemberAccess */ &&
+                ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression.leftExpression) &&
+                testExpression.rightExpression.nodeType === 11 /* Constant */ &&
+                testExpression.rightExpression.constType === 26 /* None */) {
+                const memberName = testExpression.leftExpression.memberName;
+                return (type) => {
+                    return narrowTypeForDiscriminatedFieldNoneComparison(evaluator, type, memberName.value, adjIsPositiveTest);
+                };
+            }
+        }
+        if (testExpression.operator === 41 /* In */ || testExpression.operator === 42 /* NotIn */) {
+            // Look for "x in y" or "x not in y" where y is one of several built-in types.
+            if (ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression)) {
+                const rightType = evaluator.getTypeOfExpression(testExpression.rightExpression).type;
+                const adjIsPositiveTest = testExpression.operator === 41 /* In */ ? isPositiveTest : !isPositiveTest;
+                if (adjIsPositiveTest) {
+                    return (type) => {
+                        return narrowTypeForContains(evaluator, type, rightType);
+                    };
+                }
+            }
+            if (ParseTreeUtils.isMatchingExpression(reference, testExpression.rightExpression)) {
+                // Look for <string literal> in y where y is a union that contains
+                // one or more TypedDicts.
+                const leftType = evaluator.getTypeOfExpression(testExpression.leftExpression).type;
+                if ((0, types_1.isClassInstance)(leftType) && types_1.ClassType.isBuiltIn(leftType, 'str') && (0, typeUtils_1.isLiteralType)(leftType)) {
+                    const adjIsPositiveTest = testExpression.operator === 41 /* In */ ? isPositiveTest : !isPositiveTest;
+                    return (type) => {
+                        return narrowTypeForTypedDictKey(evaluator, type, types_1.ClassType.cloneAsInstantiable(leftType), adjIsPositiveTest);
+                    };
+                }
+            }
+        }
+    }
+    if (testExpression.nodeType === 9 /* Call */) {
+        const callType = evaluator.getTypeOfExpression(testExpression.leftExpression, 2 /* DoNotSpecialize */).type;
+        // Look for "isinstance(X, Y)" or "issubclass(X, Y)".
+        if ((0, types_1.isFunction)(callType) &&
+            (callType.details.builtInName === 'isinstance' || callType.details.builtInName === 'issubclass') &&
+            testExpression.arguments.length === 2) {
+            // Make sure the first parameter is a supported expression type
+            // and the second parameter is a valid class type or a tuple
+            // of valid class types.
+            const isInstanceCheck = callType.details.builtInName === 'isinstance';
+            const arg0Expr = testExpression.arguments[0].valueExpression;
+            const arg1Expr = testExpression.arguments[1].valueExpression;
+            if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
+                const arg1Type = evaluator.getTypeOfExpression(arg1Expr, 8 /* EvaluateStringLiteralAsType */ |
+                    32 /* ParamSpecDisallowed */ |
+                    128 /* TypeVarTupleDisallowed */).type;
+                const classTypeList = getIsInstanceClassTypes(arg1Type);
+                if (classTypeList) {
+                    return (type) => {
+                        const narrowedType = narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck, isPositiveTest, 
+                        /* allowIntersections */ false, testExpression);
+                        if (!(0, types_1.isNever)(narrowedType)) {
+                            return narrowedType;
+                        }
+                        // Try again with intersection types allowed.
+                        return narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck, isPositiveTest, 
+                        /* allowIntersections */ true, testExpression);
+                    };
+                }
+            }
+        }
+        // Look for "callable(X)"
+        if ((0, types_1.isFunction)(callType) &&
+            callType.details.builtInName === 'callable' &&
+            testExpression.arguments.length === 1) {
+            const arg0Expr = testExpression.arguments[0].valueExpression;
+            if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
+                return (type) => {
+                    let narrowedType = narrowTypeForCallable(evaluator, type, isPositiveTest, testExpression, 
+                    /* allowIntersections */ false);
+                    if (isPositiveTest && (0, types_1.isNever)(narrowedType)) {
+                        // Try again with intersections allowed.
+                        narrowedType = narrowTypeForCallable(evaluator, type, isPositiveTest, testExpression, 
+                        /* allowIntersections */ true);
+                    }
+                    return narrowedType;
+                };
+            }
+        }
+        // Look for "bool(X)"
+        if ((0, types_1.isInstantiableClass)(callType) &&
+            types_1.ClassType.isBuiltIn(callType, 'bool') &&
+            testExpression.arguments.length === 1 &&
+            !testExpression.arguments[0].name) {
+            if (ParseTreeUtils.isMatchingExpression(reference, testExpression.arguments[0].valueExpression)) {
+                return (type) => {
+                    return narrowTypeForTruthiness(evaluator, type, isPositiveTest);
+                };
+            }
+        }
+        // Look for a TypeGuard function.
+        if (testExpression.arguments.length >= 1) {
+            const arg0Expr = testExpression.arguments[0].valueExpression;
+            if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
+                // Does this look like it's a custom type guard function?
+                if ((0, types_1.isFunction)(callType) &&
+                    callType.details.declaredReturnType &&
+                    (0, types_1.isClassInstance)(callType.details.declaredReturnType) &&
+                    types_1.ClassType.isBuiltIn(callType.details.declaredReturnType, ['TypeGuard', 'StrictTypeGuard'])) {
+                    // Evaluate the type guard call expression.
+                    const functionReturnType = evaluator.getTypeOfExpression(testExpression).type;
+                    if ((0, types_1.isClassInstance)(functionReturnType) &&
+                        types_1.ClassType.isBuiltIn(functionReturnType, 'bool') &&
+                        functionReturnType.typeGuardType) {
+                        const isStrictTypeGuard = types_1.ClassType.isBuiltIn(callType.details.declaredReturnType, 'StrictTypeGuard');
+                        const typeGuardType = functionReturnType.typeGuardType;
+                        return (type) => {
+                            return narrowTypeForUserDefinedTypeGuard(evaluator, type, typeGuardType, isPositiveTest, isStrictTypeGuard);
+                        };
+                    }
+                }
+            }
+        }
+    }
+    if (ParseTreeUtils.isMatchingExpression(reference, testExpression)) {
+        return (type) => {
+            return narrowTypeForTruthiness(evaluator, type, isPositiveTest);
+        };
+    }
+    // Is this a reference to an aliased conditional expression (a local variable
+    // that was assigned a value that can inform type narrowing of the reference expression)?
+    const narrowingCallback = getTypeNarrowingCallbackForAliasedCondition(evaluator, reference, testExpression, isPositiveTest, recursionCount);
+    if (narrowingCallback) {
+        return narrowingCallback;
+    }
+    // We normally won't find a "not" operator here because they are stripped out
+    // by the binder when it creates condition flow nodes, but we can find this
+    // in the case of local variables type narrowing.
+    if (reference.nodeType === 38 /* Name */) {
+        if (testExpression.nodeType === 55 /* UnaryOperation */ && testExpression.operator === 38 /* Not */) {
+            return getTypeNarrowingCallback(evaluator, reference, testExpression.expression, !isPositiveTest, recursionCount);
+        }
+    }
+    return undefined;
+}
+exports.getTypeNarrowingCallback = getTypeNarrowingCallback;
+function getTypeNarrowingCallbackForAliasedCondition(evaluator, reference, testExpression, isPositiveTest, recursionCount) {
+    if (testExpression.nodeType !== 38 /* Name */ ||
+        reference.nodeType !== 38 /* Name */ ||
+        testExpression === reference) {
+        return undefined;
+    }
+    // Make sure the reference expression is a constant parameter or variable.
+    // If the reference expression is modified within the scope multiple times,
+    // we need to validate that it is not modified between the test expression
+    // evaluation and the conditional check.
+    const testExprDecl = getDeclsForLocalVar(evaluator, testExpression, testExpression);
+    if (!testExprDecl || testExprDecl.length !== 1 || testExprDecl[0].type !== 1 /* Variable */) {
+        return undefined;
+    }
+    const referenceDecls = getDeclsForLocalVar(evaluator, reference, testExpression);
+    if (!referenceDecls) {
+        return undefined;
+    }
+    let modifyingDecls = [];
+    if (referenceDecls.length > 1) {
+        // If there is more than one assignment to the reference variable within
+        // the local scope, make sure that none of these assignments are done
+        // after the test expression but before the condition check.
+        //
+        // This is OK:
+        //  val = None
+        //  is_none = val is None
+        //  if is_none: ...
+        //
+        // This is not OK:
+        //  val = None
+        //  is_none = val is None
+        //  val = 1
+        //  if is_none: ...
+        modifyingDecls = referenceDecls.filter((decl) => {
+            return (evaluator.isNodeReachable(testExpression, decl.node) &&
+                evaluator.isNodeReachable(decl.node, testExprDecl[0].node));
+        });
+    }
+    if (modifyingDecls.length !== 0) {
+        return undefined;
+    }
+    const initNode = testExprDecl[0].inferredTypeSource;
+    if (!initNode || ParseTreeUtils.isNodeContainedWithin(testExpression, initNode) || !(0, parseNodes_1.isExpressionNode)(initNode)) {
+        return undefined;
+    }
+    return getTypeNarrowingCallback(evaluator, reference, initNode, isPositiveTest, recursionCount);
+}
+// Determines whether the symbol is a local variable or parameter within
+// the current scope.
+function getDeclsForLocalVar(evaluator, name, reachableFrom) {
+    const scope = (0, scopeUtils_1.getScopeForNode)(name);
+    if ((scope === null || scope === void 0 ? void 0 : scope.type) !== 1 /* Function */ && (scope === null || scope === void 0 ? void 0 : scope.type) !== 3 /* Module */) {
+        return undefined;
+    }
+    const symbol = scope.lookUpSymbol(name.value);
+    if (!symbol) {
+        return undefined;
+    }
+    const decls = symbol.getDeclarations();
+    if (decls.length === 0 ||
+        decls.some((decl) => decl.type !== 1 /* Variable */ && decl.type !== 2 /* Parameter */)) {
+        return undefined;
+    }
+    // If there are any assignments within different scopes (e.g. via a "global" or
+    // "nonlocal" reference), don't consider it a local variable.
+    let prevDeclScope;
+    if (decls.some((decl) => {
+        const nodeToConsider = decl.type === 2 /* Parameter */ ? decl.node.name : decl.node;
+        const declScopeNode = ParseTreeUtils.getExecutionScopeNode(nodeToConsider);
+        if (prevDeclScope && declScopeNode !== prevDeclScope) {
+            return true;
+        }
+        prevDeclScope = declScopeNode;
+        return false;
+    })) {
+        return undefined;
+    }
+    const reachableDecls = decls.filter((decl) => evaluator.isNodeReachable(reachableFrom, decl.node));
+    return reachableDecls.length > 0 ? reachableDecls : undefined;
+}
+function getTypeNarrowingCallbackForAssignmentExpression(evaluator, reference, testExpression, isPositiveTest, recursionCount) {
+    var _a;
+    return ((_a = getTypeNarrowingCallback(evaluator, reference, testExpression.rightExpression, isPositiveTest, recursionCount)) !== null && _a !== void 0 ? _a : getTypeNarrowingCallback(evaluator, reference, testExpression.name, isPositiveTest, recursionCount));
+}
+function narrowTypeForUserDefinedTypeGuard(evaluator, type, typeGuardType, isPositiveTest, isStrictTypeGuard) {
+    // For non-strict type guards, always narrow to the typeGuardType
+    // in the positive case and don't narrow in the negative case.
+    if (!isStrictTypeGuard) {
+        return isPositiveTest ? typeGuardType : type;
+    }
+    // For strict type guards, narrow the current type.
+    return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
+        return (0, typeUtils_1.mapSubtypes)(typeGuardType, (typeGuardSubtype) => {
+            const isSubType = evaluator.assignType(typeGuardType, subtype);
+            const isSuperType = evaluator.assignType(subtype, typeGuardSubtype);
+            if (isPositiveTest) {
+                if (isSubType) {
+                    return subtype;
+                }
+                else if (isSuperType) {
+                    return typeGuardSubtype;
+                }
+            }
+            else {
+                if (!isSubType && !isSubType) {
+                    return subtype;
+                }
+            }
+            return undefined;
+        });
+    });
+}
+// Narrow the type based on whether the subtype can be true or false.
+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;
+    });
+}
+// Handle type narrowing for expressions of the form "a[I] is None" and "a[I] is not None" where
+// I is an integer and a is a union of Tuples (or subtypes thereof) with known lengths and entry types.
+function narrowTupleTypeForIsNone(evaluator, type, isPositiveTest, indexValue) {
+    return evaluator.mapSubtypesExpandTypeVars(type, /* conditionFilter */ undefined, (subtype) => {
+        const tupleType = (0, typeUtils_1.getSpecializedTupleType)(subtype);
+        if (!tupleType || (0, typeUtils_1.isUnboundedTupleClass)(tupleType) || !tupleType.tupleTypeArguments) {
+            return subtype;
+        }
+        const tupleLength = tupleType.tupleTypeArguments.length;
+        if (indexValue < 0 || indexValue >= tupleLength) {
+            return subtype;
+        }
+        const typeOfEntry = evaluator.makeTopLevelTypeVarsConcrete(tupleType.tupleTypeArguments[indexValue].type);
+        if (isPositiveTest) {
+            if (!evaluator.assignType(typeOfEntry, types_1.NoneType.createInstance())) {
+                return undefined;
+            }
+        }
+        else {
+            if ((0, types_1.isNoneInstance)(typeOfEntry)) {
+                return undefined;
+            }
+        }
+        return subtype;
+    });
+}
+// Handle type narrowing for expressions of the form "x is None" and "x is not None".
+function narrowTypeForIsNone(evaluator, type, isPositiveTest) {
+    const expandedType = (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
+        return (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(subtype);
+    });
+    return evaluator.mapSubtypesExpandTypeVars(expandedType, 
+    /* conditionFilter */ undefined, (subtype, unexpandedSubtype) => {
+        if ((0, types_1.isAnyOrUnknown)(subtype)) {
+            // We need to assume that "Any" is always both None and not None,
+            // so it matches regardless of whether the test is positive or negative.
+            return subtype;
+        }
+        // If this is a TypeVar that isn't constrained, use the unexpanded
+        // TypeVar. For all other cases (including constrained TypeVars),
+        // use the expanded subtype.
+        const adjustedSubtype = (0, types_1.isTypeVar)(unexpandedSubtype) && unexpandedSubtype.details.constraints.length === 0
+            ? unexpandedSubtype
+            : subtype;
+        // See if it's a match for object.
+        if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'object')) {
+            return isPositiveTest
+                ? (0, typeUtils_1.addConditionToType)(types_1.NoneType.createInstance(), subtype.condition)
+                : adjustedSubtype;
+        }
+        // See if it's a match for None.
+        if ((0, types_1.isNoneInstance)(subtype) === isPositiveTest) {
+            return subtype;
+        }
+        return undefined;
+    });
+}
+// The "isinstance" and "issubclass" calls support two forms - a simple form
+// that accepts a single class, and a more complex form that accepts a tuple
+// of classes (including arbitrarily-nested tuples). This method determines
+// which form and returns a list of classes or undefined.
+function getIsInstanceClassTypes(argType) {
+    let foundNonClassType = false;
+    const classTypeList = [];
+    // Create a helper function that returns a list of class types or
+    // undefined if any of the types are not valid.
+    const addClassTypesToList = (types) => {
+        types.forEach((subtype) => {
+            if ((0, types_1.isInstantiableClass)(subtype) || ((0, types_1.isTypeVar)(subtype) && types_1.TypeBase.isInstantiable(subtype))) {
+                classTypeList.push(subtype);
+            }
+            else if ((0, types_1.isNoneTypeClass)(subtype)) {
+                classTypeList.push(subtype);
+            }
+            else if ((0, types_1.isFunction)(subtype) &&
+                subtype.details.parameters.length === 2 &&
+                subtype.details.parameters[0].category === 1 /* VarArgList */ &&
+                subtype.details.parameters[1].category === 2 /* VarArgDictionary */) {
+                classTypeList.push(subtype);
+            }
+            else {
+                foundNonClassType = true;
+            }
+        });
+    };
+    const addClassTypesRecursive = (subtype, recursionCount = 0) => {
+        if (recursionCount > types_1.maxTypeRecursionCount) {
+            return;
+        }
+        if ((0, types_1.isClass)(subtype) && types_1.TypeBase.isInstance(subtype) && (0, typeUtils_1.isTupleClass)(subtype)) {
+            if (subtype.tupleTypeArguments) {
+                subtype.tupleTypeArguments.forEach((tupleEntry) => {
+                    addClassTypesRecursive(tupleEntry.type, recursionCount + 1);
+                });
+            }
+        }
+        else {
+            addClassTypesToList([subtype]);
+        }
+    };
+    (0, typeUtils_1.doForEachSubtype)(argType, (subtype) => {
+        addClassTypesRecursive(subtype);
+    });
+    return foundNonClassType ? undefined : classTypeList;
+}
+// Attempts to narrow a type (make it more constrained) based on a
+// call to isinstance or issubclass. For example, if the original
+// type of expression "x" is "Mammal" and the test expression is
+// "isinstance(x, Cow)", (assuming "Cow" is a subclass of "Mammal"),
+// we can conclude that x must be constrained to "Cow".
+function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck, isPositiveTest, allowIntersections, errorNode) {
+    const expandedTypes = (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
+        return (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(subtype);
+    });
+    // Filters the varType by the parameters of the isinstance
+    // and returns the list of types the varType could be after
+    // applying the filter.
+    const filterClassType = (varType, unexpandedType, constraints, negativeFallbackType) => {
+        const filteredTypes = [];
+        let foundSuperclass = false;
+        let isClassRelationshipIndeterminate = false;
+        for (const filterType of classTypeList) {
+            const concreteFilterType = evaluator.makeTopLevelTypeVarsConcrete(filterType);
+            if ((0, types_1.isInstantiableClass)(concreteFilterType)) {
+                // 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.
+                const filterIsSuperclass = !(0, types_1.isTypeVar)(filterType) &&
+                    (types_1.ClassType.isDerivedFrom(varType, concreteFilterType) ||
+                        (isInstanceCheck &&
+                            types_1.ClassType.isProtocolClass(concreteFilterType) &&
+                            evaluator.assignType(concreteFilterType, varType)) ||
+                        (types_1.ClassType.isBuiltIn(concreteFilterType, 'dict') && types_1.ClassType.isTypedDictClass(varType)));
+                const filterIsSubclass = types_1.ClassType.isDerivedFrom(concreteFilterType, varType) ||
+                    (isInstanceCheck &&
+                        types_1.ClassType.isProtocolClass(varType) &&
+                        evaluator.assignType(varType, concreteFilterType));
+                if (filterIsSuperclass) {
+                    foundSuperclass = true;
+                }
+                // Normally, a type should never be both a subclass or a superclass.
+                // This can happen if either of the class types derives from a
+                // class whose type is unknown (e.g. an import failed). We'll
+                // note this case specially so we don't do any narrowing, which
+                // will generate false positives.
+                if (filterIsSubclass &&
+                    filterIsSuperclass &&
+                    !types_1.ClassType.isSameGenericClass(varType, concreteFilterType)) {
+                    isClassRelationshipIndeterminate = true;
+                }
+                if (isPositiveTest) {
+                    if (filterIsSuperclass) {
+                        // If the variable type is a subclass of the isinstance filter,
+                        // we haven't learned anything new about the variable type.
+                        filteredTypes.push((0, typeUtils_1.addConditionToType)(varType, constraints));
+                    }
+                    else if (filterIsSubclass) {
+                        // If the variable type is a superclass of the isinstance
+                        // filter, we can narrow the type to the subclass.
+                        let specializedFilterType = filterType;
+                        // Try to retain the type arguments for the filter type. This is
+                        // important because a specialized version of the filter cannot
+                        // be passed to isinstance or issubclass.
+                        if ((0, types_1.isClass)(filterType)) {
+                            if (types_1.ClassType.isSpecialBuiltIn(filterType) ||
+                                filterType.details.typeParameters.length > 0) {
+                                const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(filterType));
+                                const unspecializedFilterType = types_1.ClassType.cloneForSpecialization(filterType, 
+                                /* typeArguments */ undefined, 
+                                /* isTypeArgumentExplicit */ false);
+                                if ((0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluator, unspecializedFilterType, varType, typeVarContext, 
+                                /* liveTypeVarScopes */ undefined)) {
+                                    specializedFilterType = (0, typeUtils_1.applySolvedTypeVars)(unspecializedFilterType, typeVarContext, 
+                                    /* unknownIfNotFound */ true);
+                                }
+                            }
+                        }
+                        filteredTypes.push((0, typeUtils_1.addConditionToType)(specializedFilterType, constraints));
+                    }
+                    else if (allowIntersections) {
+                        // The two types appear to have no relation. It's possible that the
+                        // two types are protocols or the program is expecting one type to
+                        // be a mix-in class used with the other. In this case, we'll
+                        // synthesize a new class type that represents an intersection of
+                        // the two types.
+                        const className = `<subclass of ${varType.details.name} and ${concreteFilterType.details.name}>`;
+                        const fileInfo = (0, analyzerNodeInfo_1.getFileInfo)(errorNode);
+                        let newClassType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.filePath, 0 /* None */, ParseTreeUtils.getTypeSourceId(errorNode), 
+                        /* declaredMetaclass */ undefined, varType.details.effectiveMetaclass, varType.details.docString);
+                        newClassType.details.baseClasses = [types_1.ClassType.cloneAsInstantiable(varType), concreteFilterType];
+                        (0, typeUtils_1.computeMroLinearization)(newClassType);
+                        newClassType = (0, typeUtils_1.addConditionToType)(newClassType, concreteFilterType.condition);
+                        if ((0, types_1.isTypeVar)(unexpandedType) &&
+                            !unexpandedType.details.isParamSpec &&
+                            unexpandedType.details.constraints.length === 0) {
+                            newClassType = (0, typeUtils_1.addConditionToType)(newClassType, [
+                                {
+                                    typeVarName: types_1.TypeVarType.getNameWithScope(unexpandedType),
+                                    constraintIndex: 0,
+                                    isConstrainedTypeVar: false,
+                                },
+                            ]);
+                        }
+                        const newClassInstanceType = types_1.ClassType.cloneAsInstance(newClassType);
+                        // If this is a issubclass check, we do a double conversion from instantiable
+                        // to instance back to instantiable to make sure that the includeSubclasses flag
+                        // gets cleared.
+                        filteredTypes.push(isInstanceCheck ? newClassInstanceType : types_1.ClassType.cloneAsInstantiable(newClassInstanceType));
+                    }
+                }
+            }
+            else if ((0, types_1.isTypeVar)(filterType) && types_1.TypeBase.isInstantiable(filterType)) {
+                // Handle the case where the filter type is Type[T] and the unexpanded
+                // subtype is some instance type, possibly T.
+                if (isInstanceCheck && types_1.TypeBase.isInstance(unexpandedType)) {
+                    if ((0, types_1.isTypeVar)(unexpandedType) && (0, types_1.isTypeSame)((0, typeUtils_1.convertToInstance)(filterType), unexpandedType)) {
+                        // If the unexpanded subtype is T, we can definitively filter
+                        // in both the positive and negative cases.
+                        if (isPositiveTest) {
+                            filteredTypes.push(unexpandedType);
+                        }
+                    }
+                    else {
+                        if (isPositiveTest) {
+                            filteredTypes.push((0, typeUtils_1.convertToInstance)(filterType));
+                        }
+                        else {
+                            // If the unexpanded subtype is some other instance, we can't
+                            // filter anything because it might be an instance.
+                            filteredTypes.push(unexpandedType);
+                            isClassRelationshipIndeterminate = true;
+                        }
+                    }
+                }
+                else if (!isInstanceCheck && types_1.TypeBase.isInstantiable(unexpandedType)) {
+                    if ((0, types_1.isTypeVar)(unexpandedType) && (0, types_1.isTypeSame)(filterType, unexpandedType)) {
+                        if (isPositiveTest) {
+                            filteredTypes.push(unexpandedType);
+                        }
+                    }
+                    else {
+                        if (isPositiveTest) {
+                            filteredTypes.push(filterType);
+                        }
+                        else {
+                            filteredTypes.push(unexpandedType);
+                            isClassRelationshipIndeterminate = true;
+                        }
+                    }
+                }
+            }
+            else if ((0, types_1.isFunction)(filterType)) {
+                // Handle an isinstance check against Callable.
+                if (isInstanceCheck) {
+                    let isCallable = false;
+                    if ((0, types_1.isClass)(varType)) {
+                        if (types_1.TypeBase.isInstantiable(unexpandedType)) {
+                            isCallable = true;
+                        }
+                        else {
+                            isCallable = !!(0, typeUtils_1.lookUpClassMember)(varType, '__call__');
+                        }
+                    }
+                    if (isCallable) {
+                        if (isPositiveTest) {
+                            filteredTypes.push(unexpandedType);
+                        }
+                        else {
+                            foundSuperclass = true;
+                        }
+                    }
+                }
+            }
+        }
+        // In the negative case, if one or more of the filters
+        // always match the type (i.e. they are an exact match or
+        // a superclass of the type), then there's nothing left after
+        // the filter is applied. If we didn't find any superclass
+        // match, then the original variable type survives the filter.
+        if (!isPositiveTest) {
+            if (!foundSuperclass || isClassRelationshipIndeterminate) {
+                filteredTypes.push(negativeFallbackType);
+            }
+        }
+        if (!isInstanceCheck) {
+            return filteredTypes;
+        }
+        return filteredTypes.map((t) => (0, typeUtils_1.convertToInstance)(t));
+    };
+    const filterFunctionType = (varType, unexpandedType) => {
+        const filteredTypes = [];
+        if (isPositiveTest) {
+            for (const filterType of classTypeList) {
+                const concreteFilterType = evaluator.makeTopLevelTypeVarsConcrete(filterType);
+                if (evaluator.assignType(varType, (0, typeUtils_1.convertToInstance)(concreteFilterType))) {
+                    // If the filter type is a Callable, use the original type. If the
+                    // filter type is a callback protocol, use the filter type.
+                    if ((0, types_1.isFunction)(filterType)) {
+                        filteredTypes.push(unexpandedType);
+                    }
+                    else {
+                        filteredTypes.push((0, typeUtils_1.convertToInstance)(filterType));
+                    }
+                }
+            }
+        }
+        else if (!classTypeList.some((filterType) => {
+            // If the filter type is a runtime checkable protocol class, it can
+            // be used in an instance check.
+            const concreteFilterType = evaluator.makeTopLevelTypeVarsConcrete(filterType);
+            if ((0, types_1.isClass)(concreteFilterType) && !types_1.ClassType.isProtocolClass(concreteFilterType)) {
+                return false;
+            }
+            return evaluator.assignType(varType, (0, typeUtils_1.convertToInstance)(concreteFilterType));
+        })) {
+            filteredTypes.push(unexpandedType);
+        }
+        return filteredTypes;
+    };
+    const anyOrUnknownSubstitutions = [];
+    const anyOrUnknown = [];
+    const filteredType = evaluator.mapSubtypesExpandTypeVars(expandedTypes, 
+    /* conditionFilter */ undefined, (subtype, unexpandedSubtype) => {
+        // If we fail to filter anything in the negative case, we need to decide
+        // whether to retain the original TypeVar or replace it with its specialized
+        // type(s). We'll assume that if someone is using isinstance or issubclass
+        // on a constrained TypeVar that they want to filter based on its constrained
+        // parts.
+        const negativeFallback = (0, typeUtils_1.getTypeCondition)(subtype) ? subtype : unexpandedSubtype;
+        const isSubtypeTypeObject = (0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'type');
+        if (isPositiveTest && (0, types_1.isAnyOrUnknown)(subtype)) {
+            // If this is a positive test and the effective type is Any or
+            // Unknown, we can assume that the type matches one of the
+            // specified types.
+            if (isInstanceCheck) {
+                anyOrUnknownSubstitutions.push((0, types_1.combineTypes)(classTypeList.map((classType) => (0, typeUtils_1.convertToInstance)(classType))));
+            }
+            else {
+                // We perform a double conversion from instance to instantiable
+                // here to make sure that the includeSubclasses flag is cleared
+                // if it's a class.
+                anyOrUnknownSubstitutions.push((0, types_1.combineTypes)(classTypeList.map((classType) => (0, typeUtils_1.convertToInstantiable)((0, typeUtils_1.convertToInstance)(classType)))));
+            }
+            anyOrUnknown.push(subtype);
+            return undefined;
+        }
+        if (isInstanceCheck) {
+            if ((0, types_1.isNoneInstance)(subtype)) {
+                const containsNoneType = classTypeList.some((t) => (0, types_1.isNoneTypeClass)(t));
+                if (isPositiveTest) {
+                    return containsNoneType ? subtype : undefined;
+                }
+                else {
+                    return containsNoneType ? undefined : subtype;
+                }
+            }
+            if ((0, types_1.isModule)(subtype) || ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'ModuleType'))) {
+                // Handle type narrowing for runtime-checkable protocols
+                // when applied to modules.
+                if (isPositiveTest) {
+                    const filteredTypes = classTypeList.filter((classType) => {
+                        const concreteClassType = evaluator.makeTopLevelTypeVarsConcrete(classType);
+                        return ((0, types_1.isInstantiableClass)(concreteClassType) && types_1.ClassType.isProtocolClass(concreteClassType));
+                    });
+                    if (filteredTypes.length > 0) {
+                        return (0, typeUtils_1.convertToInstance)((0, types_1.combineTypes)(filteredTypes));
+                    }
+                }
+            }
+            if ((0, types_1.isClassInstance)(subtype) && !isSubtypeTypeObject) {
+                return (0, types_1.combineTypes)(filterClassType(types_1.ClassType.cloneAsInstantiable(subtype), (0, typeUtils_1.convertToInstance)(unexpandedSubtype), (0, typeUtils_1.getTypeCondition)(subtype), negativeFallback));
+            }
+            if (((0, types_1.isFunction)(subtype) || (0, types_1.isOverloadedFunction)(subtype)) && isInstanceCheck) {
+                return (0, types_1.combineTypes)(filterFunctionType(subtype, (0, typeUtils_1.convertToInstance)(unexpandedSubtype)));
+            }
+            if ((0, types_1.isInstantiableClass)(subtype) || isSubtypeTypeObject) {
+                // Handle the special case of isinstance(x, type).
+                const includesTypeType = classTypeList.some((classType) => (0, types_1.isInstantiableClass)(classType) && types_1.ClassType.isBuiltIn(classType, 'type'));
+                if (isPositiveTest) {
+                    return includesTypeType ? negativeFallback : undefined;
+                }
+                else {
+                    return includesTypeType ? undefined : negativeFallback;
+                }
+            }
+        }
+        else {
+            if ((0, types_1.isInstantiableClass)(subtype)) {
+                return (0, types_1.combineTypes)(filterClassType(subtype, unexpandedSubtype, (0, typeUtils_1.getTypeCondition)(subtype), negativeFallback));
+            }
+            if (isSubtypeTypeObject) {
+                const objectType = evaluator.getBuiltInObject(errorNode, 'object');
+                if (objectType && (0, types_1.isClassInstance)(objectType)) {
+                    return (0, types_1.combineTypes)(filterClassType(types_1.ClassType.cloneAsInstantiable(objectType), (0, typeUtils_1.convertToInstantiable)(unexpandedSubtype), (0, typeUtils_1.getTypeCondition)(subtype), negativeFallback));
+                }
+            }
+        }
+        return isPositiveTest ? undefined : negativeFallback;
+    });
+    // If the result is Any/Unknown and contains no other subtypes and
+    // we have substitutions for Any/Unknown, use those instead. We don't
+    // want to apply this if the filtering produced something other than
+    // Any/Unknown. For example, if the statement is "isinstance(x, list)"
+    // and the type of x is "List[str] | int | Any", the result should be
+    // "List[str]", not "List[str] | List[Unknown]".
+    if ((0, types_1.isNever)(filteredType) && anyOrUnknownSubstitutions.length > 0) {
+        return (0, types_1.combineTypes)(anyOrUnknownSubstitutions);
+    }
+    if (anyOrUnknown.length > 0) {
+        return (0, types_1.combineTypes)([filteredType, ...anyOrUnknown]);
+    }
+    return filteredType;
+}
+// Attempts to narrow a union of tuples based on their known length.
+function narrowTypeForTupleLength(evaluator, referenceType, lengthValue, isPositiveTest) {
+    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) ||
+            (0, typeUtils_1.isUnboundedTupleClass)(concreteSubtype) ||
+            !concreteSubtype.tupleTypeArguments) {
+            return subtype;
+        }
+        const tupleLengthMatches = concreteSubtype.tupleTypeArguments.length === lengthValue;
+        return tupleLengthMatches === isPositiveTest ? subtype : undefined;
+    });
+}
+// Attempts to narrow a type (make it more constrained) based on an "in" or
+// "not in" binary expression.
+function narrowTypeForContains(evaluator, referenceType, containerType) {
+    // We support contains narrowing only for certain built-in types that have been specialized.
+    if (!(0, types_1.isClassInstance)(containerType) || !types_1.ClassType.isBuiltIn(containerType)) {
+        return referenceType;
+    }
+    const builtInName = containerType.details.name;
+    if (!['list', 'set', 'frozenset', 'deque', 'tuple', 'dict', 'defaultdict', 'OrderedDict'].some((name) => name === builtInName)) {
+        return referenceType;
+    }
+    if (!containerType.typeArguments || containerType.typeArguments.length < 1) {
+        return referenceType;
+    }
+    let elementType = containerType.typeArguments[0];
+    if ((0, typeUtils_1.isTupleClass)(containerType) && containerType.tupleTypeArguments) {
+        elementType = (0, types_1.combineTypes)(containerType.tupleTypeArguments.map((t) => t.type));
+    }
+    let canNarrow = true;
+    const elementTypeWithoutLiteral = (0, typeUtils_1.stripLiteralValue)(elementType);
+    const narrowedType = (0, typeUtils_1.mapSubtypes)(referenceType, (referenceSubtype) => {
+        const concreteReferenceType = evaluator.makeTopLevelTypeVarsConcrete(referenceSubtype);
+        if ((0, types_1.isAnyOrUnknown)(concreteReferenceType)) {
+            canNarrow = false;
+            return referenceSubtype;
+        }
+        if (evaluator.assignType(elementType, concreteReferenceType)) {
+            return referenceSubtype;
+        }
+        if (evaluator.assignType(elementTypeWithoutLiteral, concreteReferenceType)) {
+            return (0, typeUtils_1.mapSubtypes)(elementType, (elementSubtype) => {
+                if ((0, types_1.isClassInstance)(elementSubtype) && (0, types_1.isSameWithoutLiteralValue)(referenceSubtype, elementSubtype)) {
+                    return elementSubtype;
+                }
+                return undefined;
+            });
+        }
+        return undefined;
+    });
+    return canNarrow ? narrowedType : referenceType;
+}
+// Attempts to narrow a type based on whether it is a TypedDict with
+// a literal key value.
+function narrowTypeForTypedDictKey(evaluator, referenceType, literalKey, isPositiveTest) {
+    const narrowedType = (0, typeUtils_1.mapSubtypes)(referenceType, (subtype) => {
+        if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isTypedDictClass(subtype)) {
+            const entries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluator, subtype, /* allowNarrowed */ true);
+            const tdEntry = entries.get(literalKey.literalValue);
+            if (isPositiveTest) {
+                if (!tdEntry) {
+                    // If the class is final, we can say with certainty that if
+                    // the TypedDict doesn't define this entry, it is not this type.
+                    // If it's not final, we can't say this because it could be a
+                    // subclass of this TypedDict that adds more fields.
+                    return types_1.ClassType.isFinal(subtype) ? undefined : subtype;
+                }
+                // 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 oldNarrowedEntriesMap = subtype.typedDictNarrowedEntries;
+                const newNarrowedEntriesMap = new Map();
+                if (oldNarrowedEntriesMap) {
+                    // Copy the old entries.
+                    oldNarrowedEntriesMap.forEach((value, key) => {
+                        newNarrowedEntriesMap.set(key, value);
+                    });
+                }
+                // Add the new entry.
+                newNarrowedEntriesMap.set(literalKey.literalValue, {
+                    valueType: tdEntry.valueType,
+                    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 {
+                return tdEntry !== undefined && (tdEntry.isRequired || tdEntry.isProvided) ? undefined : subtype;
+            }
+        }
+        return subtype;
+    });
+    return narrowedType;
+}
+// Attempts to narrow a TypedDict type based on a comparison (equal or not
+// equal) between a discriminating entry type that has a declared literal
+// type to a literal value.
+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.get(indexLiteralType.literalValue);
+            if (tdEntry && (0, typeUtils_1.isLiteralTypeOrUnion)(tdEntry.valueType)) {
+                if (isPositiveTest) {
+                    return evaluator.assignType(tdEntry.valueType, literalType) ? subtype : undefined;
+                }
+                else {
+                    return evaluator.assignType(literalType, tdEntry.valueType) ? undefined : subtype;
+                }
+            }
+        }
+        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) => {
+        var _a;
+        if ((0, types_1.isClassInstance)(subtype) &&
+            types_1.ClassType.isTupleClass(subtype) &&
+            !(0, typeUtils_1.isUnboundedTupleClass)(subtype) &&
+            typeof indexLiteralType.literalValue === 'number') {
+            const indexValue = indexLiteralType.literalValue;
+            if (subtype.tupleTypeArguments && indexValue >= 0 && indexValue < subtype.tupleTypeArguments.length) {
+                const tupleEntryType = (_a = subtype.tupleTypeArguments[indexValue]) === null || _a === void 0 ? void 0 : _a.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;
+}
+// Attempts to narrow a type based on a comparison (equal or not equal)
+// between a discriminating field that has a declared literal type to a
+// literal value.
+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, typeUtils_1.isProperty)(memberType)) {
+                const getterInfo = (0, typeUtils_1.lookUpObjectMember)(memberType, 'fget');
+                if (getterInfo && getterInfo.isTypeDeclared) {
+                    const getterType = evaluator.getTypeOfMember(getterInfo);
+                    if ((0, types_1.isFunction)(getterType) && getterType.details.declaredReturnType) {
+                        const getterReturnType = types_1.FunctionType.getSpecializedReturnType(getterType);
+                        if (getterReturnType) {
+                            memberType = getterReturnType;
+                        }
+                    }
+                }
+            }
+            if ((0, typeUtils_1.isLiteralTypeOrUnion)(memberType)) {
+                if (isPositiveTest) {
+                    return evaluator.assignType(memberType, literalType) ? subtype : undefined;
+                }
+                else {
+                    return evaluator.assignType(literalType, memberType) ? undefined : subtype;
+                }
+            }
+        }
+        return subtype;
+    });
+    return narrowedType;
+}
+// Attempts to narrow a type based on a comparison (equal or not equal)
+// between a discriminating field that has a declared None type to a
+// None.
+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) {
+            const memberType = evaluator.makeTopLevelTypeVarsConcrete(evaluator.getTypeOfMember(memberInfo));
+            let canNarrow = true;
+            if (isPositiveTest) {
+                (0, typeUtils_1.doForEachSubtype)(memberType, (memberSubtype) => {
+                    memberSubtype = evaluator.makeTopLevelTypeVarsConcrete(memberSubtype);
+                    // Don't attempt to narrow if the member is a descriptor or property.
+                    if ((0, typeUtils_1.isProperty)(memberSubtype) || (0, typeUtils_1.isMaybeDescriptorInstance)(memberSubtype)) {
+                        canNarrow = false;
+                    }
+                    if ((0, types_1.isAnyOrUnknown)(memberSubtype) || (0, types_1.isNoneInstance)(memberSubtype) || (0, types_1.isNever)(memberSubtype)) {
+                        canNarrow = false;
+                    }
+                });
+            }
+            else {
+                canNarrow = (0, types_1.isNoneInstance)(memberType);
+            }
+            if (canNarrow) {
+                return undefined;
+            }
+        }
+        return subtype;
+    });
+}
+// Attempts to narrow a type based on a "type(x) is y" or "type(x) is not y" check.
+function narrowTypeForTypeIs(type, classType, isPositiveTest) {
+    return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
+        if ((0, types_1.isClassInstance)(subtype)) {
+            const matches = types_1.ClassType.isDerivedFrom(classType, types_1.ClassType.cloneAsInstantiable(subtype));
+            if (isPositiveTest) {
+                if (matches) {
+                    if (types_1.ClassType.isSameGenericClass(subtype, classType)) {
+                        return subtype;
+                    }
+                    return types_1.ClassType.cloneAsInstance(classType);
+                }
+                return undefined;
+            }
+            else {
+                // If the class if marked final and it matches, then
+                // we can eliminate it in the negative case.
+                if (matches && types_1.ClassType.isFinal(subtype)) {
+                    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;
+            }
+        }
+        else if ((0, types_1.isNoneInstance)(subtype)) {
+            return isPositiveTest ? undefined : subtype;
+        }
+        else if ((0, types_1.isAnyOrUnknown)(subtype)) {
+            return isPositiveTest ? types_1.ClassType.cloneAsInstance(classType) : subtype;
+        }
+        return subtype;
+    });
+}
+// Attempts to narrow a type (make it more constrained) based on a comparison
+// (equal or not equal) to a literal value. It also handles "is" or "is not"
+// operators if isIsOperator is true.
+function narrowTypeForLiteralComparison(evaluator, referenceType, literalType, isPositiveTest, isIsOperator) {
+    return (0, typeUtils_1.mapSubtypes)(referenceType, (subtype) => {
+        subtype = evaluator.makeTopLevelTypeVarsConcrete(subtype);
+        if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isSameGenericClass(literalType, subtype)) {
+            if (subtype.literalValue !== undefined) {
+                const literalValueMatches = types_1.ClassType.isLiteralValueSame(subtype, literalType);
+                if ((literalValueMatches && !isPositiveTest) || (!literalValueMatches && isPositiveTest)) {
+                    return undefined;
+                }
+                return subtype;
+            }
+            else if (isPositiveTest) {
+                return literalType;
+            }
+            else {
+                // 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) => !types_1.ClassType.isLiteralValueSame(type, literalType)));
+                }
+            }
+        }
+        else if (isPositiveTest) {
+            if (isIsOperator || (0, types_1.isNoneInstance)(subtype)) {
+                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)) {
+        // Enumerate all of the values in this enumeration.
+        const enumList = [];
+        const fields = type.details.fields;
+        fields.forEach((symbol) => {
+            if (!symbol.isIgnoredForProtocolMatch()) {
+                const symbolType = evaluator.getEffectiveTypeOfSymbol(symbol);
+                if ((0, types_1.isClassInstance)(symbolType) &&
+                    types_1.ClassType.isSameGenericClass(type, symbolType) &&
+                    symbolType.literalValue !== undefined) {
+                    enumList.push(symbolType);
+                }
+            }
+        });
+        return enumList;
+    }
+    return undefined;
+}
+exports.enumerateLiteralsForType = enumerateLiteralsForType;
+// Attempts to narrow a type (make it more constrained) based on a
+// call to "callable". For example, if the original type of expression "x" is
+// Union[Callable[..., Any], Type[int], int], it would remove the "int" because
+// it's not callable.
+function narrowTypeForCallable(evaluator, type, isPositiveTest, errorNode, allowIntersections) {
+    return evaluator.mapSubtypesExpandTypeVars(type, /* conditionFilter */ undefined, (subtype) => {
+        switch (subtype.category) {
+            case 5 /* Function */:
+            case 6 /* OverloadedFunction */: {
+                return isPositiveTest ? subtype : undefined;
+            }
+            case 3 /* None */:
+            case 8 /* Module */: {
+                return isPositiveTest ? undefined : subtype;
+            }
+            case 7 /* Class */: {
+                if (types_1.TypeBase.isInstantiable(subtype)) {
+                    return isPositiveTest ? subtype : undefined;
+                }
+                // See if the object is callable.
+                const callMemberType = (0, typeUtils_1.lookUpClassMember)(subtype, '__call__');
+                if (!callMemberType) {
+                    if (!isPositiveTest) {
+                        return subtype;
+                    }
+                    if (allowIntersections) {
+                        // The type appears to not be callable. It's possible that the
+                        // two type is a subclass that is callable. We'll synthesize a
+                        // new intersection type.
+                        const className = `<callable subtype of ${subtype.details.name}>`;
+                        const fileInfo = (0, analyzerNodeInfo_1.getFileInfo)(errorNode);
+                        let newClassType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.filePath, 0 /* None */, ParseTreeUtils.getTypeSourceId(errorNode), 
+                        /* declaredMetaclass */ undefined, subtype.details.effectiveMetaclass, subtype.details.docString);
+                        newClassType.details.baseClasses = [types_1.ClassType.cloneAsInstantiable(subtype)];
+                        (0, typeUtils_1.computeMroLinearization)(newClassType);
+                        newClassType = (0, typeUtils_1.addConditionToType)(newClassType, subtype.condition);
+                        // Add a __call__ method to the new class.
+                        const callMethod = types_1.FunctionType.createSynthesizedInstance('__call__');
+                        const selfParam = {
+                            category: 0 /* Simple */,
+                            name: 'self',
+                            type: types_1.ClassType.cloneAsInstance(newClassType),
+                            hasDeclaredType: true,
+                        };
+                        types_1.FunctionType.addParameter(callMethod, selfParam);
+                        types_1.FunctionType.addDefaultParameters(callMethod);
+                        callMethod.details.declaredReturnType = types_1.UnknownType.create();
+                        newClassType.details.fields.set('__call__', symbol_1.Symbol.createWithType(4 /* ClassMember */, callMethod));
+                        return types_1.ClassType.cloneAsInstance(newClassType);
+                    }
+                    return undefined;
+                }
+                else {
+                    return isPositiveTest ? subtype : undefined;
+                }
+            }
+            default: {
+                // For all other types, we can't determine whether it's
+                // callable or not, so we can't eliminate them.
+                return subtype;
+            }
+        }
+    });
+}
+//# sourceMappingURL=typeGuards.js.map