@zzzen/pyright-internal 1.2.0-dev.20240908 → 1.2.0-dev.20240922

package/dist/analyzer/typeGuards.js

@@ -33,17 +33,15 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Tree = exports.Plant = exports.Dog = exports.Animal = void 0;
 exports.getTypeNarrowingCallback = getTypeNarrowingCallback;
-exports.isIsinstanceFilterSuperclass = isIsinstanceFilterSuperclass;
-exports.isIsinstanceFilterSubclass = isIsinstanceFilterSubclass;
+exports.getIsInstanceClassTypes = getIsInstanceClassTypes;
+exports.narrowTypeForInstanceOrSubclass = narrowTypeForInstanceOrSubclass;
 exports.getElementTypeForContainerNarrowing = getElementTypeForContainerNarrowing;
 exports.narrowTypeForContainerElementType = narrowTypeForContainerElementType;
 exports.narrowTypeForDiscriminatedDictEntryComparison = narrowTypeForDiscriminatedDictEntryComparison;
 exports.narrowTypeForDiscriminatedTupleComparison = narrowTypeForDiscriminatedTupleComparison;
 exports.narrowTypeForDiscriminatedLiteralFieldComparison = narrowTypeForDiscriminatedLiteralFieldComparison;
 exports.enumerateLiteralsForType = enumerateLiteralsForType;
-exports.func1 = func1;
 const debug_1 = require("../common/debug");
 const parseNodes_1 = require("../parser/parseNodes");
 const analyzerNodeInfo_1 = require("./analyzerNodeInfo");
