@zzzen/pyright-internal 1.2.0-dev.20231029 → 1.2.0-dev.20231112

package/dist/analyzer/typeEvaluatorTypes.d.ts

@@ -12,7 +12,7 @@ import { SymbolWithScope } from './scope';
 import { Symbol } from './symbol';
 import { PrintTypeFlags } from './typePrinter';
 import { AnyType, ClassType, FunctionParameter, FunctionType, OverloadedFunctionType, Type, TypeCondition, TypeVarType, UnknownType } from './types';
-import { AssignTypeFlags, ClassMember, InferenceContext } from './typeUtils';
+import { AssignTypeFlags, ClassMember, InferenceContext, MemberAccessFlags } from './typeUtils';
 import { TypeVarContext } from './typeVarContext';
 export declare const maxSubtypesForInferredType = 64;
 export declare const enum EvaluatorFlags {
@@ -49,7 +49,7 @@ export declare const enum EvaluatorFlags {
 export interface TypeResult<T extends Type = Type> {
     type: T;
     isIncomplete?: boolean | undefined;
-    bindToType?: ClassType | TypeVarType | undefined;
+    bindToSelfType?: ClassType | TypeVarType | undefined;
     unpackedType?: Type | undefined;
     typeList?: TypeResultWithNode[] | undefined;
     inlinedTypeDict?: ClassType;
@@ -187,7 +187,7 @@ export interface ClassMemberLookup {
     symbol: Symbol | undefined;
     type: Type;
     isTypeIncomplete: boolean;
-    isSetTypeError: boolean;
+    isDescriptorError: boolean;
     isClassMember: boolean;
     classType?: ClassType | UnknownType | AnyType;
     isClassVar: boolean;
@@ -211,19 +211,6 @@ export interface ResolveAliasOptions {
     allowExternallyHiddenAccess?: boolean;
     skipFileNeededCheck?: boolean;
 }
-export declare const enum MemberAccessFlags {
-    None = 0,
-    AccessClassMembersOnly = 1,
-    AccessInstanceMembersOnly = 2,
-    SkipBaseClasses = 4,
-    SkipObjectBaseClass = 8,
-    DisallowClassVarWrites = 16,
-    TreatConstructorAsClassMethod = 32,
-    ConsiderMetaclassOnly = 64,
-    SkipAttributeAccessOverride = 128,
-    SkipOriginalClass = 256,
-    SkipTypeBaseClass = 512
-}
 export interface ValidateTypeArgsOptions {
     allowEmptyTuple?: boolean;
     allowVariadicTypeVar?: boolean;
@@ -266,8 +253,8 @@ export interface TypeEvaluator {
     getTypeForDeclaration: (declaration: Declaration) => DeclaredSymbolTypeInfo;
     resolveAliasDeclaration: (declaration: Declaration, resolveLocalNames: boolean, options?: ResolveAliasOptions) => Declaration | undefined;
     resolveAliasDeclarationWithInfo: (declaration: Declaration, resolveLocalNames: boolean, options?: ResolveAliasOptions) => DeclarationUtils.ResolvedAliasInfo | undefined;
-    getTypeOfIterable: (typeResult: TypeResult, isAsync: boolean, errorNode: ExpressionNode | undefined) => TypeResult | undefined;
-    getTypeOfIterator: (typeResult: TypeResult, isAsync: boolean, errorNode: ExpressionNode | undefined) => TypeResult | undefined;
+    getTypeOfIterable: (typeResult: TypeResult, isAsync: boolean, errorNode: ExpressionNode, emitNotIterableError?: boolean) => TypeResult | undefined;
+    getTypeOfIterator: (typeResult: TypeResult, isAsync: boolean, errorNode: ExpressionNode, emitNotIterableError?: boolean) => TypeResult | undefined;
     getGetterTypeFromProperty: (propertyClass: ClassType, inferTypeIfNeeded: boolean) => Type | undefined;
     getTypeOfArgument: (arg: FunctionArgument) => TypeResult;
     markNamesAccessed: (node: ParseNode, names: string[]) => void;
@@ -286,11 +273,10 @@ export interface TypeEvaluator {
     getBestOverloadForArguments: (errorNode: ExpressionNode, typeResult: TypeResult<OverloadedFunctionType>, argList: FunctionArgument[]) => FunctionType | undefined;
     getBuiltInType: (node: ParseNode, name: string) => Type;
     getTypeOfMember: (member: ClassMember) => Type;
-    getTypeOfObjectMember(errorNode: ExpressionNode, objectType: ClassType, memberName: string, usage?: EvaluatorUsage, diag?: DiagnosticAddendum | undefined, memberAccessFlags?: MemberAccessFlags, bindToType?: ClassType | TypeVarType): TypeResult | undefined;
-    getTypeOfClassMemberName: (errorNode: ExpressionNode, classType: ClassType, isAccessedThroughObject: boolean, memberName: string, usage: EvaluatorUsage, diag: DiagnosticAddendum | undefined, flags: MemberAccessFlags, bindToType?: ClassType | TypeVarType) => ClassMemberLookup | undefined;
-    getBoundMethod: (classType: ClassType, memberName: string, recursionCount?: number, treatConstructorAsClassMember?: boolean) => FunctionType | OverloadedFunctionType | undefined;
-    getTypeOfMagicMethodReturn: (objType: Type, args: TypeResult[], magicMethodName: string, errorNode: ExpressionNode, inferenceContext: InferenceContext | undefined) => Type | undefined;
-    bindFunctionToClassOrObject: (baseType: ClassType | undefined, memberType: FunctionType | OverloadedFunctionType, memberClass?: ClassType, treatConstructorAsClassMember?: boolean, firstParamType?: ClassType | TypeVarType, diag?: DiagnosticAddendum, recursionCount?: number) => FunctionType | OverloadedFunctionType | undefined;
+    getTypeOfBoundMember(errorNode: ExpressionNode, objectType: ClassType, memberName: string, usage?: EvaluatorUsage, diag?: DiagnosticAddendum | undefined, flags?: MemberAccessFlags, selfType?: ClassType | TypeVarType): TypeResult | undefined;
+    getBoundMagicMethod: (classType: ClassType, memberName: string, selfType?: ClassType | TypeVarType | undefined, recursionCount?: number) => FunctionType | OverloadedFunctionType | undefined;
+    getTypeOfMagicMethodCall: (objType: Type, methodName: string, argList: TypeResult[], errorNode: ExpressionNode, inferenceContext: InferenceContext | undefined) => Type | undefined;
+    bindFunctionToClassOrObject: (baseType: ClassType | undefined, memberType: FunctionType | OverloadedFunctionType, memberClass?: ClassType, treatConstructorAsClassMember?: boolean, selfType?: ClassType | TypeVarType, diag?: DiagnosticAddendum, recursionCount?: number) => FunctionType | OverloadedFunctionType | undefined;
     getCallSignatureInfo: (node: CallNode, activeIndex: number, activeOrFake: boolean) => CallSignatureInfo | undefined;
     getAbstractMethods: (classType: ClassType) => AbstractMethod[];
     narrowConstrainedTypeVar: (node: ParseNode, typeVar: TypeVarType) => Type | undefined;
@@ -301,9 +287,10 @@ export interface TypeEvaluator {
     assignTypeToExpression: (target: ExpressionNode, type: Type, isTypeIncomplete: boolean, srcExpr: ExpressionNode) => void;
     assignClassToSelf: (destType: ClassType, srcType: ClassType) => boolean;
     getBuiltInObject: (node: ParseNode, name: string, typeArguments?: Type[]) => Type;
-    getTypedDictClassType: () => Type | undefined;
-    getTupleClassType: () => Type | undefined;
-    getObjectType: () => Type | undefined;
+    getTypedDictClassType: () => ClassType | undefined;
+    getTupleClassType: () => ClassType | undefined;
+    getObjectType: () => Type;
+    getNoneType: () => Type;
     getTypingType: (node: ParseNode, symbolName: string) => Type | undefined;
     inferReturnTypeIfNecessary: (type: Type) => void;
     inferTypeParameterVarianceForClass: (type: ClassType) => void;

package/dist/analyzer/typeEvaluatorTypes.js

@@ -8,7 +8,7 @@
  * Abstract interface and other helper types for type evaluator module.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MemberAccessFlags = exports.EvaluatorFlags = exports.maxSubtypesForInferredType = void 0;
+exports.EvaluatorFlags = exports.maxSubtypesForInferredType = void 0;
 // Maximum number of unioned subtypes for an inferred type (e.g.
 // a list) before the type is considered an "Any".
 exports.maxSubtypesForInferredType = 64;
@@ -88,39 +88,4 @@ var EvaluatorFlags;
     // Defaults used for evaluating the LHS of a member access expression.
     EvaluatorFlags[EvaluatorFlags["MemberAccessBaseDefaults"] = 16777218] = "MemberAccessBaseDefaults";
 })(EvaluatorFlags = exports.EvaluatorFlags || (exports.EvaluatorFlags = {}));
-var MemberAccessFlags;
-(function (MemberAccessFlags) {
-    MemberAccessFlags[MemberAccessFlags["None"] = 0] = "None";
-    // By default, member accesses are assumed to access the attributes
-    // of a class instance. By setting this flag, only attributes of
-    // the class are considered.
-    MemberAccessFlags[MemberAccessFlags["AccessClassMembersOnly"] = 1] = "AccessClassMembersOnly";
-    // Consider only instance members, not members that could be
-    // class members.
-    MemberAccessFlags[MemberAccessFlags["AccessInstanceMembersOnly"] = 2] = "AccessInstanceMembersOnly";
-    // By default, members of base classes are also searched.
-    // Set this flag to consider only the specified class' members.
-    MemberAccessFlags[MemberAccessFlags["SkipBaseClasses"] = 4] = "SkipBaseClasses";
-    // Do not include the "object" base class in the search.
-    MemberAccessFlags[MemberAccessFlags["SkipObjectBaseClass"] = 8] = "SkipObjectBaseClass";
-    // Consider writes to symbols flagged as ClassVars as an error.
-    MemberAccessFlags[MemberAccessFlags["DisallowClassVarWrites"] = 16] = "DisallowClassVarWrites";
-    // Normally __new__ is treated as a static method, but when
-    // it is invoked implicitly through a constructor call, it
-    // acts like a class method instead.
-    MemberAccessFlags[MemberAccessFlags["TreatConstructorAsClassMethod"] = 32] = "TreatConstructorAsClassMethod";
-    // By default, class member lookups start with the class itself
-    // and fall back on the metaclass if it's not found. This option
-    // skips the first check.
-    MemberAccessFlags[MemberAccessFlags["ConsiderMetaclassOnly"] = 64] = "ConsiderMetaclassOnly";
-    // If an attribute cannot be found when looking for instance
-    // members, normally an attribute access override method
-    // (__getattr__, etc.) may provide the missing attribute type.
-    // This disables this check.
-    MemberAccessFlags[MemberAccessFlags["SkipAttributeAccessOverride"] = 128] = "SkipAttributeAccessOverride";
-    // Do not include the class itself, only base classes.
-    MemberAccessFlags[MemberAccessFlags["SkipOriginalClass"] = 256] = "SkipOriginalClass";
-    // Do not include the "type" base class in the search.
-    MemberAccessFlags[MemberAccessFlags["SkipTypeBaseClass"] = 512] = "SkipTypeBaseClass";
-})(MemberAccessFlags = exports.MemberAccessFlags || (exports.MemberAccessFlags = {}));
 //# sourceMappingURL=typeEvaluatorTypes.js.map

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,cAsGjB;AAtGD,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,yDAAyD;IACzD,gEAAgE;IAChE,wHAA6C,CAAA;IAE7C,6DAA6D;IAC7D,kFAA4D,CAAA;IAE5D,sEAAsE;IACtE,6EAAmC,CAAA;IAEnC,sEAAsE;IACtE,kGAAoE,CAAA;AACxE,CAAC,EAtGiB,cAAc,GAAd,sBAAc,KAAd,sBAAc,QAsG/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"}
+{"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,cAsGjB;AAtGD,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,yDAAyD;IACzD,gEAAgE;IAChE,wHAA6C,CAAA;IAE7C,6DAA6D;IAC7D,kFAA4D,CAAA;IAE5D,sEAAsE;IACtE,6EAAmC,CAAA;IAEnC,sEAAsE;IACtE,kGAAoE,CAAA;AACxE,CAAC,EAtGiB,cAAc,GAAd,sBAAc,KAAd,sBAAc,QAsG/B"}

package/dist/analyzer/typeGuards.js

@@ -30,6 +30,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.func1 = exports.Tree = exports.Plant = exports.Dog = exports.Animal = exports.enumerateLiteralsForType = exports.narrowTypeForDiscriminatedTupleComparison = exports.narrowTypeForDiscriminatedDictEntryComparison = exports.narrowTypeForContainerElementType = exports.getElementTypeForContainerNarrowing = exports.isIsinstanceFilterSubclass = exports.isIsinstanceFilterSuperclass = exports.getTypeNarrowingCallback = void 0;
+const debug_1 = require("../common/debug");
 const parseNodes_1 = require("../parser/parseNodes");
 const analyzerNodeInfo_1 = require("./analyzerNodeInfo");
 const constraintSolver_1 = require("./constraintSolver");
@@ -719,12 +720,12 @@ function narrowTupleTypeForIsNone(evaluator, type, isPositiveTest, indexValue) {
         }
         const typeOfEntry = evaluator.makeTopLevelTypeVarsConcrete(tupleType.tupleTypeArguments[indexValue].type);
         if (isPositiveTest) {
-            if (!evaluator.assignType(typeOfEntry, types_1.NoneType.createInstance())) {
+            if (!evaluator.assignType(typeOfEntry, evaluator.getNoneType())) {
                 return undefined;
             }
         }
         else {
-            if ((0, types_1.isNoneInstance)(typeOfEntry)) {
+            if ((0, typeUtils_1.isNoneInstance)(typeOfEntry)) {
                 return undefined;
             }
         }
@@ -754,12 +755,15 @@ function narrowTypeForIsNone(evaluator, type, isPositiveTest) {
         if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'object')) {
             resultIncludesNoneSubtype = true;
             return isPositiveTest
-                ? (0, typeUtils_1.addConditionToType)(types_1.NoneType.createInstance(), subtype.condition)
+                ? (0, typeUtils_1.addConditionToType)(evaluator.getNoneType(), subtype.condition)
                 : adjustedSubtype;
         }
         // See if it's a match for None.
-        if ((0, types_1.isNoneInstance)(subtype) === isPositiveTest) {
+        if ((0, typeUtils_1.isNoneInstance)(subtype) === isPositiveTest) {
             resultIncludesNoneSubtype = true;
+            if ((0, types_1.isTypeVar)(adjustedSubtype) && adjustedSubtype.details.isSynthesizedSelf) {
+                return adjustedSubtype;
+            }
             return subtype;
         }
         return undefined;
@@ -769,7 +773,7 @@ function narrowTypeForIsNone(evaluator, type, isPositiveTest) {
     // of the subtypes are None types with conditions, retain those.
     if (isPositiveTest && resultIncludesNoneSubtype) {
         return (0, typeUtils_1.mapSubtypes)(result, (subtype) => {
-            return (0, types_1.isNoneInstance)(subtype) ? subtype : undefined;
+            return (0, typeUtils_1.isNoneInstance)(subtype) ? subtype : undefined;
         });
     }
     return result;
@@ -795,7 +799,7 @@ function narrowTypeForIsEllipsis(evaluator, type, isPositiveTest) {
         // See if it's a match for object.
         if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'object')) {
             return isPositiveTest
-                ? (0, typeUtils_1.addConditionToType)(types_1.NoneType.createInstance(), subtype.condition)
+                ? (0, typeUtils_1.addConditionToType)(evaluator.getNoneType(), subtype.condition)
                 : adjustedSubtype;
         }
         const isEllipsis = (0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'ellipsis');
@@ -820,7 +824,8 @@ function getIsInstanceClassTypes(argType) {
             if ((0, types_1.isInstantiableClass)(subtype) || ((0, types_1.isTypeVar)(subtype) && types_1.TypeBase.isInstantiable(subtype))) {
                 classTypeList.push(subtype);
             }
-            else if ((0, types_1.isNoneTypeClass)(subtype)) {
+            else if ((0, typeUtils_1.isNoneTypeClass)(subtype)) {
+                (0, debug_1.assert)((0, types_1.isInstantiableClass)(subtype));
                 classTypeList.push(subtype);
             }
             else if ((0, types_1.isFunction)(subtype) &&
@@ -1070,7 +1075,7 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
                             isCallable = true;
                         }
                         else {
-                            isCallable = !!(0, typeUtils_1.lookUpClassMember)(concreteVarType, '__call__', 8 /* SkipInstanceVariables */);
+                            isCallable = !!(0, typeUtils_1.lookUpClassMember)(concreteVarType, '__call__', 16 /* SkipInstanceMembers */);
                         }
                     }
                     if (isCallable) {
@@ -1188,7 +1193,7 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
         return filteredTypes;
     };
     const classListContainsNoneType = () => classTypeList.some((t) => {
-        if ((0, types_1.isNoneTypeClass)(t)) {
+        if ((0, typeUtils_1.isNoneTypeClass)(t)) {
             return true;
         }
         return (0, types_1.isInstantiableClass)(t) && types_1.ClassType.isBuiltIn(t, 'NoneType');
@@ -1221,7 +1226,7 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
             return undefined;
         }
         if (isInstanceCheck) {
-            if ((0, types_1.isNoneInstance)(subtype)) {
+            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'))) {
@@ -1255,7 +1260,7 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
             }
         }
         else {
-            if ((0, types_1.isNoneTypeClass)(subtype)) {
+            if ((0, typeUtils_1.isNoneTypeClass)(subtype)) {
                 return classListContainsNoneType() === isPositiveTest ? subtype : undefined;
             }
             if ((0, types_1.isClass)(subtype)) {
@@ -1354,7 +1359,7 @@ function narrowTypeForContainerType(evaluator, referenceType, containerType, isP
     const typesToEliminate = [];
     containerType.tupleTypeArguments.forEach((tupleEntry) => {
         if (!tupleEntry.isUnbounded) {
-            if ((0, types_1.isNoneInstance)(tupleEntry.type)) {
+            if ((0, typeUtils_1.isNoneInstance)(tupleEntry.type)) {
                 typesToEliminate.push(tupleEntry.type);
             }
             else if ((0, types_1.isClassInstance)(tupleEntry.type) && (0, typeUtils_1.isLiteralType)(tupleEntry.type)) {
@@ -1420,7 +1425,8 @@ function narrowTypeForContainerElementType(evaluator, referenceType, elementType
         }
         if (evaluator.assignType(elementTypeWithoutLiteral, concreteReferenceType)) {
             return (0, typeUtils_1.mapSubtypes)(elementType, (elementSubtype) => {
-                if ((0, types_1.isClassInstance)(elementSubtype) && (0, types_1.isSameWithoutLiteralValue)(referenceSubtype, elementSubtype)) {
+                if ((0, types_1.isClassInstance)(elementSubtype) &&
+                    (0, types_1.isSameWithoutLiteralValue)(concreteReferenceType, elementSubtype)) {
                     return elementSubtype;
                 }
                 return undefined;
@@ -1564,14 +1570,11 @@ function narrowTypeForDiscriminatedLiteralFieldComparison(evaluator, referenceTy
             // Handle the case where the field is a property
             // that has a declared literal return type for its getter.
             if ((0, types_1.isClassInstance)(subtype) && (0, types_1.isClassInstance)(memberType) && (0, typeUtils_1.isProperty)(memberType)) {
-                const getterInfo = (0, typeUtils_1.lookUpObjectMember)(memberType, 'fget');
-                if (getterInfo && getterInfo.isTypeDeclared) {
-                    const getterType = evaluator.getTypeOfMember(getterInfo);
-                    if ((0, types_1.isFunction)(getterType) && getterType.details.declaredReturnType) {
-                        const getterReturnType = types_1.FunctionType.getSpecializedReturnType(getterType);
-                        if (getterReturnType) {
-                            memberType = getterReturnType;
-                        }
+                const getterType = memberType.fgetFunction;
+                if (getterType && getterType.details.declaredReturnType) {
+                    const getterReturnType = types_1.FunctionType.getSpecializedReturnType(getterType);
+                    if (getterReturnType) {
+                        memberType = getterReturnType;
                     }
                 }
             }
@@ -1610,13 +1613,13 @@ function narrowTypeForDiscriminatedFieldNoneComparison(evaluator, referenceType,
                     if ((0, typeUtils_1.isProperty)(memberSubtype) || (0, typeUtils_1.isMaybeDescriptorInstance)(memberSubtype)) {
                         canNarrow = false;
                     }
-                    if ((0, types_1.isAnyOrUnknown)(memberSubtype) || (0, types_1.isNoneInstance)(memberSubtype) || (0, types_1.isNever)(memberSubtype)) {
+                    if ((0, types_1.isAnyOrUnknown)(memberSubtype) || (0, typeUtils_1.isNoneInstance)(memberSubtype) || (0, types_1.isNever)(memberSubtype)) {
                         canNarrow = false;
                     }
                 });
             }
             else {
-                canNarrow = (0, types_1.isNoneInstance)(memberType);
+                canNarrow = (0, typeUtils_1.isNoneInstance)(memberType);
             }
             if (canNarrow) {
                 return undefined;
@@ -1654,7 +1657,7 @@ function narrowTypeForTypeIs(evaluator, type, classType, isPositiveTest) {
                 return subtype;
             }
         }
-        else if ((0, types_1.isNoneInstance)(subtype)) {
+        else if ((0, typeUtils_1.isNoneInstance)(subtype)) {
             return isPositiveTest ? undefined : subtype;
         }
         else if ((0, types_1.isAnyOrUnknown)(subtype)) {
@@ -1669,7 +1672,7 @@ function narrowTypeForClassComparison(evaluator, referenceType, classType, isPos
     return (0, typeUtils_1.mapSubtypes)(referenceType, (subtype) => {
         const concreteSubtype = evaluator.makeTopLevelTypeVarsConcrete(subtype);
         if (isPositiveTest) {
-            if ((0, types_1.isNoneInstance)(concreteSubtype)) {
+            if ((0, typeUtils_1.isNoneInstance)(concreteSubtype)) {
                 return undefined;
             }
             if ((0, types_1.isClassInstance)(concreteSubtype) && types_1.TypeBase.isInstance(subtype)) {
@@ -1729,7 +1732,7 @@ function narrowTypeForLiteralComparison(evaluator, referenceType, literalType, i
             }
         }
         else if (isPositiveTest) {
-            if (isIsOperator || (0, types_1.isNoneInstance)(subtype)) {
+            if (isIsOperator || (0, typeUtils_1.isNoneInstance)(subtype)) {
                 return undefined;
             }
         }
@@ -1770,20 +1773,22 @@ exports.enumerateLiteralsForType = enumerateLiteralsForType;
 function narrowTypeForCallable(evaluator, type, isPositiveTest, errorNode, allowIntersections) {
     return evaluator.mapSubtypesExpandTypeVars(type, /* conditionFilter */ undefined, (subtype) => {
         switch (subtype.category) {
-            case 5 /* Function */:
-            case 6 /* OverloadedFunction */: {
+            case 4 /* Function */:
+            case 5 /* OverloadedFunction */: {
                 return isPositiveTest ? subtype : undefined;
             }
-            case 3 /* None */:
-            case 8 /* Module */: {
+            case 7 /* Module */: {
                 return isPositiveTest ? undefined : subtype;
             }
-            case 7 /* Class */: {
+            case 6 /* 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__', 8 /* SkipInstanceVariables */);
+                const callMemberType = (0, typeUtils_1.lookUpClassMember)(subtype, '__call__', 16 /* SkipInstanceMembers */);
                 if (!callMemberType) {
                     if (!isPositiveTest) {
                         return subtype;