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

package/dist/analyzer/typeUtils.d.ts

@@ -10,15 +10,18 @@ export interface ClassMember {
     isTypeDeclared: boolean;
     skippedUndeclaredType: boolean;
 }
-export declare const enum ClassMemberLookupFlags {
+export declare const enum MemberAccessFlags {
     Default = 0,
     SkipOriginalClass = 1,
     SkipBaseClasses = 2,
     SkipObjectBaseClass = 4,
-    SkipInstanceVariables = 8,
-    SkipClassVariables = 16,
-    DeclaredTypesOnly = 32,
-    SkipTypeBaseClass = 64
+    SkipTypeBaseClass = 8,
+    SkipInstanceMembers = 16,
+    SkipClassMembers = 32,
+    DeclaredTypesOnly = 64,
+    DisallowClassVarWrites = 128,
+    TreatConstructorAsClassMethod = 256,
+    SkipAttributeAccessOverride = 512
 }
 export declare const enum ClassIteratorFlags {
     Default = 0,
@@ -70,12 +73,16 @@ export declare class UniqueSignatureTracker {
     addSignature(signature: FunctionType | OverloadedFunctionType, offset: number): void;
 }
 export declare function isOptionalType(type: Type): boolean;
+export declare function isNoneInstance(type: Type): boolean;
+export declare function isNoneTypeClass(type: Type): boolean;
+export declare function removeNoneFromUnion(type: Type): Type;
 export declare function isIncompleteUnknown(type: Type): boolean;
 export declare function isTypeVarSame(type1: TypeVarType, type2: Type): boolean;
 export declare function makeInferenceContext(expectedType: undefined, isTypeIncomplete?: boolean, signatureTracker?: UniqueSignatureTracker): undefined;
 export declare function makeInferenceContext(expectedType: Type, isTypeIncomplete?: boolean, signatureTracker?: UniqueSignatureTracker): InferenceContext;
 export declare function makeInferenceContext(expectedType: Type | undefined, isTypeIncomplete?: boolean, signatureTracker?: UniqueSignatureTracker): InferenceContext | undefined;
 export declare function mapSubtypes(type: Type, callback: (type: Type) => Type | undefined, sortSubtypes?: boolean): Type;
+export declare function mapSignatures(type: FunctionType | OverloadedFunctionType, callback: (type: FunctionType, index: number) => FunctionType | undefined): OverloadedFunctionType | FunctionType | undefined;
 export declare function cleanIncompleteUnknown(type: Type, recursionCount?: number): Type;
 export declare function sortTypes(types: Type[]): Type[];
 export declare function doForEachSubtype(type: Type, callback: (type: Type, index: number, allSubtypes: Type[]) => void, sortSubtypes?: boolean): void;
@@ -125,9 +132,9 @@ export declare function transformExpectedType(expectedType: Type, liveTypeVarSco
 export declare function getProtocolSymbols(classType: ClassType): Map<string, ClassMember>;
 export declare function getProtocolSymbolsRecursive(classType: ClassType, symbolMap: Map<string, ClassMember>, classFlags?: ClassTypeFlags, recursionCount?: number): void;
 export declare function getContainerDepth(type: Type, recursionCount?: number): number;
-export declare function lookUpObjectMember(objectType: ClassType, memberName: string, flags?: ClassMemberLookupFlags, skipMroClass?: ClassType | undefined): ClassMember | undefined;
-export declare function lookUpClassMember(classType: ClassType, memberName: string, flags?: ClassMemberLookupFlags, skipMroClass?: ClassType | undefined): ClassMember | undefined;
-export declare function getClassMemberIterator(classType: ClassType | AnyType | UnknownType, memberName: string, flags?: ClassMemberLookupFlags, skipMroClass?: ClassType | undefined): Generator<ClassMember, undefined, unknown>;
+export declare function lookUpObjectMember(objectType: ClassType, memberName: string, flags?: MemberAccessFlags, skipMroClass?: ClassType | undefined): ClassMember | undefined;
+export declare function lookUpClassMember(classType: ClassType, memberName: string, flags?: MemberAccessFlags, skipMroClass?: ClassType | undefined): ClassMember | undefined;
+export declare function getClassMemberIterator(classType: ClassType | AnyType | UnknownType, memberName: string, flags?: MemberAccessFlags, skipMroClass?: ClassType | undefined): Generator<ClassMember, undefined, unknown>;
 export declare function getClassIterator(classType: Type, flags?: ClassIteratorFlags, skipMroClass?: ClassType): Generator<Type[], undefined, unknown>;
 export declare function getClassFieldsRecursive(classType: ClassType): Map<string, ClassMember>;
 export declare function addTypeVarsToListIfUnique(list1: TypeVarType[], list2: TypeVarType[]): void;
@@ -146,6 +153,8 @@ export declare function getGeneratorYieldType(declaredReturnType: Type, isAsync:
 export declare function isInstantiableMetaclass(type: Type): boolean;
 export declare function isMetaclassInstance(type: Type): boolean;
 export declare function isEffectivelyInstantiable(type: Type): boolean;
+export declare function convertToInstance(type: ClassType, includeSubclasses?: boolean): ClassType;
+export declare function convertToInstance(type: TypeVarType, includeSubclasses?: boolean): TypeVarType;
 export declare function convertToInstance(type: Type, includeSubclasses?: boolean): Type;
 export declare function convertToInstantiable(type: Type, includeSubclasses?: boolean): Type;
 export declare function getMembersForClass(classType: ClassType, symbolTable: SymbolTable, includeInstanceVars: boolean): void;

package/dist/analyzer/typeUtils.js

@@ -8,8 +8,9 @@
  * Functions that operate on Type objects.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.applySourceContextTypeVarsToSignature = exports.applySourceContextTypeVars = exports.applySolvedTypeVars = exports.ensureFunctionSignaturesAreUnique = exports.populateTypeVarContextForSelfType = exports.partiallySpecializeType = exports.isTupleIndexUnambiguous = exports.isUnboundedTupleClass = exports.isTupleClass = exports.isMaybeDescriptorInstance = exports.isDescriptorInstance = exports.isCallableType = exports.isProperty = exports.isEllipsisType = exports.getUnionSubtypeCount = exports.getLiteralTypeClassName = exports.containsLiteralType = exports.isLiteralTypeOrUnion = exports.isLiteralType = exports.getSpecializedTupleType = exports.selfSpecializeClass = exports.getUnknownTypeForParamSpec = exports.getUnknownTypeForTypeVar = exports.specializeWithUnknown = exports.specializeWithDefaultTypeArgs = exports.getTypeVarScopeIds = exports.getTypeVarScopeId = exports.transformPossibleRecursiveTypeAlias = exports.isTypeAliasRecursive = exports.isTypeAliasPlaceholder = exports.getTypeCondition = exports.addConditionToType = exports.getFullNameOfType = exports.derivesFromAnyOrUnknown = exports.isUnionableType = exports.preserveUnknown = exports.areTypesSame = exports.doForEachSignature = exports.doForEachSubtype = exports.sortTypes = exports.cleanIncompleteUnknown = exports.mapSubtypes = exports.makeInferenceContext = exports.isTypeVarSame = exports.isIncompleteUnknown = exports.isOptionalType = exports.UniqueSignatureTracker = exports.AssignTypeFlags = exports.ClassIteratorFlags = exports.ClassMemberLookupFlags = void 0;
-exports.convertParamSpecValueToType = exports.convertTypeToParamSpecValue = exports.getDeclaringModulesForType = exports.computeMroLinearization = exports.isVarianceOfTypeArgumentCompatible = exports.combineVariances = exports.requiresSpecialization = exports.requiresTypeArguments = exports.getGeneratorTypeArgs = exports.removeParamSpecVariadicsFromFunction = exports.removeParamSpecVariadicsFromSignature = exports.specializeTupleClass = exports.combineSameSizedTuples = exports.explodeGenericClass = exports.isPartlyUnknown = exports.containsAnyOrUnknown = exports.containsAnyRecursive = exports.getMembersForModule = exports.getMembersForClass = exports.convertToInstantiable = exports.convertToInstance = exports.isEffectivelyInstantiable = exports.isMetaclassInstance = exports.isInstantiableMetaclass = exports.getGeneratorYieldType = exports.getDeclaredGeneratorReturnType = exports.synthesizeTypeVarForSelfCls = exports.derivesFromClassRecursive = exports.derivesFromStdlibClass = exports.specializeForBaseClass = exports.buildTypeVarContext = exports.buildTypeVarContextFromSpecializedClass = exports.setTypeArgumentsRecursive = exports.specializeClassType = exports.isTypeVarLimitedToCallable = exports.getTypeVarArgumentsRecursive = exports.addTypeVarsToListIfUnique = exports.getClassFieldsRecursive = exports.getClassIterator = exports.getClassMemberIterator = exports.lookUpClassMember = exports.lookUpObjectMember = exports.getContainerDepth = exports.getProtocolSymbolsRecursive = exports.getProtocolSymbols = exports.transformExpectedType = exports.replaceTypeVarsWithAny = exports.validateTypeVarDefault = exports.applyInScopePlaceholders = void 0;
+exports.populateTypeVarContextForSelfType = exports.partiallySpecializeType = exports.isTupleIndexUnambiguous = exports.isUnboundedTupleClass = exports.isTupleClass = exports.isMaybeDescriptorInstance = exports.isDescriptorInstance = exports.isCallableType = exports.isProperty = exports.isEllipsisType = exports.getUnionSubtypeCount = exports.getLiteralTypeClassName = exports.containsLiteralType = exports.isLiteralTypeOrUnion = exports.isLiteralType = exports.getSpecializedTupleType = exports.selfSpecializeClass = exports.getUnknownTypeForParamSpec = exports.getUnknownTypeForTypeVar = exports.specializeWithUnknown = exports.specializeWithDefaultTypeArgs = exports.getTypeVarScopeIds = exports.getTypeVarScopeId = exports.transformPossibleRecursiveTypeAlias = exports.isTypeAliasRecursive = exports.isTypeAliasPlaceholder = exports.getTypeCondition = exports.addConditionToType = exports.getFullNameOfType = exports.derivesFromAnyOrUnknown = exports.isUnionableType = exports.preserveUnknown = exports.areTypesSame = exports.doForEachSignature = exports.doForEachSubtype = exports.sortTypes = exports.cleanIncompleteUnknown = exports.mapSignatures = exports.mapSubtypes = exports.makeInferenceContext = exports.isTypeVarSame = exports.isIncompleteUnknown = exports.removeNoneFromUnion = exports.isNoneTypeClass = exports.isNoneInstance = exports.isOptionalType = exports.UniqueSignatureTracker = exports.AssignTypeFlags = exports.ClassIteratorFlags = exports.MemberAccessFlags = void 0;
+exports.computeMroLinearization = exports.isVarianceOfTypeArgumentCompatible = exports.combineVariances = exports.requiresSpecialization = exports.requiresTypeArguments = exports.getGeneratorTypeArgs = exports.removeParamSpecVariadicsFromFunction = exports.removeParamSpecVariadicsFromSignature = exports.specializeTupleClass = exports.combineSameSizedTuples = exports.explodeGenericClass = exports.isPartlyUnknown = exports.containsAnyOrUnknown = exports.containsAnyRecursive = exports.getMembersForModule = exports.getMembersForClass = exports.convertToInstantiable = exports.convertToInstance = exports.isEffectivelyInstantiable = exports.isMetaclassInstance = exports.isInstantiableMetaclass = exports.getGeneratorYieldType = exports.getDeclaredGeneratorReturnType = exports.synthesizeTypeVarForSelfCls = exports.derivesFromClassRecursive = exports.derivesFromStdlibClass = exports.specializeForBaseClass = exports.buildTypeVarContext = exports.buildTypeVarContextFromSpecializedClass = exports.setTypeArgumentsRecursive = exports.specializeClassType = exports.isTypeVarLimitedToCallable = exports.getTypeVarArgumentsRecursive = exports.addTypeVarsToListIfUnique = exports.getClassFieldsRecursive = exports.getClassIterator = exports.getClassMemberIterator = exports.lookUpClassMember = exports.lookUpObjectMember = exports.getContainerDepth = exports.getProtocolSymbolsRecursive = exports.getProtocolSymbols = exports.transformExpectedType = exports.replaceTypeVarsWithAny = exports.validateTypeVarDefault = exports.applyInScopePlaceholders = exports.applySourceContextTypeVarsToSignature = exports.applySourceContextTypeVars = exports.applySolvedTypeVars = exports.ensureFunctionSignaturesAreUnique = void 0;
+exports.convertParamSpecValueToType = exports.convertTypeToParamSpecValue = exports.getDeclaringModulesForType = void 0;
 const collectionUtils_1 = require("../common/collectionUtils");
 const debug_1 = require("../common/debug");
 const symbol_1 = require("./symbol");
@@ -17,32 +18,43 @@ const symbolUtils_1 = require("./symbolUtils");
 const types_1 = require("./types");
 const typeVarContext_1 = require("./typeVarContext");
 const typeWalker_1 = require("./typeWalker");
-var ClassMemberLookupFlags;
-(function (ClassMemberLookupFlags) {
-    ClassMemberLookupFlags[ClassMemberLookupFlags["Default"] = 0] = "Default";
+var MemberAccessFlags;
+(function (MemberAccessFlags) {
+    MemberAccessFlags[MemberAccessFlags["Default"] = 0] = "Default";
     // By default, the original (derived) class is searched along
     // with its base classes. If this flag is set, the original
     // class is skipped and only the base classes are searched.
-    ClassMemberLookupFlags[ClassMemberLookupFlags["SkipOriginalClass"] = 1] = "SkipOriginalClass";
+    MemberAccessFlags[MemberAccessFlags["SkipOriginalClass"] = 1] = "SkipOriginalClass";
     // By default, base classes are searched as well as the
     // original (derived) class. If this flag is set, no recursion
     // is performed.
-    ClassMemberLookupFlags[ClassMemberLookupFlags["SkipBaseClasses"] = 2] = "SkipBaseClasses";
+    MemberAccessFlags[MemberAccessFlags["SkipBaseClasses"] = 2] = "SkipBaseClasses";
     // Skip the 'object' base class in particular.
-    ClassMemberLookupFlags[ClassMemberLookupFlags["SkipObjectBaseClass"] = 4] = "SkipObjectBaseClass";
+    MemberAccessFlags[MemberAccessFlags["SkipObjectBaseClass"] = 4] = "SkipObjectBaseClass";
+    // Skip the 'type' base class in particular.
+    MemberAccessFlags[MemberAccessFlags["SkipTypeBaseClass"] = 8] = "SkipTypeBaseClass";
     // By default, both class and instance variables are searched.
     // If this flag is set, the instance variables are skipped.
-    ClassMemberLookupFlags[ClassMemberLookupFlags["SkipInstanceVariables"] = 8] = "SkipInstanceVariables";
+    MemberAccessFlags[MemberAccessFlags["SkipInstanceMembers"] = 16] = "SkipInstanceMembers";
     // By default, both class and instance variables are searched.
     // If this flag is set, the class variables are skipped.
-    ClassMemberLookupFlags[ClassMemberLookupFlags["SkipClassVariables"] = 16] = "SkipClassVariables";
+    MemberAccessFlags[MemberAccessFlags["SkipClassMembers"] = 32] = "SkipClassMembers";
     // By default, the first symbol is returned even if it has only
     // an inferred type associated with it. If this flag is set,
     // the search looks only for symbols with declared types.
-    ClassMemberLookupFlags[ClassMemberLookupFlags["DeclaredTypesOnly"] = 32] = "DeclaredTypesOnly";
-    // Skip the 'type' base class in particular.
-    ClassMemberLookupFlags[ClassMemberLookupFlags["SkipTypeBaseClass"] = 64] = "SkipTypeBaseClass";
-})(ClassMemberLookupFlags = exports.ClassMemberLookupFlags || (exports.ClassMemberLookupFlags = {}));
+    MemberAccessFlags[MemberAccessFlags["DeclaredTypesOnly"] = 64] = "DeclaredTypesOnly";
+    // Consider writes to symbols flagged as ClassVars as an error.
+    MemberAccessFlags[MemberAccessFlags["DisallowClassVarWrites"] = 128] = "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"] = 256] = "TreatConstructorAsClassMethod";
+    // 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"] = 512] = "SkipAttributeAccessOverride";
+})(MemberAccessFlags = exports.MemberAccessFlags || (exports.MemberAccessFlags = {}));
 var ClassIteratorFlags;
 (function (ClassIteratorFlags) {
     ClassIteratorFlags[ClassIteratorFlags["Default"] = 0] = "Default";
@@ -156,11 +168,25 @@ class UniqueSignatureTracker {
 exports.UniqueSignatureTracker = UniqueSignatureTracker;
 function isOptionalType(type) {
     if ((0, types_1.isUnion)(type)) {
-        return (0, types_1.findSubtype)(type, (subtype) => (0, types_1.isNoneInstance)(subtype)) !== undefined;
+        return (0, types_1.findSubtype)(type, (subtype) => isNoneInstance(subtype)) !== undefined;
     }
     return false;
 }
 exports.isOptionalType = isOptionalType;
+function isNoneInstance(type) {
+    return (0, types_1.isClassInstance)(type) && types_1.ClassType.isBuiltIn(type, 'NoneType');
+}
+exports.isNoneInstance = isNoneInstance;
+function isNoneTypeClass(type) {
+    return (0, types_1.isInstantiableClass)(type) && types_1.ClassType.isBuiltIn(type, 'NoneType');
+}
+exports.isNoneTypeClass = isNoneTypeClass;
+// If the type is a union, remove an "None" type from the union,
+// returning only the known types.
+function removeNoneFromUnion(type) {
+    return (0, types_1.removeFromUnion)(type, (t) => isNoneInstance(t));
+}
+exports.removeNoneFromUnion = removeNoneFromUnion;
 function isIncompleteUnknown(type) {
     return (0, types_1.isUnknown)(type) && type.isIncomplete;
 }
@@ -226,7 +252,7 @@ function mapSubtypes(type, callback, sortSubtypes = false) {
                 }
                 const newType = (0, types_1.combineTypes)(typesToCombine);
                 // Do our best to retain type aliases.
-                if (newType.category === 9 /* Union */) {
+                if (newType.category === 8 /* Union */) {
                     types_1.UnionType.addTypeAliasSource(newType, type);
                 }
                 return newType;
@@ -241,6 +267,35 @@ function mapSubtypes(type, callback, sortSubtypes = false) {
     return transformedSubtype;
 }
 exports.mapSubtypes = mapSubtypes;
+// Iterates over each signature in a function or overload, allowing the
+// caller to replace one or more signatures with new ones.
+function mapSignatures(type, callback) {
+    if ((0, types_1.isFunction)(type)) {
+        return callback(type, 0);
+    }
+    const newSignatures = [];
+    let changeMade = false;
+    types_1.OverloadedFunctionType.getOverloads(type).forEach((overload, index) => {
+        const newOverload = callback(overload, index);
+        if (newOverload !== overload) {
+            changeMade = true;
+        }
+        if (newOverload) {
+            newSignatures.push(newOverload);
+        }
+    });
+    if (!changeMade) {
+        return type;
+    }
+    if (newSignatures.length === 0) {
+        return undefined;
+    }
+    if (newSignatures.length === 1) {
+        return newSignatures[0];
+    }
+    return types_1.OverloadedFunctionType.create(newSignatures);
+}
+exports.mapSignatures = mapSignatures;
 // The code flow engine uses a special form of the UnknownType (with the
 // isIncomplete flag set) to distinguish between an unknown that was generated
 // in a loop because it was temporarily incomplete versus an unknown that is
@@ -311,12 +366,11 @@ function compareTypes(a, b, recursionCount = 0) {
         case 0 /* Unbound */:
         case 1 /* Unknown */:
         case 2 /* Any */:
-        case 3 /* None */:
-        case 4 /* Never */:
-        case 9 /* Union */: {
+        case 3 /* Never */:
+        case 8 /* Union */: {
             return 0;
         }
-        case 5 /* Function */: {
+        case 4 /* Function */: {
             const bFunc = b;
             const aParamCount = a.details.parameters.length;
             const bParamCount = bFunc.details.parameters.length;
@@ -329,12 +383,12 @@ function compareTypes(a, b, recursionCount = 0) {
                 if (aParam.category !== bParam.category) {
                     return bParam.category - aParam.category;
                 }
-                const typeComparison = compareTypes(aParam.type, bParam.type);
+                const typeComparison = compareTypes(types_1.FunctionType.getEffectiveParameterType(a, i), types_1.FunctionType.getEffectiveParameterType(bFunc, i));
                 if (typeComparison !== 0) {
                     return typeComparison;
                 }
             }
-            const returnTypeComparison = compareTypes((_a = a.details.declaredReturnType) !== null && _a !== void 0 ? _a : types_1.UnknownType.create(), (_b = bFunc.details.declaredReturnType) !== null && _b !== void 0 ? _b : types_1.UnknownType.create());
+            const returnTypeComparison = compareTypes((_a = types_1.FunctionType.getSpecializedReturnType(a)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create(), (_b = types_1.FunctionType.getSpecializedReturnType(bFunc)) !== null && _b !== void 0 ? _b : types_1.UnknownType.create());
             if (returnTypeComparison !== 0) {
                 return returnTypeComparison;
             }
@@ -348,7 +402,7 @@ function compareTypes(a, b, recursionCount = 0) {
             }
             return 0;
         }
-        case 6 /* OverloadedFunction */: {
+        case 5 /* OverloadedFunction */: {
             const bOver = b;
             const aOverloadCount = a.overloads.length;
             const bOverloadCount = bOver.overloads.length;
@@ -363,7 +417,7 @@ function compareTypes(a, b, recursionCount = 0) {
             }
             return 0;
         }
-        case 7 /* Class */: {
+        case 6 /* Class */: {
             const bClass = b;
             // Sort instances before instantiables.
             if ((0, types_1.isClassInstance)(a) && (0, types_1.isInstantiableClass)(bClass)) {
@@ -381,6 +435,13 @@ function compareTypes(a, b, recursionCount = 0) {
             else if (isLiteralType(bClass)) {
                 return 1;
             }
+            // Always sort NoneType at the end.
+            if (types_1.ClassType.isBuiltIn(a, 'NoneType')) {
+                return 1;
+            }
+            else if (types_1.ClassType.isBuiltIn(bClass, 'NoneType')) {
+                return -1;
+            }
             // Sort non-generics before generics.
             if (a.details.typeParameters.length > 0 || isTupleClass(a)) {
                 if (bClass.details.typeParameters.length === 0) {
@@ -417,12 +478,12 @@ function compareTypes(a, b, recursionCount = 0) {
             }
             return 0;
         }
-        case 8 /* Module */: {
+        case 7 /* Module */: {
             const aName = a.moduleName;
             const bName = b.moduleName;
             return aName < bName ? -1 : aName === bName ? 0 : 1;
         }
-        case 10 /* TypeVar */: {
+        case 9 /* TypeVar */: {
             const aName = a.details.name;
             const bName = b.details.name;
             return aName < bName ? -1 : aName === bName ? 0 : 1;
@@ -527,15 +588,13 @@ function getFullNameOfType(type) {
         case 2 /* Any */:
         case 1 /* Unknown */:
             return 'typing.Any';
-        case 3 /* None */:
-            return 'builtins.None';
-        case 7 /* Class */:
+        case 6 /* Class */:
             return type.details.fullName;
-        case 5 /* Function */:
+        case 4 /* Function */:
             return type.details.fullName;
-        case 8 /* Module */:
+        case 7 /* Module */:
             return type.moduleName;
-        case 6 /* OverloadedFunction */:
+        case 5 /* OverloadedFunction */:
             return type.overloads[0].details.fullName;
     }
     return undefined;
@@ -549,18 +608,17 @@ function addConditionToType(type, condition) {
         case 0 /* Unbound */:
         case 1 /* Unknown */:
         case 2 /* Any */:
-        case 4 /* Never */:
-        case 8 /* Module */:
-        case 10 /* TypeVar */:
+        case 3 /* Never */:
+        case 7 /* Module */:
+        case 9 /* TypeVar */:
             return type;
-        case 3 /* None */:
-        case 5 /* Function */:
+        case 4 /* Function */:
             return types_1.TypeBase.cloneForCondition(type, types_1.TypeCondition.combine(type.condition, condition));
-        case 6 /* OverloadedFunction */:
+        case 5 /* OverloadedFunction */:
             return types_1.OverloadedFunctionType.create(type.overloads.map((t) => addConditionToType(t, condition)));
-        case 7 /* Class */:
+        case 6 /* Class */:
             return types_1.TypeBase.cloneForCondition(type, types_1.TypeCondition.combine(type.condition, condition));
-        case 9 /* Union */:
+        case 8 /* Union */:
             return (0, types_1.combineTypes)(type.subtypes.map((t) => addConditionToType(t, condition)));
     }
 }
@@ -570,15 +628,14 @@ function getTypeCondition(type) {
         case 0 /* Unbound */:
         case 1 /* Unknown */:
         case 2 /* Any */:
-        case 4 /* Never */:
-        case 8 /* Module */:
-        case 10 /* TypeVar */:
-        case 6 /* OverloadedFunction */:
-        case 9 /* Union */:
+        case 3 /* Never */:
+        case 7 /* Module */:
+        case 9 /* TypeVar */:
+        case 5 /* OverloadedFunction */:
+        case 8 /* Union */:
             return undefined;
-        case 3 /* None */:
-        case 7 /* Class */:
-        case 5 /* Function */:
+        case 6 /* Class */:
+        case 4 /* Function */:
             return type.condition;
     }
 }
@@ -593,7 +650,7 @@ exports.isTypeAliasPlaceholder = isTypeAliasPlaceholder;
 // within the specified type. It's OK if it's used indirectly as
 // a type argument.
 function isTypeAliasRecursive(typeAliasPlaceholder, type) {
-    if (type.category !== 9 /* Union */) {
+    if (type.category !== 8 /* Union */) {
         if (type === typeAliasPlaceholder) {
             return true;
         }
@@ -830,7 +887,7 @@ function isCallableType(type) {
         if (types_1.TypeBase.isInstantiable(type)) {
             return true;
         }
-        const callMember = lookUpObjectMember(type, '__call__', 8 /* SkipInstanceVariables */);
+        const callMember = lookUpObjectMember(type, '__call__', 16 /* SkipInstanceMembers */);
         return !!callMember;
     }
     if ((0, types_1.isUnion)(type)) {
@@ -898,7 +955,7 @@ exports.isTupleIndexUnambiguous = isTupleIndexUnambiguous;
 function partiallySpecializeType(type, contextClassType, selfClass, typeClassType) {
     // If the context class is not specialized (or doesn't need specialization),
     // then there's no need to do any more work.
-    if (types_1.ClassType.isUnspecialized(contextClassType)) {
+    if (types_1.ClassType.isUnspecialized(contextClassType) && !selfClass) {
         return type;
     }
     // Partially specialize the type using the specialized class type vars.
@@ -922,7 +979,9 @@ function populateTypeVarContextForSelfType(typeVarContext, contextClassType, sel
         }
         return subtype;
     });
-    typeVarContext.setTypeVarType(synthesizedSelfTypeVar, selfInstance, selfWithoutLiteral);
+    if (!(0, types_1.isTypeSame)(synthesizedSelfTypeVar, selfWithoutLiteral)) {
+        typeVarContext.setTypeVarType(synthesizedSelfTypeVar, selfInstance, selfWithoutLiteral);
+    }
 }
 exports.populateTypeVarContextForSelfType = populateTypeVarContextForSelfType;
 // Looks for duplicate function types within the type and ensures that
@@ -1127,7 +1186,7 @@ exports.lookUpClassMember = lookUpClassMember;
 // If skipMroClass is defined, all MRO classes up to and including that class
 // are skipped.
 function* getClassMemberIterator(classType, memberName, flags = 0 /* Default */, skipMroClass) {
-    const declaredTypesOnly = (flags & 32 /* DeclaredTypesOnly */) !== 0;
+    const declaredTypesOnly = (flags & 64 /* DeclaredTypesOnly */) !== 0;
     let skippedUndeclaredType = false;
     if ((0, types_1.isClass)(classType)) {
         let classFlags = 0 /* Default */;
@@ -1142,7 +1201,7 @@ function* getClassMemberIterator(classType, memberName, flags = 0 /* Default */,
         if (flags & 4 /* SkipObjectBaseClass */) {
             classFlags = classFlags | 2 /* SkipObjectBaseClass */;
         }
-        if (flags & 64 /* SkipTypeBaseClass */) {
+        if (flags & 8 /* SkipTypeBaseClass */) {
             classFlags = classFlags | 4 /* SkipTypeBaseClass */;
         }
         const classItr = getClassIterator(classType, classFlags, skipMroClass);
@@ -1169,7 +1228,7 @@ function* getClassMemberIterator(classType, memberName, flags = 0 /* Default */,
             }
             const memberFields = specializedMroClass.details.fields;
             // Look at instance members first if requested.
-            if ((flags & 8 /* SkipInstanceVariables */) === 0) {
+            if ((flags & 16 /* SkipInstanceMembers */) === 0) {
                 const symbol = memberFields.get(memberName);
                 if (symbol && symbol.isInstanceMember()) {
                     const hasDeclaredType = symbol.hasTypedDeclarations();
@@ -1191,7 +1250,7 @@ function* getClassMemberIterator(classType, memberName, flags = 0 /* Default */,
                 }
             }
             // Next look at class members.
-            if ((flags & 16 /* SkipClassVariables */) === 0) {
+            if ((flags & 32 /* SkipClassMembers */) === 0) {
                 const symbol = memberFields.get(memberName);
                 if (symbol && symbol.isClassMember()) {
                     const hasDeclaredType = symbol.hasTypedDeclarations();
@@ -1490,12 +1549,12 @@ function setTypeArgumentsRecursive(destType, srcType, typeVarContext, recursionC
         return;
     }
     switch (destType.category) {
-        case 9 /* Union */:
+        case 8 /* Union */:
             doForEachSubtype(destType, (subtype) => {
                 setTypeArgumentsRecursive(subtype, srcType, typeVarContext, recursionCount);
             });
             break;
-        case 7 /* Class */:
+        case 6 /* Class */:
             if (destType.typeArguments) {
                 destType.typeArguments.forEach((typeArg) => {
                     setTypeArgumentsRecursive(typeArg, srcType, typeVarContext, recursionCount);
@@ -1507,7 +1566,7 @@ function setTypeArgumentsRecursive(destType, srcType, typeVarContext, recursionC
                 });
             }
             break;
-        case 5 /* Function */:
+        case 4 /* Function */:
             if (destType.specializedTypes) {
                 destType.specializedTypes.parameterTypes.forEach((paramType) => {
                     setTypeArgumentsRecursive(paramType, srcType, typeVarContext, recursionCount);
@@ -1531,12 +1590,12 @@ function setTypeArgumentsRecursive(destType, srcType, typeVarContext, recursionC
                 }
             }
             break;
-        case 6 /* OverloadedFunction */:
+        case 5 /* OverloadedFunction */:
             destType.overloads.forEach((subtype) => {
                 setTypeArgumentsRecursive(subtype, srcType, typeVarContext, recursionCount);
             });
             break;
-        case 10 /* TypeVar */:
+        case 9 /* TypeVar */:
             if (!typeVarContext.getPrimarySignature().getTypeVar(destType)) {
                 typeVarContext.setTypeVarType(destType, srcType);
             }
@@ -1729,7 +1788,7 @@ function convertToInstance(type, includeSubclasses = true) {
     }
     let result = mapSubtypes(type, (subtype) => {
         switch (subtype.category) {
-            case 7 /* Class */: {
+            case 6 /* Class */: {
                 // Handle type[x] as a special case.
                 if (types_1.ClassType.isBuiltIn(subtype, 'type')) {
                     if (types_1.TypeBase.isInstance(subtype)) {
@@ -1742,26 +1801,21 @@ function convertToInstance(type, includeSubclasses = true) {
                     }
                     else {
                         if (subtype.typeArguments && subtype.typeArguments.length > 0) {
-                            return convertToInstantiable(subtype.typeArguments[0]);
+                            if (!(0, types_1.isAnyOrUnknown)(subtype.typeArguments[0])) {
+                                return convertToInstantiable(subtype.typeArguments[0]);
+                            }
                         }
                     }
                 }
-                // Handle NoneType as a special case.
-                if (types_1.TypeBase.isInstantiable(subtype) && types_1.ClassType.isBuiltIn(subtype, 'NoneType')) {
-                    return types_1.NoneType.createInstance();
-                }
                 return types_1.ClassType.cloneAsInstance(subtype, includeSubclasses);
             }
-            case 3 /* None */: {
-                return types_1.NoneType.createInstance();
-            }
-            case 5 /* Function */: {
+            case 4 /* Function */: {
                 if (types_1.TypeBase.isInstantiable(subtype)) {
                     return types_1.FunctionType.cloneAsInstance(subtype);
                 }
                 break;
             }
-            case 10 /* TypeVar */: {
+            case 9 /* TypeVar */: {
                 if (types_1.TypeBase.isInstantiable(subtype)) {
                     return types_1.TypeVarType.cloneAsInstance(subtype);
                 }
@@ -1795,16 +1849,13 @@ function convertToInstantiable(type, includeSubclasses = true) {
     }
     let result = mapSubtypes(type, (subtype) => {
         switch (subtype.category) {
-            case 7 /* Class */: {
+            case 6 /* Class */: {
                 return types_1.ClassType.cloneAsInstantiable(subtype, includeSubclasses);
             }
-            case 3 /* None */: {
-                return types_1.NoneType.createType();
-            }
-            case 5 /* Function */: {
+            case 4 /* Function */: {
                 return types_1.FunctionType.cloneAsInstantiable(subtype);
             }
-            case 10 /* TypeVar */: {
+            case 9 /* TypeVar */: {
                 return types_1.TypeVarType.cloneAsInstantiable(subtype);
             }
         }
@@ -2216,7 +2267,7 @@ exports.requiresSpecialization = requiresSpecialization;
 function _requiresSpecialization(type, options, recursionCount = 0) {
     var _a;
     switch (type.category) {
-        case 7 /* Class */: {
+        case 6 /* Class */: {
             if (types_1.ClassType.isPseudoGenericClass(type) && (options === null || options === void 0 ? void 0 : options.ignorePseudoGeneric)) {
                 return false;
             }
@@ -2228,7 +2279,7 @@ function _requiresSpecialization(type, options, recursionCount = 0) {
             }
             return types_1.ClassType.getTypeParameters(type).length > 0;
         }
-        case 5 /* Function */: {
+        case 4 /* Function */: {
             if (type.details.paramSpec) {
                 return true;
             }
@@ -2252,13 +2303,13 @@ function _requiresSpecialization(type, options, recursionCount = 0) {
             }
             return false;
         }
-        case 6 /* OverloadedFunction */: {
+        case 5 /* OverloadedFunction */: {
             return type.overloads.some((overload) => requiresSpecialization(overload, options, recursionCount));
         }
-        case 9 /* Union */: {
+        case 8 /* Union */: {
             return type.subtypes.some((subtype) => requiresSpecialization(subtype, options, recursionCount));
         }
-        case 10 /* TypeVar */: {
+        case 9 /* TypeVar */: {
             // Most TypeVar types need to be specialized.
             if (!type.details.recursiveTypeAliasName) {
                 if (type.details.isSynthesizedSelf && (options === null || options === void 0 ? void 0 : options.ignoreSelf)) {
@@ -2350,9 +2401,9 @@ function computeMroLinearization(classType) {
             // Generic has some special-case logic (see description of __mro_entries__
             // in PEP 560) that we need to account for here.
             if (types_1.ClassType.isBuiltIn(baseClass, 'Generic')) {
-                // If the class is a Protocol, the generic is ignored for the purposes
-                // of computing the MRO.
-                if (types_1.ClassType.isProtocolClass(classType)) {
+                // If the class is a Protocol or TypedDict, the generic is ignored for
+                // the purposes of computing the MRO.
+                if (types_1.ClassType.isProtocolClass(classType) || types_1.ClassType.isTypedDictClass(classType)) {
                     return false;
                 }
                 // If the class contains any specialized generic classes after
@@ -2475,27 +2526,27 @@ function addDeclaringModuleNamesForType(type, moduleList, recursionCount = 0) {
         }
     };
     switch (type.category) {
-        case 7 /* Class */: {
+        case 6 /* Class */: {
             addIfUnique(type.details.moduleName);
             break;
         }
-        case 5 /* Function */: {
+        case 4 /* Function */: {
             addIfUnique(type.details.moduleName);
             break;
         }
-        case 6 /* OverloadedFunction */: {
+        case 5 /* OverloadedFunction */: {
             type.overloads.forEach((overload) => {
                 addDeclaringModuleNamesForType(overload, moduleList, recursionCount);
             });
             break;
         }
-        case 9 /* Union */: {
+        case 8 /* Union */: {
             doForEachSubtype(type, (subtype) => {
                 addDeclaringModuleNamesForType(subtype, moduleList, recursionCount);
             });
             break;
         }
-        case 8 /* Module */: {
+        case 7 /* Module */: {
             addIfUnique(type.moduleName);
             break;
         }
@@ -2583,7 +2634,7 @@ class TypeVarTransformer {
         if ((0, types_1.isAnyOrUnknown)(type)) {
             return type;
         }
-        if ((0, types_1.isNoneInstance)(type)) {
+        if (isNoneInstance(type)) {
             return type;
         }
         if ((0, types_1.isTypeVar)(type)) {
@@ -2963,7 +3014,9 @@ class TypeVarTransformer {
                 return types_1.FunctionType.cloneForSpecialization(functionType, specializedParameters, specializedInferredReturnType);
             }
             // Unpack the tuple and synthesize a new function in the process.
-            const newFunctionType = types_1.FunctionType.createSynthesizedInstance('', functionType.details.flags);
+            const newFunctionType = types_1.TypeBase.isInstantiable(functionType)
+                ? types_1.FunctionType.createInstantiable(functionType.details.flags | 64 /* SynthesizedMethod */)
+                : types_1.FunctionType.createSynthesizedInstance('', functionType.details.flags);
             let insertKeywordOnlySeparator = false;
             let swallowPositionOnlySeparator = false;
             specializedParameters.parameterTypes.forEach((paramType, index) => {
@@ -2972,7 +3025,9 @@ class TypeVarTransformer {
                     // Unpack the tuple into individual parameters.
                     variadicTypesToUnpack.forEach((unpackedType) => {
                         types_1.FunctionType.addParameter(newFunctionType, {
-                            category: unpackedType.isUnbounded ? 1 /* ArgsList */ : 0 /* Simple */,
+                            category: unpackedType.isUnbounded || (0, types_1.isVariadicTypeVar)(unpackedType.type)
+                                ? 1 /* ArgsList */
+                                : 0 /* Simple */,
                             name: `__p${newFunctionType.details.parameters.length}`,
                             isNameSynthesized: true,
                             type: unpackedType.type,