@@ -127,7 +125,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                 if (ParseTreeUtils.isMatchingExpression(reference, leftExpression)) {
                     return (type) => {
                         return {
-                            type: narrowTypeForIsEllipsis(evaluator, type, adjIsPositiveTest),
+                            type: narrowTypeForIsEllipsis(evaluator, testExpression, type, adjIsPositiveTest),
                             isIncomplete: false,
                         };
                     };
@@ -230,12 +228,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                 // Look for X == <literal> or X != <literal>
                 const adjIsPositiveTest = testExpression.d.operator === 12 /* OperatorType.Equals */ ? isPositiveTest : !isPositiveTest;
                 if (ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr)) {
-                    // Use speculative mode here to avoid polluting the type cache. This is
-                    // important in cases where evaluation of the right expression creates
-                    // a false dependency on another variable.
-                    const rightTypeResult = evaluator.useSpeculativeMode(testExpression.d.rightExpr, () => {
-                        return evaluator.getTypeOfExpression(testExpression.d.rightExpr);
-                    });
+                    const rightTypeResult = evaluator.getTypeOfExpression(testExpression.d.rightExpr);
                     const rightType = rightTypeResult.type;
                     if ((0, types_1.isClassInstance)(rightType) && rightType.priv.literalValue !== undefined) {
                         return (type) => {
@@ -417,7 +410,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                     if (classTypeList) {
                         return (type) => {
                             return {
-                                type: narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck, 
+                                type: narrowTypeForInstanceOrSubclass(evaluator, type, classTypeList, isInstanceCheck, 
                                 /* isTypeIsCheck */ false, isPositiveTest, testExpression),
                                 isIncomplete,
                             };
@@ -436,26 +429,6 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                 }
             }
         }
-        // Look for "callable(X)"
-        if (testExpression.d.args.length === 1) {
-            const arg0Expr = testExpression.d.args[0].d.valueExpr;
-            if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
-                const callTypeResult = evaluator.getTypeOfExpression(testExpression.d.leftExpr, 2 /* EvalFlags.CallBaseDefaults */);
-                const callType = callTypeResult.type;
-                if ((0, types_1.isFunction)(callType) && types_1.FunctionType.isBuiltIn(callType, 'callable')) {
-                    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 { type: narrowedType, isIncomplete: !!callTypeResult.isIncomplete };
-                    };
-                }
-            }
-        }
         // Look for "bool(X)"
         if (testExpression.d.args.length === 1 && !testExpression.d.args[0].d.name) {
             if (ParseTreeUtils.isMatchingExpression(reference, testExpression.d.args[0].d.valueExpr)) {
@@ -650,7 +623,7 @@ function narrowTypeForUserDefinedTypeGuard(evaluator, type, typeGuardType, isPos
     (0, typeUtils_1.doForEachSubtype)(typeGuardType, (typeGuardSubtype) => {
         filterTypes.push((0, typeUtils_1.convertToInstantiable)(typeGuardSubtype));
     });
-    return narrowTypeForIsInstance(evaluator, type, filterTypes, 
+    return narrowTypeForInstanceOrSubclass(evaluator, type, filterTypes, 
     /* isInstanceCheck */ true, 
     /* isTypeIsCheck */ true, isPositiveTest, errorNode);
 }
@@ -752,10 +725,12 @@ function narrowTypeForIsNone(evaluator, type, isPositiveTest) {
     return result;
 }
 // Handle type narrowing for expressions of the form "x is ..." and "x is not ...".
-function narrowTypeForIsEllipsis(evaluator, type, isPositiveTest) {
+function narrowTypeForIsEllipsis(evaluator, node, type, isPositiveTest) {
+    var _a, _b;
     const expandedType = (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
         return (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(subtype);
     });
+    const ellipsisType = (_b = (_a = evaluator.getBuiltInObject(node, 'EllipsisType')) !== null && _a !== void 0 ? _a : evaluator.getBuiltInObject(node, 'ellipsis')) !== null && _b !== void 0 ? _b : types_1.AnyType.create();
     return evaluator.mapSubtypesExpandTypeVars(expandedType, /* options */ undefined, (subtype, unexpandedSubtype) => {
         var _a;
         if ((0, types_1.isAnyOrUnknown)(subtype)) {
@@ -771,9 +746,7 @@ function narrowTypeForIsEllipsis(evaluator, type, isPositiveTest) {
             : 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)(evaluator.getNoneType(), (_a = subtype.props) === null || _a === void 0 ? void 0 : _a.condition)
-                : adjustedSubtype;
+            return isPositiveTest ? (0, typeUtils_1.addConditionToType)(ellipsisType, (_a = subtype.props) === null || _a === void 0 ? void 0 : _a.condition) : adjustedSubtype;
         }
         const isEllipsis = (0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, ['EllipsisType', 'ellipsis']);
         // See if it's a match for "...".
@@ -849,68 +822,50 @@ function getIsInstanceClassTypes(evaluator, argType) {
     });
     return foundNonClassType ? undefined : classTypeList;
 }
-function isIsinstanceFilterSuperclass(evaluator, varType, concreteVarType, filterType, concreteFilterType, isInstanceCheck) {
-    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;
-    }
-    if (isInstanceCheck) {
-        // We convert both types to instances in case they are protocol
-        // classes. A protocol class isn't allowed to be assigned to
-        // type[T], so this would otherwise fail.
-        if (types_1.ClassType.isProtocolClass(concreteFilterType) &&
-            evaluator.assignType(types_1.ClassType.cloneAsInstance(concreteFilterType), types_1.ClassType.cloneAsInstance(concreteVarType))) {
-            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 isIsinstanceFilterSubclass(evaluator, varType, concreteFilterType, isInstanceCheck) {
-    if (types_1.ClassType.isDerivedFrom(concreteFilterType, varType)) {
-        return true;
-    }
-    if (isInstanceCheck) {
-        // We convert both types to instances in case they are protocol
-        // classes. A protocol class isn't allowed to be assigned to
-        // type[T], so this would otherwise fail.
-        if (types_1.ClassType.isProtocolClass(varType) &&
-            evaluator.assignType(types_1.ClassType.cloneAsInstance(varType), types_1.ClassType.cloneAsInstance(concreteFilterType))) {
-            return true;
-        }
-    }
-    return false;
-}
-function narrowTypeForIsInstance(evaluator, type, filterTypes, isInstanceCheck, isTypeIsCheck, isPositiveTest, errorNode) {
+function narrowTypeForInstanceOrSubclass(evaluator, type, filterTypes, isInstanceCheck, isTypeIsCheck, isPositiveTest, errorNode) {
     // First try with intersection types disallowed.
-    const narrowedType = narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanceCheck, isTypeIsCheck, isPositiveTest, 
+    const narrowedType = narrowTypeForInstanceOrSubclassInternal(evaluator, type, filterTypes, isInstanceCheck, isTypeIsCheck, isPositiveTest, 
     /* allowIntersections */ false, errorNode);
     if (!(0, types_1.isNever)(narrowedType)) {
         return narrowedType;
     }
     // Try again with intersection types allowed.
-    return narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanceCheck, isTypeIsCheck, isPositiveTest, 
+    return narrowTypeForInstanceOrSubclassInternal(evaluator, type, filterTypes, isInstanceCheck, isTypeIsCheck, isPositiveTest, 
     /* allowIntersections */ true, errorNode);
 }
-// Attempts to narrow a type (make it more constrained) based on a
-// call to isinstance or issubclass. For example, if the original
+function narrowTypeForInstanceOrSubclassInternal(evaluator, type, filterTypes, isInstanceCheck, isTypeIsCheck, isPositiveTest, allowIntersections, errorNode) {
+    const result = (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
+        let adjSubtype = subtype;
+        let resultRequiresAdj = false;
+        let adjFilterTypes = filterTypes;
+        if (!isInstanceCheck) {
+            const isTypeInstance = (0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'type');
+            if ((0, typeUtils_1.isMetaclassInstance)(subtype) && !isTypeInstance) {
+                // Handle metaclass instances specially.
+                adjFilterTypes = filterTypes.map((filterType) => (0, typeUtils_1.convertToInstantiable)(filterType));
+            }
+            else {
+                const convSubtype = (0, typeUtils_1.convertToInstance)(subtype);
+                // Handle type[Any] specially for this case.
+                if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'type') && (0, types_1.isAnyOrUnknown)(convSubtype)) {
+                    adjSubtype = (0, typeUtils_1.convertToInstance)(evaluator.getObjectType());
+                }
+                else {
+                    adjSubtype = convSubtype;
+                }
+                resultRequiresAdj = true;
+            }
+        }
+        const narrowedResult = narrowTypeForInstance(evaluator, adjSubtype, adjFilterTypes, isTypeIsCheck, isPositiveTest, allowIntersections, errorNode);
+        return resultRequiresAdj ? (0, typeUtils_1.convertToInstantiable)(narrowedResult) : narrowedResult;
+    });
+    return result;
+}
+// Narrows a type based on a call to isinstance. 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 narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanceCheck, isTypeIsCheck, isPositiveTest, allowIntersections, errorNode) {
+// "isinstance(x, Cow)", (assuming "Cow" is a subclass of "Mammal"), we can
+// narrow x to "Cow".
+function narrowTypeForInstance(evaluator, type, filterTypes, isTypeIsCheck, isPositiveTest, allowIntersections, errorNode) {
     let expandedTypes = (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
         return (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(subtype);
     });
@@ -928,23 +883,67 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
     // and returns the list of types the varType could be after
     // applying the filter.
     const filterClassType = (varType, concreteVarType, conditions, negativeFallbackType) => {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         const filteredTypes = [];
         let foundSuperclass = false;
         let isClassRelationshipIndeterminate = false;
         for (const filterType of filterTypes) {
             const concreteFilterType = evaluator.makeTopLevelTypeVarsConcrete(filterType);
             if ((0, types_1.isInstantiableClass)(concreteFilterType)) {
-                let filterIsSuperclass;
-                let filterIsSubclass;
-                if (isTypeIsCheck) {
-                    filterIsSuperclass = evaluator.assignType(filterType, concreteVarType);
-                    filterIsSubclass = evaluator.assignType(concreteVarType, filterType);
+                const filterMetaclass = concreteFilterType.shared.effectiveMetaclass;
+                if ((0, typeUtils_1.isInstantiableMetaclass)(concreteVarType) &&
+                    types_1.TypeBase.getInstantiableDepth(concreteFilterType) > 0 &&
+                    filterMetaclass &&
+                    (0, types_1.isInstantiableClass)(filterMetaclass)) {
+                    const metaclassType = (0, typeUtils_1.convertToInstance)(concreteVarType);
+                    let isMetaclassOverlap = evaluator.assignType(convertVarTypeToFree(metaclassType), types_1.ClassType.cloneAsInstance(filterMetaclass));
+                    // Handle the special case where the metaclass for the filter is type.
+                    // This will normally be treated as type[Any], which is compatible with
+                    // any metaclass, but we specifically want to treat type as the class
+                    // type[object] in this case.
+                    if (types_1.ClassType.isBuiltIn(filterMetaclass, 'type') && !filterMetaclass.priv.isTypeArgExplicit) {
+                        if (!types_1.ClassType.isBuiltIn(metaclassType, 'type')) {
+                            isMetaclassOverlap = false;
+                        }
+                    }
+                    if (isMetaclassOverlap) {
+                        if (isPositiveTest) {
+                            filteredTypes.push(filterType);
+                            foundSuperclass = true;
+                        }
+                        else if (!(0, types_1.isTypeSame)(metaclassType, filterMetaclass) ||
+                            filterMetaclass.priv.includeSubclasses) {
+                            filteredTypes.push(metaclassType);
+                            isClassRelationshipIndeterminate = true;
+                        }
+                        continue;
+                    }
                 }
-                else {
-                    filterIsSuperclass = isIsinstanceFilterSuperclass(evaluator, varType, concreteVarType, filterType, concreteFilterType, isInstanceCheck);
-                    filterIsSubclass = isIsinstanceFilterSubclass(evaluator, concreteVarType, concreteFilterType, isInstanceCheck);
+                let runtimeVarType = concreteVarType;
+                // Type variables are erased for runtime types, so switch from
+                // bound to free type variables. We'll retain the bound type
+                // variables for TypeIs checks.
+                if (!isTypeIsCheck) {
+                    runtimeVarType = (0, typeUtils_1.makeTypeVarsFree)(runtimeVarType, ParseTreeUtils.getTypeVarScopesForNode(errorNode));
+                }
+                // If the value is a TypedDict, convert it into its runtime form,
+                // which is a dict[str, Any].
+                if ((0, types_1.isInstantiableClass)(runtimeVarType) && types_1.ClassType.isTypedDictClass(runtimeVarType)) {
+                    const dictClass = evaluator.getDictClassType();
+                    const strType = evaluator.getStrClassType();
+                    if (dictClass && strType) {
+                        runtimeVarType = types_1.ClassType.specialize(dictClass, [
+                            types_1.ClassType.cloneAsInstance(strType),
+                            types_1.UnknownType.create(),
+                        ]);
+                    }
                 }
+                const filterIsSuperclass = evaluator.assignType(filterType, runtimeVarType, 
+                /* diag */ undefined, 
+                /* constraints */ undefined, 16384 /* AssignTypeFlags.AllowIsinstanceSpecialForms */ | 65536 /* AssignTypeFlags.AllowProtocolClassSource */);
+                const filterIsSubclass = evaluator.assignType(runtimeVarType, filterType, 
+                /* diag */ undefined, 
+                /* constraints */ undefined, 16384 /* AssignTypeFlags.AllowIsinstanceSpecialForms */ | 65536 /* AssignTypeFlags.AllowProtocolClassSource */);
                 if (filterIsSuperclass) {
                     foundSuperclass = true;
                 }
@@ -953,10 +952,16 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
                 // 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(concreteVarType, concreteFilterType)) {
-                    isClassRelationshipIndeterminate = true;
+                if (filterIsSubclass && filterIsSuperclass) {
+                    if (!isTypeIsCheck && concreteFilterType.priv.includeSubclasses) {
+                        // If the filter type includes subclasses, we can't eliminate
+                        // this type in the negative direction. We'll relax this for
+                        // TypeIs checks.
+                        isClassRelationshipIndeterminate = true;
+                    }
+                    if (!types_1.ClassType.isSameGenericClass(runtimeVarType, concreteFilterType)) {
+                        isClassRelationshipIndeterminate = true;
+                    }
                 }
                 // If both the variable type and the filter type ar generics, we can't
                 // determine the relationship between the two.
@@ -976,46 +981,44 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
                         }
                     }
                     else if (filterIsSubclass) {
-                        if (evaluator.assignType((0, typeUtils_1.convertToInstance)(convertVarTypeToFree(concreteVarType)), (0, typeUtils_1.convertToInstance)(concreteFilterType), 
-                        /* diag */ undefined, 
-                        /* constraints */ undefined, 16384 /* AssignTypeFlags.AllowIsinstanceSpecialForms */)) {
-                            // 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.shared.typeParams.length > 0) {
-                                    if (!filterType.priv.isTypeArgExplicit &&
-                                        !types_1.ClassType.isSameGenericClass(concreteVarType, filterType)) {
-                                        const constraints = new constraintTracker_1.ConstraintTracker();
-                                        const unspecializedFilterType = types_1.ClassType.specialize(filterType, 
-                                        /* typeArg */ undefined);
-                                        if ((0, constraintSolver_1.addConstraintsForExpectedType)(evaluator, (0, typeUtils_1.convertToInstance)(unspecializedFilterType), (0, typeUtils_1.convertToInstance)(concreteVarType), constraints, 
-                                        /* liveTypeVarScopes */ undefined, errorNode.start)) {
-                                            specializedFilterType = evaluator.solveAndApplyConstraints(unspecializedFilterType, constraints, {
-                                                replaceUnsolved: {
-                                                    scopeIds: (0, typeUtils_1.getTypeVarScopeIds)(filterType),
-                                                    useUnknown: true,
-                                                    tupleClassType: evaluator.getTupleClassType(),
-                                                },
-                                            });
-                                        }
+                        // 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.shared.typeParams.length > 0) {
+                                if (!filterType.priv.isTypeArgExplicit &&
+                                    !types_1.ClassType.isSameGenericClass(concreteVarType, filterType)) {
+                                    const constraints = new constraintTracker_1.ConstraintTracker();
+                                    const unspecializedFilterType = types_1.ClassType.specialize(filterType, 
+                                    /* typeArg */ undefined);
+                                    if ((0, constraintSolver_1.addConstraintsForExpectedType)(evaluator, (0, typeUtils_1.convertToInstance)(unspecializedFilterType), (0, typeUtils_1.convertToInstance)(concreteVarType), constraints, 
+                                    /* liveTypeVarScopes */ undefined, errorNode.start)) {
+                                        specializedFilterType = evaluator.solveAndApplyConstraints(unspecializedFilterType, constraints, {
+                                            replaceUnsolved: {
+                                                scopeIds: (0, typeUtils_1.getTypeVarScopeIds)(filterType),
+                                                useUnknown: true,
+                                                tupleClassType: evaluator.getTupleClassType(),
+                                            },
+                                        });
                                     }
                                 }
                             }
-                            filteredTypes.push((0, typeUtils_1.addConditionToType)(specializedFilterType, conditions));
                         }
+                        filteredTypes.push((0, typeUtils_1.addConditionToType)(specializedFilterType, conditions));
                     }
-                    else if (types_1.ClassType.isSameGenericClass(concreteVarType, concreteFilterType)) {
-                        // Don't attempt to narrow in this case.
-                        if (((_a = concreteVarType.priv) === null || _a === void 0 ? void 0 : _a.literalValue) === undefined &&
-                            ((_b = concreteFilterType.priv) === null || _b === void 0 ? void 0 : _b.literalValue) === undefined) {
-                            const intersection = intersectSameClassType(evaluator, concreteVarType, concreteFilterType);
-                            filteredTypes.push(intersection !== null && intersection !== void 0 ? intersection : varType);
-                            // Don't attempt to narrow in the negative direction.
-                            isClassRelationshipIndeterminate = true;
+                    else if (types_1.ClassType.isSameGenericClass(types_1.ClassType.cloneAsInstance(concreteVarType), types_1.ClassType.cloneAsInstance(concreteFilterType))) {
+                        if (!isTypeIsCheck) {
+                            // Don't attempt to narrow in this case.
+                            if (((_a = concreteVarType.priv) === null || _a === void 0 ? void 0 : _a.literalValue) === undefined &&
+                                ((_b = concreteFilterType.priv) === null || _b === void 0 ? void 0 : _b.literalValue) === undefined) {
+                                const intersection = intersectSameClassType(evaluator, concreteVarType, concreteFilterType);
+                                filteredTypes.push(intersection !== null && intersection !== void 0 ? intersection : varType);
+                                // Don't attempt to narrow in the negative direction.
+                                isClassRelationshipIndeterminate = true;
+                            }
                         }
                     }
                     else if (allowIntersections &&
@@ -1030,19 +1033,22 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
                         if ((0, types_1.isTypeVar)(varType) && !(0, types_1.isParamSpec)(varType) && !types_1.TypeVarType.hasConstraints(varType)) {
                             newClassType = (0, typeUtils_1.addConditionToType)(newClassType, [{ typeVar: varType, constraintIndex: 0 }]);
                         }
-                        let newClassObjType = types_1.ClassType.cloneAsInstance(newClassType);
-                        newClassObjType = (0, typeUtils_1.addConditionToType)(newClassObjType, (_c = concreteVarType.props) === null || _c === void 0 ? void 0 : _c.condition);
-                        // 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 ? newClassObjType : types_1.ClassType.cloneAsInstantiable(newClassObjType));
+                        filteredTypes.push((0, typeUtils_1.addConditionToType)(newClassType, (_c = concreteVarType.props) === null || _c === void 0 ? void 0 : _c.condition));
+                    }
+                }
+                else {
+                    if ((0, types_1.isAnyOrUnknown)(varType)) {
+                        filteredTypes.push((0, typeUtils_1.addConditionToType)(varType, conditions));
+                    }
+                    else if ((0, typeUtils_1.derivesFromAnyOrUnknown)(varType) && !(0, types_1.isTypeSame)(concreteVarType, concreteFilterType)) {
+                        filteredTypes.push((0, typeUtils_1.addConditionToType)(varType, conditions));
                     }
                 }
             }
             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(varType)) {
+                if (types_1.TypeBase.isInstance(varType)) {
                     if ((0, types_1.isTypeVar)(varType) && (0, types_1.isTypeSame)((0, typeUtils_1.convertToInstance)(filterType), varType)) {
                         // If the unexpanded subtype is T, we can definitively filter
                         // in both the positive and negative cases.
@@ -1065,51 +1071,53 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
                         }
                     }
                 }
-                else if (!isInstanceCheck && types_1.TypeBase.isInstantiable(varType)) {
-                    if ((0, types_1.isTypeVar)(varType) && (0, types_1.isTypeSame)(filterType, varType)) {
-                        if (isPositiveTest) {
-                            filteredTypes.push(varType);
-                        }
+            }
+            else if ((0, types_1.isFunction)(filterType)) {
+                // Handle an isinstance check against Callable.
+                let isCallable = false;
+                if ((0, types_1.isClass)(concreteVarType)) {
+                    if (types_1.TypeBase.isInstantiable(varType)) {
+                        isCallable = true;
                     }
                     else {
-                        if (isPositiveTest) {
-                            filteredTypes.push(filterType);
-                        }
-                        else {
-                            filteredTypes.push(varType);
-                            isClassRelationshipIndeterminate = true;
-                        }
+                        isCallable = !!(0, typeUtils_1.lookUpClassMember)(concreteVarType, '__call__', 16 /* MemberAccessFlags.SkipInstanceMembers */);
                     }
                 }
-            }
-            else if ((0, types_1.isFunction)(filterType)) {
-                // Handle an isinstance check against Callable.
-                if (isInstanceCheck) {
-                    let isCallable = false;
-                    if ((0, types_1.isClass)(concreteVarType)) {
-                        if (types_1.TypeBase.isInstantiable(varType)) {
-                            isCallable = true;
-                        }
-                        else {
-                            isCallable = !!(0, typeUtils_1.lookUpClassMember)(concreteVarType, '__call__', 16 /* MemberAccessFlags.SkipInstanceMembers */);
-                        }
+                if (isCallable) {
+                    if (isPositiveTest) {
+                        filteredTypes.push((0, typeUtils_1.convertToInstantiable)(varType));
                     }
-                    if (isCallable) {
-                        if (isPositiveTest) {
-                            filteredTypes.push(varType);
-                        }
-                        else {
-                            foundSuperclass = true;
-                        }
+                    else {
+                        foundSuperclass = true;
                     }
-                    else if (evaluator.assignType(convertVarTypeToFree(concreteVarType), filterType, 
-                    /* diag */ undefined, 
-                    /* constraints */ undefined, 16384 /* AssignTypeFlags.AllowIsinstanceSpecialForms */)) {
-                        if (isPositiveTest) {
-                            filteredTypes.push(filterType);
-                        }
+                }
+                else if (evaluator.assignType(convertVarTypeToFree(concreteVarType), filterType, 
+                /* diag */ undefined, 
+                /* constraints */ undefined, 16384 /* AssignTypeFlags.AllowIsinstanceSpecialForms */)) {
+                    if (isPositiveTest) {
+                        filteredTypes.push((0, typeUtils_1.addConditionToType)(filterType, (_d = concreteVarType.props) === null || _d === void 0 ? void 0 : _d.condition));
                     }
                 }
+                else if (allowIntersections && isPositiveTest) {
+                    // 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 ${concreteVarType.shared.name}>`;
+                    const fileInfo = (0, analyzerNodeInfo_1.getFileInfo)(errorNode);
+                    let newClassType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.fileUri, 0 /* ClassTypeFlags.None */, ParseTreeUtils.getTypeSourceId(errorNode), 
+                    /* declaredMetaclass */ undefined, concreteVarType.shared.effectiveMetaclass, concreteVarType.shared.docString);
+                    newClassType.shared.baseClasses = [concreteVarType];
+                    (0, typeUtils_1.computeMroLinearization)(newClassType);
+                    newClassType = (0, typeUtils_1.addConditionToType)(newClassType, (_e = concreteVarType.props) === null || _e === void 0 ? void 0 : _e.condition);
+                    // Add a __call__ method to the new class.
+                    const callMethod = types_1.FunctionType.createSynthesizedInstance('__call__');
+                    const selfParam = types_1.FunctionParam.create(0 /* ParamCategory.Simple */, types_1.ClassType.cloneAsInstance(newClassType), types_1.FunctionParamFlags.TypeDeclared, 'self');
+                    types_1.FunctionType.addParam(callMethod, selfParam);
+                    types_1.FunctionType.addDefaultParams(callMethod);
+                    callMethod.shared.declaredReturnType = types_1.UnknownType.create();
+                    types_1.ClassType.getSymbolTable(newClassType).set('__call__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, callMethod));
+                    filteredTypes.push(types_1.ClassType.cloneAsInstance(newClassType));
+                }
             }
         }
         // In the negative case, if one or more of the filters
@@ -1119,101 +1127,58 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
         // match, then the original variable type survives the filter.
         if (!isPositiveTest) {
             if (!foundSuperclass || isClassRelationshipIndeterminate) {
-                filteredTypes.push(isInstanceCheck ? (0, typeUtils_1.convertToInstantiable)(negativeFallbackType) : negativeFallbackType);
+                filteredTypes.push((0, typeUtils_1.convertToInstantiable)(negativeFallbackType));
             }
         }
-        if (!isInstanceCheck) {
-            // We perform a double conversion from instance to instantiable
-            // here to make sure that the includeSubclasses flag is cleared
-            // if it's a class.
-            return filteredTypes.map((t) => ((0, types_1.isInstantiableClass)(t) ? (0, typeUtils_1.convertToInstantiable)((0, typeUtils_1.convertToInstance)(t)) : t));
-        }
         return filteredTypes.map((t) => (0, typeUtils_1.convertToInstance)(t));
     };
-    // Filters the metaclassType (which is assumed to be a metaclass instance)
-    // by the classTypeList and returns the list of types the varType could be
-    // after applying the filter.
-    const filterMetaclassType = (metaclassType, negativeFallbackType) => {
-        const filteredTypes = [];
-        let foundPositiveMatch = false;
-        let isMatchIndeterminate = false;
-        for (const filterType of filterTypes) {
-            const concreteFilterType = evaluator.makeTopLevelTypeVarsConcrete(filterType);
-            if ((0, types_1.isInstantiableClass)(concreteFilterType)) {
-                const filterMetaclass = concreteFilterType.shared.effectiveMetaclass;
-                if (filterMetaclass && (0, types_1.isInstantiableClass)(filterMetaclass)) {
-                    let isMetaclassOverlap = evaluator.assignType(convertVarTypeToFree(metaclassType), types_1.ClassType.cloneAsInstance(filterMetaclass));
-                    // Handle the special case where the metaclass for the filter is type.
-                    // This will normally be treated as type[Any], which is compatible with
-                    // any metaclass, but we specifically want to treat type as the class
-                    // type[object] in this case.
-                    if (types_1.ClassType.isBuiltIn(filterMetaclass, 'type') && !filterMetaclass.priv.isTypeArgExplicit) {
-                        if (!types_1.ClassType.isBuiltIn(metaclassType, 'type')) {
-                            isMetaclassOverlap = false;
-                        }
-                    }
-                    if (isMetaclassOverlap) {
-                        if (isPositiveTest) {
-                            filteredTypes.push(filterType);
-                            foundPositiveMatch = true;
-                        }
-                        else if (!(0, types_1.isTypeSame)(metaclassType, filterMetaclass) ||
-                            filterMetaclass.priv.includeSubclasses) {
-                            filteredTypes.push(metaclassType);
-                            isMatchIndeterminate = true;
-                        }
-                    }
-                }
-                else {
-                    filteredTypes.push(metaclassType);
-                    isMatchIndeterminate = true;
-                }
-            }
-            else {
-                filteredTypes.push(metaclassType);
-                isMatchIndeterminate = true;
-            }
-        }
-        // In the negative case, if one or more of the filters
-        // always match the type in the positive case, then there's nothing
-        // left after the filter is applied.
-        if (!isPositiveTest) {
-            if (!foundPositiveMatch || isMatchIndeterminate) {
-                filteredTypes.push(negativeFallbackType);
-            }
-        }
-        // We perform a double conversion from instance to instantiable
-        // here to make sure that the includeSubclasses flag is cleared
-        // if it's a class.
-        return filteredTypes.map((t) => ((0, types_1.isInstantiableClass)(t) ? (0, typeUtils_1.convertToInstantiable)((0, typeUtils_1.convertToInstance)(t)) : t));
+    const isFilterTypeCallbackProtocol = (filterType) => {
+        return ((0, types_1.isInstantiableClass)(filterType) &&
+            evaluator.getCallbackProtocolType((0, typeUtils_1.convertToInstance)(filterType)) !== undefined);
     };
     const filterFunctionType = (varType, unexpandedType) => {
         const filteredTypes = [];
         if (isPositiveTest) {
             for (const filterType of filterTypes) {
                 const concreteFilterType = evaluator.makeTopLevelTypeVarsConcrete(filterType);
-                if (evaluator.assignType(convertVarTypeToFree(varType), (0, typeUtils_1.convertToInstance)(concreteFilterType))) {
+                if (!isTypeIsCheck && isFilterTypeCallbackProtocol(concreteFilterType)) {
+                    filteredTypes.push((0, typeUtils_1.convertToInstance)(varType));
+                }
+                else if (evaluator.assignType(convertVarTypeToFree(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);
+                        filteredTypes.push((0, typeUtils_1.convertToInstance)(unexpandedType));
                     }
                     else {
                         filteredTypes.push((0, typeUtils_1.convertToInstance)(filterType));
                     }
                 }
+                else if (evaluator.assignType((0, typeUtils_1.convertToInstance)(convertVarTypeToFree(concreteFilterType)), varType)) {
+                    filteredTypes.push((0, typeUtils_1.convertToInstance)(varType));
+                }
             }
         }
-        else if (!filterTypes.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;
+        else {
+            // If one or more filters does not always filter the type,
+            // we can't eliminate the type in the negative case.
+            if (filterTypes.every((filterType) => {
+                const concreteFilterType = evaluator.makeTopLevelTypeVarsConcrete(filterType);
+                // If the filter type is a callback protocol, the runtime
+                // isinstance check will filter all objects that have a __call__
+                // method regardless of their signature types.
+                if (!isTypeIsCheck && isFilterTypeCallbackProtocol(concreteFilterType)) {
+                    return false;
+                }
+                if ((0, types_1.isFunction)(concreteFilterType) && types_1.FunctionType.isGradualCallableForm(concreteFilterType)) {
+                    return false;
+                }
+                const isSubtype = evaluator.assignType((0, typeUtils_1.convertToInstance)(convertVarTypeToFree(concreteFilterType)), varType);
+                const isSupertype = evaluator.assignType(convertVarTypeToFree(varType), (0, typeUtils_1.convertToInstance)(concreteFilterType));
+                return !isSubtype || isSupertype;
+            })) {
+                filteredTypes.push((0, typeUtils_1.convertToInstance)(varType));
             }
-            return evaluator.assignType(convertVarTypeToFree(varType), (0, typeUtils_1.convertToInstance)(concreteFilterType));
-        })) {
-            filteredTypes.push(unexpandedType);
         }
         return filteredTypes;
     };
@@ -1236,77 +1201,36 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
         // on a constrained TypeVar that they want to filter based on its constrained
         // parts.
         const negativeFallback = (0, typeUtils_1.getTypeCondition)(subtype) ? subtype : unexpandedSubtype;
-        const isSubtypeMetaclass = (0, typeUtils_1.isMetaclassInstance)(subtype);
         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)(filterTypes.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)(filterTypes.map((classType) => (0, typeUtils_1.convertToInstantiable)((0, typeUtils_1.convertToInstance)(classType)))));
-            }
+            anyOrUnknownSubstitutions.push((0, types_1.combineTypes)(filterTypes.map((classType) => (0, typeUtils_1.convertToInstance)(classType))));
             anyOrUnknown.push(subtype);
             return undefined;
         }
-        if (isInstanceCheck) {
-            if ((0, typeUtils_1.isNoneInstance)(subtype)) {
-                return classListContainsNoneType() === isPositiveTest ? subtype : undefined;
-            }
-            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 = filterTypes.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)) {
-                return (0, types_1.combineTypes)(filterClassType(unexpandedSubtype, types_1.ClassType.cloneAsInstantiable(subtype), (0, typeUtils_1.getTypeCondition)(subtype), negativeFallback));
-            }
-            if (((0, types_1.isFunction)(subtype) || (0, types_1.isOverloaded)(subtype)) && isInstanceCheck) {
-                return (0, types_1.combineTypes)(filterFunctionType(subtype, (0, typeUtils_1.convertToInstance)(unexpandedSubtype)));
-            }
-            if ((0, types_1.isInstantiableClass)(subtype) || isSubtypeMetaclass) {
-                // Handle the special case of isinstance(x, metaclass).
-                const includesMetaclassType = filterTypes.some((classType) => (0, typeUtils_1.isInstantiableMetaclass)(classType));
-                const includesObject = filterTypes.some((classType) => (0, types_1.isInstantiableClass)(classType) && types_1.ClassType.isBuiltIn(classType, 'object'));
-                if (isPositiveTest) {
-                    return includesMetaclassType || includesObject ? negativeFallback : undefined;
-                }
-                else {
-                    return includesMetaclassType ? undefined : negativeFallback;
-                }
-            }
+        if ((0, typeUtils_1.isNoneInstance)(subtype)) {
+            return classListContainsNoneType() === isPositiveTest ? subtype : undefined;
         }
-        else {
-            if ((0, typeUtils_1.isNoneTypeClass)(subtype)) {
-                return classListContainsNoneType() === isPositiveTest ? subtype : undefined;
-            }
-            if ((0, types_1.isClass)(subtype)) {
-                if ((0, types_1.isInstantiableClass)(subtype)) {
-                    return (0, types_1.combineTypes)(filterClassType(unexpandedSubtype, subtype, (0, typeUtils_1.getTypeCondition)(subtype), negativeFallback));
-                }
-                else if ((0, typeUtils_1.isMetaclassInstance)(subtype)) {
-                    return (0, types_1.combineTypes)(filterMetaclassType(subtype, negativeFallback));
-                }
-            }
-            if (isSubtypeMetaclass) {
-                const objectType = evaluator.getBuiltInObject(errorNode, 'object');
-                if (objectType && (0, types_1.isClassInstance)(objectType)) {
-                    return (0, types_1.combineTypes)(filterClassType((0, typeUtils_1.convertToInstantiable)(unexpandedSubtype), types_1.ClassType.cloneAsInstantiable(objectType), (0, typeUtils_1.getTypeCondition)(subtype), negativeFallback));
+        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 = filterTypes.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.isClass)(subtype)) {
+            return (0, types_1.combineTypes)(filterClassType(unexpandedSubtype, types_1.ClassType.cloneAsInstantiable(subtype), (0, typeUtils_1.getTypeCondition)(subtype), negativeFallback));
+        }
+        if ((0, types_1.isFunction)(subtype) || (0, types_1.isOverloaded)(subtype)) {
+            return (0, types_1.combineTypes)(filterFunctionType(subtype, unexpandedSubtype));
+        }
         return isPositiveTest ? undefined : negativeFallback;
     });
     // If the result is Any/Unknown and contains no other subtypes and
@@ -1383,6 +1307,12 @@ function narrowTypeForTupleLength(evaluator, referenceType, lengthValue, isPosit
                 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);
@@ -1494,62 +1424,21 @@ function getElementTypeForContainerNarrowing(containerType) {
     return elementType;
 }
 function narrowTypeForContainerElementType(evaluator, referenceType, elementType) {
-    let canNarrow = true;
-    const elementTypeWithoutLiteral = evaluator.stripLiteralValue(elementType);
-    // Look for cases where one or more of the reference subtypes are
-    // supertypes of the element types. For example, if the element type
-    // is "int | str" and the reference type is "float | bytes", we can
-    // narrow the reference type to "float" because it is a supertype of "int".
-    const narrowedSupertypes = evaluator.mapSubtypesExpandTypeVars(referenceType, 
-    /* options */ undefined, (referenceSubtype) => {
-        if ((0, types_1.isAnyOrUnknown)(referenceSubtype)) {
-            canNarrow = false;
-            return referenceSubtype;
-        }
-        // Handle "type" specially.
-        if ((0, types_1.isClassInstance)(referenceSubtype) && types_1.ClassType.isBuiltIn(referenceSubtype, 'type')) {
-            canNarrow = false;
-            return referenceSubtype;
-        }
-        if (evaluator.assignType(elementType, referenceSubtype)) {
-            return referenceSubtype;
-        }
-        if (evaluator.assignType(elementTypeWithoutLiteral, referenceSubtype)) {
-            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;
-    });
-    // Look for cases where one or more of the reference subtypes are
-    // subtypes of the element types. For example, if the element type
-    // is "int | str" and the reference type is "object", we can
-    // narrow the reference type to "int | str" because they are both
-    // subtypes of "object".
-    const narrowedSubtypes = evaluator.mapSubtypesExpandTypeVars(elementType, 
-    /* options */ undefined, (elementSubtype) => {
-        if ((0, types_1.isAnyOrUnknown)(elementSubtype)) {
-            canNarrow = false;
-            return referenceType;
-        }
-        // Handle the special case where the reference type is a dict or Mapping and
-        // the element type is a TypedDict. In this case, we can't say whether there
-        // is a type overlap, so don't apply narrowing.
-        if ((0, types_1.isClassInstance)(referenceType) && types_1.ClassType.isBuiltIn(referenceType, ['dict', 'Mapping'])) {
-            if ((0, types_1.isClassInstance)(elementSubtype) && types_1.ClassType.isTypedDictClass(elementSubtype)) {
-                return elementSubtype;
+    return evaluator.mapSubtypesExpandTypeVars(referenceType, /* options */ undefined, (referenceSubtype) => {
+        return (0, typeUtils_1.mapSubtypes)(elementType, (elementSubtype) => {
+            var _a, _b;
+            if ((0, types_1.isAnyOrUnknown)(referenceSubtype)) {
+                return referenceSubtype;
             }
-        }
-        if (evaluator.assignType(referenceType, elementSubtype)) {
-            return elementSubtype;
-        }
-        return undefined;
+            if (evaluator.assignType(referenceSubtype, elementSubtype)) {
+                return (0, typeUtils_1.stripTypeForm)((0, typeUtils_1.addConditionToType)(elementSubtype, (_a = referenceSubtype.props) === null || _a === void 0 ? void 0 : _a.condition));
+            }
+            if (evaluator.assignType(elementSubtype, referenceSubtype)) {
+                return (0, typeUtils_1.stripTypeForm)((0, typeUtils_1.addConditionToType)(referenceSubtype, (_b = elementSubtype.props) === null || _b === void 0 ? void 0 : _b.condition));
+            }
+            return undefined;
+        });
     });
-    return canNarrow ? (0, types_1.combineTypes)([narrowedSupertypes, narrowedSubtypes]) : referenceType;
 }
 // Attempts to narrow a type based on whether it is a TypedDict with
 // a literal key value.
@@ -1786,8 +1675,7 @@ function narrowTypeForClassComparison(evaluator, referenceType, classType, isPos
                 if (types_1.TypeBase.isInstance(concreteSubtype)) {
                     return types_1.ClassType.isBuiltIn(concreteSubtype, 'object') ? classType : undefined;
                 }
-                const isSuperType = isIsinstanceFilterSuperclass(evaluator, subtype, concreteSubtype, classType, classType, 
-                /* isInstanceCheck */ false);
+                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
@@ -1795,11 +1683,10 @@ function narrowTypeForClassComparison(evaluator, referenceType, classType, isPos
                     if (!concreteSubtype.priv.includeSubclasses) {
                         return types_1.ClassType.isSameGenericClass(concreteSubtype, classType) ? classType : undefined;
                     }
-                    const isSubType = isIsinstanceFilterSubclass(evaluator, concreteSubtype, classType, 
-                    /* isInstanceCheck */ false);
                     if (isSuperType) {
                         return classType;
                     }
+                    const isSubType = types_1.ClassType.isDerivedFrom(classType, concreteSubtype);
                     if (isSubType) {
                         return (0, typeUtils_1.addConditionToType)(classType, (0, typeUtils_1.getTypeCondition)(concreteSubtype));
                     }
@@ -1820,6 +1707,27 @@ function narrowTypeForClassComparison(evaluator, referenceType, classType, isPos
         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;
+}
 // 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.
@@ -1894,86 +1802,4 @@ function enumerateLiteralsForType(evaluator, type) {
     }
     return undefined;
 }
-// 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, /* options */ undefined, (subtype) => {
-        var _a;
-        switch (subtype.category) {
-            case 4 /* TypeCategory.Function */:
-            case 5 /* TypeCategory.Overloaded */: {
-                return isPositiveTest ? subtype : undefined;
-            }
-            case 7 /* TypeCategory.Module */: {
-                return isPositiveTest ? undefined : subtype;
-            }
-            case 6 /* TypeCategory.Class */: {
-                if ((0, typeUtils_1.isNoneInstance)(subtype)) {
-                    return isPositiveTest ? undefined : subtype;
-                }
-                if (types_1.TypeBase.isInstantiable(subtype)) {
-                    return isPositiveTest ? subtype : undefined;
-                }
-                // See if the object is callable.
-                const callMemberType = (0, typeUtils_1.lookUpClassMember)(subtype, '__call__', 16 /* MemberAccessFlags.SkipInstanceMembers */);
-                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.shared.name}>`;
-                        const fileInfo = (0, analyzerNodeInfo_1.getFileInfo)(errorNode);
-                        let newClassType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.fileUri, 0 /* ClassTypeFlags.None */, ParseTreeUtils.getTypeSourceId(errorNode), 
-                        /* declaredMetaclass */ undefined, subtype.shared.effectiveMetaclass, subtype.shared.docString);
-                        newClassType.shared.baseClasses = [types_1.ClassType.cloneAsInstantiable(subtype)];
-                        (0, typeUtils_1.computeMroLinearization)(newClassType);
-                        newClassType = (0, typeUtils_1.addConditionToType)(newClassType, (_a = subtype.props) === null || _a === void 0 ? void 0 : _a.condition);
-                        // Add a __call__ method to the new class.
-                        const callMethod = types_1.FunctionType.createSynthesizedInstance('__call__');
-                        const selfParam = types_1.FunctionParam.create(0 /* ParamCategory.Simple */, types_1.ClassType.cloneAsInstance(newClassType), types_1.FunctionParamFlags.TypeDeclared, 'self');
-                        types_1.FunctionType.addParam(callMethod, selfParam);
-                        types_1.FunctionType.addDefaultParams(callMethod);
-                        callMethod.shared.declaredReturnType = types_1.UnknownType.create();
-                        types_1.ClassType.getSymbolTable(newClassType).set('__call__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.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;
-            }
-        }
-    });
-}
-class Animal {
-}
-exports.Animal = Animal;
-class Dog extends Animal {
-}
-exports.Dog = Dog;
-class Plant {
-}
-exports.Plant = Plant;
-class Tree extends Plant {
-}
-exports.Tree = Tree;
-function func1(val) {
-    if (val instanceof Tree) {
-        console.log(val);
-    }
-    else {
-        console.log(val);
-    }
-}
 //# sourceMappingURL=typeGuards.js.map