@zzzen/pyright-internal 1.2.0-dev.20231001 → 1.2.0-dev.20231015

package/dist/analyzer/typeEvaluatorTypes.d.ts

@@ -53,7 +53,7 @@ export interface TypeResult<T extends Type = Type> {
     typeList?: TypeResultWithNode[] | undefined;
     inlinedTypeDict?: ClassType;
     typeErrors?: boolean | undefined;
-    classType?: ClassType | UnknownType;
+    classType?: ClassType | UnknownType | AnyType;
     isEmptyTupleShorthand?: boolean | undefined;
     expectedTypeDiagAddendum?: DiagnosticAddendum | undefined;
     isAsymmetricAccessor?: boolean;
@@ -61,10 +61,16 @@ export interface TypeResult<T extends Type = Type> {
     isNotRequired?: boolean;
     isReadOnly?: boolean;
     overloadsUsedForCall?: FunctionType[];
+    memberAccessDeprecationInfo?: MemberAccessDeprecationInfo;
 }
 export interface TypeResultWithNode extends TypeResult {
     node: ParseNode;
 }
+export interface MemberAccessDeprecationInfo {
+    accessType: 'property' | 'descriptor';
+    accessMethod: 'get' | 'set' | 'del';
+    deprecationMessage: string;
+}
 export interface EvaluatorUsage {
     method: 'get' | 'set' | 'del';
     setType?: TypeResult | undefined;
@@ -180,10 +186,12 @@ export interface ClassMemberLookup {
     symbol: Symbol | undefined;
     type: Type;
     isTypeIncomplete: boolean;
+    isSetTypeError: boolean;
     isClassMember: boolean;
-    classType?: ClassType | UnknownType;
+    classType?: ClassType | UnknownType | AnyType;
     isClassVar: boolean;
     isAsymmetricAccessor: boolean;
+    memberAccessDeprecationInfo?: MemberAccessDeprecationInfo;
 }
 export interface PrintTypeOptions {
     expandTypeAlias?: boolean;

package/dist/analyzer/typeEvaluatorTypes.js.map

@@ -1 +1 @@
-{"version":3,"file":"typeEvaluatorTypes.js","sourceRoot":"","sources":["../../../src/analyzer/typeEvaluatorTypes.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;;AA8CH,gEAAgE;AAChE,kDAAkD;AACrC,QAAA,0BAA0B,GAAG,EAAE,CAAC;AAE7C,IAAkB,cAkGjB;AAlGD,WAAkB,cAAc;IAC5B,mDAAQ,CAAA;IAER,uDAAuD;IACvD,mFAA6B,CAAA;IAE7B,0DAA0D;IAC1D,gEAAgE;IAChE,SAAS;IACT,yEAAwB,CAAA;IAExB,yDAAyD;IACzD,uFAA+B,CAAA;IAE/B,kCAAkC;IAClC,iGAAoC,CAAA;IAEpC,0CAA0C;IAC1C,sEAAsB,CAAA;IAEtB,6CAA6C;IAC7C,8EAA0B,CAAA;IAE1B,gDAAgD;IAChD,oFAA6B,CAAA;IAE7B,2DAA2D;IAC3D,4BAA4B;IAC5B,+FAAkC,CAAA;IAElC,gEAAgE;IAChE,6DAA6D;IAC7D,qBAAqB;IACrB,2FAAgC,CAAA;IAEhC,qEAAqE;IACrE,qFAA6B,CAAA;IAE7B,2DAA2D;IAC3D,gDAAgD;IAChD,wFAA+B,CAAA;IAE/B,8DAA8D;IAC9D,0BAA0B;IAC1B,oGAAqC,CAAA;IAErC,oEAAoE;IACpE,0BAA0B;IAC1B,oGAAqC,CAAA;IAErC,yDAAyD;IACzD,2DAA2D;IAC3D,mCAAmC;IACnC,gHAA2C,CAAA;IAE3C,yDAAyD;IACzD,6DAA6D;IAC7D,uDAAuD;IACvD,iHAA2C,CAAA;IAE3C,mDAAmD;IACnD,2FAAgC,CAAA;IAEhC,6CAA6C;IAC7C,gFAA0B,CAAA;IAE1B,mEAAmE;IACnE,wFAA8B,CAAA;IAE9B,iEAAiE;IACjE,iCAAiC;IACjC,4FAAgC,CAAA;IAEhC,wDAAwD;IACxD,2EAAuB,CAAA;IAEvB,uDAAuD;IACvD,iHAA0C,CAAA;IAE1C,6DAA6D;IAC7D,2DAA2D;IAC3D,oDAAoD;IACpD,6GAAwC,CAAA;IAExC,yCAAyC;IACzC,6FAAgC,CAAA;IAEhC,yDAAyD;IACzD,gGAAiC,CAAA;IAEjC,6DAA6D;IAC7D,kFAA4D,CAAA;IAE5D,sEAAsE;IACtE,6EAAmC,CAAA;IAEnC,sEAAsE;IACtE,kGAAoE,CAAA;AACxE,CAAC,EAlGiB,cAAc,GAAd,sBAAc,KAAd,sBAAc,QAkG/B;AA0PD,IAAkB,iBA2CjB;AA3CD,WAAkB,iBAAiB;IAC/B,yDAAQ,CAAA;IAER,mEAAmE;IACnE,gEAAgE;IAChE,4BAA4B;IAC5B,6FAA+B,CAAA;IAE/B,4DAA4D;IAC5D,iBAAiB;IACjB,mGAAkC,CAAA;IAElC,yDAAyD;IACzD,+DAA+D;IAC/D,+EAAwB,CAAA;IAExB,wDAAwD;IACxD,uFAA4B,CAAA;IAE5B,+DAA+D;IAC/D,8FAA+B,CAAA;IAE/B,2DAA2D;IAC3D,0DAA0D;IAC1D,oCAAoC;IACpC,4GAAsC,CAAA;IAEtC,+DAA+D;IAC/D,gEAAgE;IAChE,yBAAyB;IACzB,4FAA8B,CAAA;IAE9B,4DAA4D;IAC5D,wDAAwD;IACxD,8DAA8D;IAC9D,4BAA4B;IAC5B,yGAAoC,CAAA;IAEpC,sDAAsD;IACtD,qFAA0B,CAAA;IAE1B,sDAAsD;IACtD,qFAA0B,CAAA;AAC9B,CAAC,EA3CiB,iBAAiB,GAAjB,yBAAiB,KAAjB,yBAAiB,QA2ClC"}
+{"version":3,"file":"typeEvaluatorTypes.js","sourceRoot":"","sources":["../../../src/analyzer/typeEvaluatorTypes.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;;AA8CH,gEAAgE;AAChE,kDAAkD;AACrC,QAAA,0BAA0B,GAAG,EAAE,CAAC;AAE7C,IAAkB,cAkGjB;AAlGD,WAAkB,cAAc;IAC5B,mDAAQ,CAAA;IAER,uDAAuD;IACvD,mFAA6B,CAAA;IAE7B,0DAA0D;IAC1D,gEAAgE;IAChE,SAAS;IACT,yEAAwB,CAAA;IAExB,yDAAyD;IACzD,uFAA+B,CAAA;IAE/B,kCAAkC;IAClC,iGAAoC,CAAA;IAEpC,0CAA0C;IAC1C,sEAAsB,CAAA;IAEtB,6CAA6C;IAC7C,8EAA0B,CAAA;IAE1B,gDAAgD;IAChD,oFAA6B,CAAA;IAE7B,2DAA2D;IAC3D,4BAA4B;IAC5B,+FAAkC,CAAA;IAElC,gEAAgE;IAChE,6DAA6D;IAC7D,qBAAqB;IACrB,2FAAgC,CAAA;IAEhC,qEAAqE;IACrE,qFAA6B,CAAA;IAE7B,2DAA2D;IAC3D,gDAAgD;IAChD,wFAA+B,CAAA;IAE/B,8DAA8D;IAC9D,0BAA0B;IAC1B,oGAAqC,CAAA;IAErC,oEAAoE;IACpE,0BAA0B;IAC1B,oGAAqC,CAAA;IAErC,yDAAyD;IACzD,2DAA2D;IAC3D,mCAAmC;IACnC,gHAA2C,CAAA;IAE3C,yDAAyD;IACzD,6DAA6D;IAC7D,uDAAuD;IACvD,iHAA2C,CAAA;IAE3C,mDAAmD;IACnD,2FAAgC,CAAA;IAEhC,6CAA6C;IAC7C,gFAA0B,CAAA;IAE1B,mEAAmE;IACnE,wFAA8B,CAAA;IAE9B,iEAAiE;IACjE,iCAAiC;IACjC,4FAAgC,CAAA;IAEhC,wDAAwD;IACxD,2EAAuB,CAAA;IAEvB,uDAAuD;IACvD,iHAA0C,CAAA;IAE1C,6DAA6D;IAC7D,2DAA2D;IAC3D,oDAAoD;IACpD,6GAAwC,CAAA;IAExC,yCAAyC;IACzC,6FAAgC,CAAA;IAEhC,yDAAyD;IACzD,gGAAiC,CAAA;IAEjC,6DAA6D;IAC7D,kFAA4D,CAAA;IAE5D,sEAAsE;IACtE,6EAAmC,CAAA;IAEnC,sEAAsE;IACtE,kGAAoE,CAAA;AACxE,CAAC,EAlGiB,cAAc,GAAd,sBAAc,KAAd,sBAAc,QAkG/B;AA+QD,IAAkB,iBA2CjB;AA3CD,WAAkB,iBAAiB;IAC/B,yDAAQ,CAAA;IAER,mEAAmE;IACnE,gEAAgE;IAChE,4BAA4B;IAC5B,6FAA+B,CAAA;IAE/B,4DAA4D;IAC5D,iBAAiB;IACjB,mGAAkC,CAAA;IAElC,yDAAyD;IACzD,+DAA+D;IAC/D,+EAAwB,CAAA;IAExB,wDAAwD;IACxD,uFAA4B,CAAA;IAE5B,+DAA+D;IAC/D,8FAA+B,CAAA;IAE/B,2DAA2D;IAC3D,0DAA0D;IAC1D,oCAAoC;IACpC,4GAAsC,CAAA;IAEtC,+DAA+D;IAC/D,gEAAgE;IAChE,yBAAyB;IACzB,4FAA8B,CAAA;IAE9B,4DAA4D;IAC5D,wDAAwD;IACxD,8DAA8D;IAC9D,4BAA4B;IAC5B,yGAAoC,CAAA;IAEpC,sDAAsD;IACtD,qFAA0B,CAAA;IAE1B,sDAAsD;IACtD,qFAA0B,CAAA;AAC9B,CAAC,EA3CiB,iBAAiB,GAAjB,yBAAiB,KAAjB,yBAAiB,QA2ClC"}

package/dist/analyzer/typeGuards.d.ts

@@ -7,7 +7,7 @@ export interface TypeNarrowingResult {
 }
 export declare type TypeNarrowingCallback = (type: Type) => TypeNarrowingResult | undefined;
 export declare function getTypeNarrowingCallback(evaluator: TypeEvaluator, reference: ExpressionNode, testExpression: ExpressionNode, isPositiveTest: boolean, recursionCount?: number): TypeNarrowingCallback | undefined;
-export declare function isIsinstanceFilterSuperclass(evaluator: TypeEvaluator, varType: ClassType, filterType: Type, concreteFilterType: ClassType, isInstanceCheck: boolean): boolean;
+export declare function isIsinstanceFilterSuperclass(evaluator: TypeEvaluator, varType: Type, concreteVarType: ClassType, filterType: Type, concreteFilterType: ClassType, isInstanceCheck: boolean): boolean;
 export declare function isIsinstanceFilterSubclass(evaluator: TypeEvaluator, varType: ClassType, concreteFilterType: ClassType, isInstanceCheck: boolean): boolean;
 export declare function getElementTypeForContainerNarrowing(containerType: Type): Type | undefined;
 export declare function narrowTypeForContainerElementType(evaluator: TypeEvaluator, referenceType: Type, elementType: Type): Type;

package/dist/analyzer/typeGuards.js

@@ -852,28 +852,29 @@ function getIsInstanceClassTypes(argType) {
     });
     return foundNonClassType ? undefined : classTypeList;
 }
-function isIsinstanceFilterSuperclass(evaluator, varType, filterType, concreteFilterType, isInstanceCheck) {
+function isIsinstanceFilterSuperclass(evaluator, varType, concreteVarType, filterType, concreteFilterType, isInstanceCheck) {
+    if ((0, types_1.isTypeVar)(filterType)) {
+        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 varType.
+    // relationship with concreteVarType.
     if (concreteFilterType.includeSubclasses) {
         return false;
     }
-    if ((0, types_1.isTypeVar)(filterType)) {
-        return false;
-    }
-    if (types_1.ClassType.isDerivedFrom(varType, concreteFilterType)) {
+    if (types_1.ClassType.isDerivedFrom(concreteVarType, concreteFilterType)) {
         return true;
     }
     if (isInstanceCheck) {
-        if (types_1.ClassType.isProtocolClass(concreteFilterType) && evaluator.assignType(concreteFilterType, varType)) {
+        if (types_1.ClassType.isProtocolClass(concreteFilterType) &&
+            evaluator.assignType(concreteFilterType, 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(varType)) {
+    if (types_1.ClassType.isBuiltIn(concreteFilterType, 'dict') && types_1.ClassType.isTypedDictClass(concreteVarType)) {
         return true;
     }
     return false;
@@ -904,15 +905,15 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
     // 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 filterClassType = (varType, concreteVarType, conditions, 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)) {
-                const filterIsSuperclass = isIsinstanceFilterSuperclass(evaluator, varType, filterType, concreteFilterType, isInstanceCheck);
-                const filterIsSubclass = isIsinstanceFilterSubclass(evaluator, varType, concreteFilterType, isInstanceCheck);
+                const filterIsSuperclass = isIsinstanceFilterSuperclass(evaluator, varType, concreteVarType, filterType, concreteFilterType, isInstanceCheck);
+                const filterIsSubclass = isIsinstanceFilterSubclass(evaluator, concreteVarType, concreteFilterType, isInstanceCheck);
                 if (filterIsSuperclass) {
                     foundSuperclass = true;
                 }
@@ -923,17 +924,17 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
                 // will generate false positives.
                 if (filterIsSubclass &&
                     filterIsSuperclass &&
-                    !types_1.ClassType.isSameGenericClass(varType, concreteFilterType)) {
+                    !types_1.ClassType.isSameGenericClass(concreteVarType, 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));
+                        filteredTypes.push((0, typeUtils_1.addConditionToType)(concreteVarType, conditions));
                     }
                     else if (filterIsSubclass) {
-                        if (evaluator.assignType(varType, filterType, 
+                        if (evaluator.assignType(concreteVarType, filterType, 
                         /* diag */ undefined, 
                         /* destTypeVarContext */ undefined, 
                         /* srcTypeVarContext */ undefined, 512 /* IgnoreTypeVarScope */ | 4096 /* IgnoreProtocolAssignmentCheck */)) {
@@ -950,27 +951,27 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
                                     const unspecializedFilterType = types_1.ClassType.cloneForSpecialization(filterType, 
                                     /* typeArguments */ undefined, 
                                     /* isTypeArgumentExplicit */ false);
-                                    if ((0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluator, unspecializedFilterType, varType, typeVarContext, 
+                                    if ((0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluator, unspecializedFilterType, concreteVarType, typeVarContext, 
                                     /* liveTypeVarScopes */ undefined, errorNode.start)) {
                                         specializedFilterType = (0, typeUtils_1.applySolvedTypeVars)(unspecializedFilterType, typeVarContext, { unknownIfNotFound: true });
                                     }
                                 }
                             }
-                            filteredTypes.push((0, typeUtils_1.addConditionToType)(specializedFilterType, constraints));
+                            filteredTypes.push((0, typeUtils_1.addConditionToType)(specializedFilterType, conditions));
                         }
                     }
                     else if (allowIntersections &&
-                        !types_1.ClassType.isFinal(varType) &&
+                        !types_1.ClassType.isFinal(concreteVarType) &&
                         !types_1.ClassType.isFinal(concreteFilterType)) {
                         // 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 className = `<subclass of ${concreteVarType.details.name} and ${concreteFilterType.details.name}>`;
                         const fileInfo = (0, analyzerNodeInfo_1.getFileInfo)(errorNode);
                         // The effective metaclass of the intersection is the narrower of the two metaclasses.
-                        let effectiveMetaclass = varType.details.effectiveMetaclass;
+                        let effectiveMetaclass = concreteVarType.details.effectiveMetaclass;
                         if (concreteFilterType.details.effectiveMetaclass) {
                             if (!effectiveMetaclass ||
                                 evaluator.assignType(effectiveMetaclass, concreteFilterType.details.effectiveMetaclass)) {
@@ -978,24 +979,27 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
                             }
                         }
                         let newClassType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.filePath, 0 /* None */, ParseTreeUtils.getTypeSourceId(errorNode), 
-                        /* declaredMetaclass */ undefined, effectiveMetaclass, varType.details.docString);
-                        newClassType.details.baseClasses = [types_1.ClassType.cloneAsInstantiable(varType), concreteFilterType];
+                        /* declaredMetaclass */ undefined, effectiveMetaclass, concreteVarType.details.docString);
+                        newClassType.details.baseClasses = [
+                            types_1.ClassType.cloneAsInstantiable(concreteVarType),
+                            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) {
+                        if ((0, types_1.isTypeVar)(varType) &&
+                            !varType.details.isParamSpec &&
+                            varType.details.constraints.length === 0) {
                             newClassType = (0, typeUtils_1.addConditionToType)(newClassType, [
                                 {
-                                    typeVarName: types_1.TypeVarType.getNameWithScope(unexpandedType),
+                                    typeVarName: types_1.TypeVarType.getNameWithScope(varType),
                                     constraintIndex: 0,
                                     isConstrainedTypeVar: false,
                                 },
                             ]);
                         }
                         let newClassInstanceType = types_1.ClassType.cloneAsInstance(newClassType);
-                        if (varType.condition) {
-                            newClassInstanceType = (0, typeUtils_1.addConditionToType)(newClassInstanceType, varType.condition);
+                        if (concreteVarType.condition) {
+                            newClassInstanceType = (0, typeUtils_1.addConditionToType)(newClassInstanceType, concreteVarType.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
@@ -1007,12 +1011,15 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
             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 (isInstanceCheck && 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.
                         if (isPositiveTest) {
-                            filteredTypes.push(unexpandedType);
+                            filteredTypes.push(varType);
+                        }
+                        else {
+                            foundSuperclass = true;
                         }
                     }
                     else {
@@ -1022,15 +1029,15 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
                         else {
                             // If the unexpanded subtype is some other instance, we can't
                             // filter anything because it might be an instance.
-                            filteredTypes.push(unexpandedType);
+                            filteredTypes.push(varType);
                             isClassRelationshipIndeterminate = true;
                         }
                     }
                 }
-                else if (!isInstanceCheck && types_1.TypeBase.isInstantiable(unexpandedType)) {
-                    if ((0, types_1.isTypeVar)(unexpandedType) && (0, types_1.isTypeSame)(filterType, unexpandedType)) {
+                else if (!isInstanceCheck && types_1.TypeBase.isInstantiable(varType)) {
+                    if ((0, types_1.isTypeVar)(varType) && (0, types_1.isTypeSame)(filterType, varType)) {
                         if (isPositiveTest) {
-                            filteredTypes.push(unexpandedType);
+                            filteredTypes.push(varType);
                         }
                     }
                     else {
@@ -1038,7 +1045,7 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
                             filteredTypes.push(filterType);
                         }
                         else {
-                            filteredTypes.push(unexpandedType);
+                            filteredTypes.push(varType);
                             isClassRelationshipIndeterminate = true;
                         }
                     }
@@ -1048,22 +1055,27 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
                 // Handle an isinstance check against Callable.
                 if (isInstanceCheck) {
                     let isCallable = false;
-                    if ((0, types_1.isClass)(varType)) {
-                        if (types_1.TypeBase.isInstantiable(unexpandedType)) {
+                    if ((0, types_1.isClass)(concreteVarType)) {
+                        if (types_1.TypeBase.isInstantiable(varType)) {
                             isCallable = true;
                         }
                         else {
-                            isCallable = !!(0, typeUtils_1.lookUpClassMember)(varType, '__call__', 8 /* SkipInstanceVariables */);
+                            isCallable = !!(0, typeUtils_1.lookUpClassMember)(concreteVarType, '__call__', 8 /* SkipInstanceVariables */);
                         }
                     }
                     if (isCallable) {
                         if (isPositiveTest) {
-                            filteredTypes.push(unexpandedType);
+                            filteredTypes.push(varType);
                         }
                         else {
                             foundSuperclass = true;
                         }
                     }
+                    else if (evaluator.assignType(concreteVarType, filterType)) {
+                        if (isPositiveTest) {
+                            filteredTypes.push(filterType);
+                        }
+                    }
                 }
             }
         }
@@ -1085,6 +1097,53 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
         }
         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 classTypeList) {
+            const concreteFilterType = evaluator.makeTopLevelTypeVarsConcrete(filterType);
+            if ((0, types_1.isInstantiableClass)(concreteFilterType)) {
+                const filterMetaclass = concreteFilterType.details.effectiveMetaclass;
+                if (filterMetaclass && (0, types_1.isInstantiableClass)(filterMetaclass)) {
+                    const isMetaclassOverlap = evaluator.assignType(metaclassType, types_1.ClassType.cloneAsInstance(filterMetaclass));
+                    if (isMetaclassOverlap) {
+                        if (isPositiveTest) {
+                            filteredTypes.push(filterType);
+                            foundPositiveMatch = true;
+                        }
+                        else if (!(0, types_1.isTypeSame)(metaclassType, filterMetaclass) || filterMetaclass.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 filterFunctionType = (varType, unexpandedType) => {
         const filteredTypes = [];
         if (isPositiveTest) {
@@ -1128,7 +1187,7 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
         // 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');
+        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
@@ -1173,31 +1232,36 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
                     }
                 }
             }
-            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.isClassInstance)(subtype) && !isSubtypeMetaclass) {
+                return (0, types_1.combineTypes)(filterClassType((0, typeUtils_1.convertToInstance)(unexpandedSubtype), types_1.ClassType.cloneAsInstantiable(subtype), (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 ((0, types_1.isInstantiableClass)(subtype) || isSubtypeMetaclass) {
+                // Handle the special case of isinstance(x, metaclass).
+                const includesMetaclassType = classTypeList.some((classType) => (0, typeUtils_1.isInstantiableMetaclass)(classType));
                 if (isPositiveTest) {
-                    return includesTypeType ? negativeFallback : undefined;
+                    return includesMetaclassType ? negativeFallback : undefined;
                 }
                 else {
-                    return includesTypeType ? undefined : negativeFallback;
+                    return includesMetaclassType ? undefined : negativeFallback;
                 }
             }
         }
         else {
-            if ((0, types_1.isInstantiableClass)(subtype)) {
-                return (0, types_1.combineTypes)(filterClassType(subtype, unexpandedSubtype, (0, typeUtils_1.getTypeCondition)(subtype), negativeFallback));
+            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 (isSubtypeTypeObject) {
+            if (isSubtypeMetaclass) {
                 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 (0, types_1.combineTypes)(filterClassType((0, typeUtils_1.convertToInstantiable)(unexpandedSubtype), types_1.ClassType.cloneAsInstantiable(objectType), (0, typeUtils_1.getTypeCondition)(subtype), negativeFallback));
                 }
             }
         }
@@ -1566,9 +1630,11 @@ function narrowTypeForTypeIs(evaluator, type, classType, isPositiveTest) {
                     }
                     return (0, typeUtils_1.addConditionToType)(types_1.ClassType.cloneAsInstance(classType), subtype.condition);
                 }
-                return undefined;
+                if (!classType.includeSubclasses) {
+                    return undefined;
+                }
             }
-            else {
+            else if (!classType.includeSubclasses) {
                 // 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)) {
@@ -1606,7 +1672,7 @@ function narrowTypeForClassComparison(evaluator, referenceType, classType, isPos
             }
             if ((0, types_1.isInstantiableClass)(concreteSubtype) && types_1.ClassType.isFinal(concreteSubtype)) {
                 if (!types_1.ClassType.isSameGenericClass(concreteSubtype, classType) &&
-                    !isIsinstanceFilterSuperclass(evaluator, concreteSubtype, classType, classType, 
+                    !isIsinstanceFilterSuperclass(evaluator, subtype, concreteSubtype, classType, classType, 
                     /* isInstanceCheck */ false)) {
                     return undefined;
                 }
@@ -1628,7 +1694,13 @@ function narrowTypeForClassComparison(evaluator, referenceType, classType, isPos
 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 ((0, types_1.isAnyOrUnknown)(subtype)) {
+            if (isPositiveTest) {
+                return literalType;
+            }
+            return subtype;
+        }
+        else 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)) {