@zzzen/pyright-internal 1.2.0-dev.20241103 → 1.2.0-dev.20241117

package/dist/analyzer/typeEvaluator.js

@@ -191,25 +191,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     let incompleteGenerationCount = 0;
     const returnTypeInferenceContextStack = [];
     let returnTypeInferenceTypeCache;
-    let isPrefetchedTypesInitialized = false;
     const signatureTrackerStack = [];
-    // Various types prefetched from stdlib stubs
-    let noneTypeClass;
-    let objectClass;
-    let typeClass;
-    let unionTypeClass;
-    let awaitableClass;
-    let functionClass;
-    let tupleClass;
-    let boolClass;
-    let intClass;
-    let strClass;
-    let dictClass;
-    let moduleTypeClass;
-    let typedDictClass;
-    let typedDictPrivateClass;
-    let supportsKeysAndGetItemClass;
-    let mappingClass;
+    let prefetched;
     function runWithCancellationToken(token, callback) {
         try {
             cancellationToken = token;
@@ -480,43 +463,46 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     function initializePrefetchedTypes(node) {
         var _a;
-        if (!isPrefetchedTypesInitialized) {
+        if (!prefetched) {
             // Some of these types have cyclical dependencies on each other,
             // so don't re-enter this block once we start executing it.
-            isPrefetchedTypesInitialized = true;
-            objectClass = getBuiltInType(node, 'object');
-            typeClass = getBuiltInType(node, 'type');
-            functionClass = getBuiltInType(node, 'function');
-            unionTypeClass = getTypesType(node, 'UnionType');
-            if (unionTypeClass && (0, types_1.isClass)(unionTypeClass)) {
-                unionTypeClass.shared.flags |= 8388608 /* ClassTypeFlags.SpecialFormClass */;
+            prefetched = {};
+            prefetched.objectClass = getBuiltInType(node, 'object');
+            prefetched.typeClass = getBuiltInType(node, 'type');
+            prefetched.functionClass = getBuiltInType(node, 'function');
+            prefetched.unionTypeClass = getTypesType(node, 'UnionType');
+            if (prefetched.unionTypeClass && (0, types_1.isClass)(prefetched.unionTypeClass)) {
+                prefetched.unionTypeClass.shared.flags |= 8388608 /* ClassTypeFlags.SpecialFormClass */;
             }
             // Initialize and cache "Collection" to break a cyclical dependency
             // that occurs when resolving tuple below.
             getTypingType(node, 'Collection');
-            noneTypeClass = (_a = getTypeshedType(node, 'NoneType')) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
-            tupleClass = getBuiltInType(node, 'tuple');
-            boolClass = getBuiltInType(node, 'bool');
-            intClass = getBuiltInType(node, 'int');
-            strClass = getBuiltInType(node, 'str');
-            dictClass = getBuiltInType(node, 'dict');
-            moduleTypeClass = getTypingType(node, 'ModuleType');
-            typedDictClass = getTypingType(node, 'TypedDict');
-            typedDictPrivateClass = getTypingType(node, '_TypedDict');
-            awaitableClass = getTypingType(node, 'Awaitable');
-            mappingClass = getTypingType(node, 'Mapping');
-            supportsKeysAndGetItemClass = getTypeshedType(node, 'SupportsKeysAndGetItem');
-            if (!supportsKeysAndGetItemClass) {
+            prefetched.noneTypeClass = (_a = getTypeshedType(node, 'NoneType')) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
+            prefetched.tupleClass = getBuiltInType(node, 'tuple');
+            prefetched.boolClass = getBuiltInType(node, 'bool');
+            prefetched.intClass = getBuiltInType(node, 'int');
+            prefetched.strClass = getBuiltInType(node, 'str');
+            prefetched.dictClass = getBuiltInType(node, 'dict');
+            prefetched.moduleTypeClass = getTypingType(node, 'ModuleType');
+            prefetched.typedDictClass = getTypingType(node, 'TypedDict');
+            prefetched.typedDictPrivateClass = getTypingType(node, '_TypedDict');
+            prefetched.awaitableClass = getTypingType(node, 'Awaitable');
+            prefetched.mappingClass = getTypingType(node, 'Mapping');
+            prefetched.supportsKeysAndGetItemClass = getTypeshedType(node, 'SupportsKeysAndGetItem');
+            if (!prefetched.supportsKeysAndGetItemClass) {
                 // Fall back on 'Mapping' if 'SupportsKeysAndGetItem' is not available.
-                supportsKeysAndGetItemClass = mappingClass;
+                prefetched.supportsKeysAndGetItemClass = prefetched.mappingClass;
             }
             // Wire up the `Any` class to the special-form version of our internal AnyType.
-            if (objectClass && (0, types_1.isInstantiableClass)(objectClass) && typeClass && (0, types_1.isInstantiableClass)(typeClass)) {
+            if (prefetched.objectClass &&
+                (0, types_1.isInstantiableClass)(prefetched.objectClass) &&
+                prefetched.typeClass &&
+                (0, types_1.isInstantiableClass)(prefetched.typeClass)) {
                 const anyClass = types_1.ClassType.createInstantiable('Any', 'typing.Any', 'typing', uri_1.Uri.empty(), 1 /* ClassTypeFlags.BuiltIn */ | 8388608 /* ClassTypeFlags.SpecialFormClass */ | 16777216 /* ClassTypeFlags.IllegalIsinstanceClass */, 
                 /* typeSourceId */ -1, 
                 /* declaredMetaclass */ undefined, 
-                /* effectiveMetaclass */ typeClass);
-                anyClass.shared.baseClasses.push(objectClass);
+                /* effectiveMetaclass */ prefetched.typeClass);
+                anyClass.shared.baseClasses.push(prefetched.objectClass);
                 (0, typeUtils_1.computeMroLinearization)(anyClass);
                 const anySpecialForm = types_1.AnyType.createSpecialForm();
                 if ((0, types_1.isAny)(anySpecialForm)) {
@@ -1122,8 +1108,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 if (types_1.ClassType.isBuiltIn(subtype, 'LiteralString')) {
                     // Handle "LiteralString" specially.
-                    if (strClass && (0, types_1.isInstantiableClass)(strClass)) {
-                        let strInstance = types_1.ClassType.cloneAsInstance(strClass);
+                    if ((prefetched === null || prefetched === void 0 ? void 0 : prefetched.strClass) && (0, types_1.isInstantiableClass)(prefetched.strClass)) {
+                        let strInstance = types_1.ClassType.cloneAsInstance(prefetched.strClass);
                         strInstance = types_1.TypeBase.cloneForCondition(strInstance, (0, typeUtils_1.getTypeCondition)(subtype));
                         return strInstance;
                     }
@@ -1212,6 +1198,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (tupleBaseClass && (0, types_1.isClass)(tupleBaseClass) && tupleBaseClass.priv.tupleTypeArgs) {
                     return (0, typeUtils_1.isUnboundedTupleClass)(tupleBaseClass) || tupleBaseClass.priv.tupleTypeArgs.length === 0;
                 }
+                // Handle TypedDicts specially. If one or more entries are required
+                // or known to exist, we can say for sure that the type is not falsy.
+                if (types_1.ClassType.isTypedDictClass(type)) {
+                    const tdEntries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluatorInterface, type, /* allowNarrowed */ true);
+                    if (tdEntries) {
+                        for (const tdEntry of tdEntries.knownItems.values()) {
+                            if (tdEntry.isRequired || tdEntry.isProvided) {
+                                return false;
+                            }
+                        }
+                    }
+                }
                 // Check for bool, int, str and bytes literals that are never falsy.
                 if (type.priv.literalValue !== undefined) {
                     if (types_1.ClassType.isBuiltIn(type, ['bool', 'int', 'str', 'bytes'])) {
@@ -1425,7 +1423,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function stripTypeGuard(type) {
         return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
             if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, ['TypeGuard', 'TypeIs'])) {
-                return boolClass ? (0, typeUtils_1.convertToInstance)(boolClass) : types_1.UnknownType.create();
+                return (prefetched === null || prefetched === void 0 ? void 0 : prefetched.boolClass) ? (0, typeUtils_1.convertToInstance)(prefetched.boolClass) : types_1.UnknownType.create();
             }
             return subtype;
         });
@@ -1854,10 +1852,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // (object that provides an __await__ that returns a generator object).
     // If errorNode is undefined, no errors are reported.
     function getTypeOfAwaitable(type, errorNode) {
-        if (!awaitableClass || !(0, types_1.isInstantiableClass)(awaitableClass) || awaitableClass.shared.typeParams.length !== 1) {
+        if (!(prefetched === null || prefetched === void 0 ? void 0 : prefetched.awaitableClass) ||
+            !(0, types_1.isInstantiableClass)(prefetched.awaitableClass) ||
+            prefetched.awaitableClass.shared.typeParams.length !== 1) {
             return types_1.UnknownType.create();
         }
-        const awaitableProtocolObj = types_1.ClassType.cloneAsInstance(awaitableClass);
+        const awaitableProtocolObj = types_1.ClassType.cloneAsInstance(prefetched.awaitableClass);
         return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
             subtype = makeTopLevelTypeVarsConcrete(subtype);
             if ((0, types_1.isAnyOrUnknown)(subtype)) {
@@ -1919,8 +1919,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (!isAsync && (0, types_1.isClassInstance)(subtype)) {
                         const getItemReturnType = (_b = getTypeOfMagicMethodCall(subtype, '__getitem__', [
                             {
-                                type: intClass && (0, types_1.isInstantiableClass)(intClass)
-                                    ? types_1.ClassType.cloneAsInstance(intClass)
+                                type: (prefetched === null || prefetched === void 0 ? void 0 : prefetched.intClass) && (0, types_1.isInstantiableClass)(prefetched.intClass)
+                                    ? types_1.ClassType.cloneAsInstance(prefetched.intClass)
                                     : types_1.UnknownType.create(),
                             },
                         ], errorNode)) === null || _b === void 0 ? void 0 : _b.type;
@@ -2047,29 +2047,32 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return isTypeHashable;
     }
     function getTypedDictClassType() {
-        return typedDictPrivateClass && (0, types_1.isInstantiableClass)(typedDictPrivateClass) ? typedDictPrivateClass : undefined;
+        return (prefetched === null || prefetched === void 0 ? void 0 : prefetched.typedDictPrivateClass) && (0, types_1.isInstantiableClass)(prefetched.typedDictPrivateClass)
+            ? prefetched.typedDictPrivateClass
+            : undefined;
     }
     function getTupleClassType() {
-        return tupleClass && (0, types_1.isInstantiableClass)(tupleClass) ? tupleClass : undefined;
+        return (prefetched === null || prefetched === void 0 ? void 0 : prefetched.tupleClass) && (0, types_1.isInstantiableClass)(prefetched.tupleClass) ? prefetched.tupleClass : undefined;
     }
     function getDictClassType() {
-        return dictClass && (0, types_1.isInstantiableClass)(dictClass) ? dictClass : undefined;
+        return (prefetched === null || prefetched === void 0 ? void 0 : prefetched.dictClass) && (0, types_1.isInstantiableClass)(prefetched.dictClass) ? prefetched.dictClass : undefined;
     }
     function getStrClassType() {
-        return strClass && (0, types_1.isInstantiableClass)(strClass) ? strClass : undefined;
+        return (prefetched === null || prefetched === void 0 ? void 0 : prefetched.strClass) && (0, types_1.isInstantiableClass)(prefetched.strClass) ? prefetched.strClass : undefined;
     }
     function getObjectType() {
-        return objectClass ? (0, typeUtils_1.convertToInstance)(objectClass) : types_1.UnknownType.create();
+        return (prefetched === null || prefetched === void 0 ? void 0 : prefetched.objectClass) ? (0, typeUtils_1.convertToInstance)(prefetched.objectClass) : types_1.UnknownType.create();
     }
     function getNoneType() {
-        return noneTypeClass ? (0, typeUtils_1.convertToInstance)(noneTypeClass) : types_1.UnknownType.create();
+        return (prefetched === null || prefetched === void 0 ? void 0 : prefetched.noneTypeClass) ? (0, typeUtils_1.convertToInstance)(prefetched.noneTypeClass) : types_1.UnknownType.create();
     }
     function getUnionClassType() {
-        return unionTypeClass !== null && unionTypeClass !== void 0 ? unionTypeClass : types_1.UnknownType.create();
+        var _a;
+        return (_a = prefetched === null || prefetched === void 0 ? void 0 : prefetched.unionTypeClass) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
     }
     function getTypeClassType() {
-        if (typeClass && (0, types_1.isInstantiableClass)(typeClass)) {
-            return typeClass;
+        if ((prefetched === null || prefetched === void 0 ? void 0 : prefetched.typeClass) && (0, types_1.isInstantiableClass)(prefetched.typeClass)) {
+            return prefetched.typeClass;
         }
         return undefined;
     }
@@ -2457,9 +2460,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (isThisClass && isInstanceMember && memberClass) {
                     const inheritedSlotsNames = types_1.ClassType.getInheritedSlotsNames(memberClass);
                     if (inheritedSlotsNames && memberClass.shared.localSlotsNames) {
-                        // Skip this check if the local slots is specified but empty because this pattern
-                        // is used in a legitimate manner for mix-in classes.
-                        if (memberClass.shared.localSlotsNames.length > 0 &&
+                        // Skip this check if the local slots is specified but empty
+                        // and the class isn't final. This pattern is used in a
+                        // legitimate manner for mix-in classes.
+                        if ((memberClass.shared.localSlotsNames.length > 0 || types_1.ClassType.isFinal(memberClass)) &&
                             !inheritedSlotsNames.some((name) => name === memberName)) {
                             // Determine whether the assignment corresponds to a descriptor
                             // that was assigned as a class variable. If so, then slots will not
@@ -2652,8 +2656,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return (0, tuples_1.makeTupleObject)(evaluatorInterface, [{ type: getObjectType(), isUnbounded: true }]);
                 }
                 else if (subtype.priv.paramSpecAccess === 'kwargs') {
-                    if (dictClass && (0, types_1.isInstantiableClass)(dictClass) && strClass && (0, types_1.isInstantiableClass)(strClass)) {
-                        return types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(dictClass, [(0, typeUtils_1.convertToInstance)(strClass), getObjectType()]));
+                    if ((prefetched === null || prefetched === void 0 ? void 0 : prefetched.dictClass) &&
+                        (0, types_1.isInstantiableClass)(prefetched.dictClass) &&
+                        (prefetched === null || prefetched === void 0 ? void 0 : prefetched.strClass) &&
+                        (0, types_1.isInstantiableClass)(prefetched.strClass)) {
+                        return types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(prefetched.dictClass, [
+                            (0, typeUtils_1.convertToInstance)(prefetched.strClass),
+                            getObjectType(),
+                        ]));
                     }
                     return types_1.UnknownType.create();
                 }
@@ -2670,8 +2680,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // If it's in a union, convert to type or object.
                 if (subtype.priv.isInUnion) {
                     if (types_1.TypeBase.isInstantiable(subtype)) {
-                        if (typeClass && (0, types_1.isInstantiableClass)(typeClass)) {
-                            return typeClass;
+                        if ((prefetched === null || prefetched === void 0 ? void 0 : prefetched.typeClass) && (0, types_1.isInstantiableClass)(prefetched.typeClass)) {
+                            return prefetched.typeClass;
                         }
                     }
                     else {
@@ -2953,7 +2963,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
     }
-    function verifyRaiseExceptionType(node) {
+    function verifyRaiseExceptionType(node, allowNone) {
         const baseExceptionType = getBuiltInType(node, 'BaseException');
         const exceptionType = getTypeOfExpression(node).type;
         // Validate that the argument of "raise" is an exception object or class.
@@ -2963,7 +2973,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const diag = new diagnostic_1.DiagnosticAddendum();
             (0, typeUtils_1.doForEachSubtype)(exceptionType, (subtype) => {
                 const concreteSubtype = makeTopLevelTypeVarsConcrete(subtype);
-                if ((0, types_1.isAnyOrUnknown)(concreteSubtype) || (0, types_1.isNever)(concreteSubtype) || (0, typeUtils_1.isNoneInstance)(concreteSubtype)) {
+                if ((0, types_1.isAnyOrUnknown)(concreteSubtype) || (0, types_1.isNever)(concreteSubtype)) {
+                    return;
+                }
+                if (allowNone && (0, typeUtils_1.isNoneInstance)(concreteSubtype)) {
                     return;
                 }
                 if ((0, types_1.isInstantiableClass)(concreteSubtype) && concreteSubtype.priv.literalValue === undefined) {
@@ -3277,8 +3290,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((flags & exemptFlags) !== 0) {
             return type;
         }
-        if (convertModule && (0, types_1.isModule)(type) && moduleTypeClass && (0, types_1.isInstantiableClass)(moduleTypeClass)) {
-            return types_1.ClassType.cloneAsInstance(moduleTypeClass);
+        if (convertModule &&
+            (0, types_1.isModule)(type) &&
+            (prefetched === null || prefetched === void 0 ? void 0 : prefetched.moduleTypeClass) &&
+            (0, types_1.isInstantiableClass)(prefetched.moduleTypeClass)) {
+            return types_1.ClassType.cloneAsInstance(prefetched.moduleTypeClass);
         }
         // Isinstance treats traditional (non-PEP 695) type aliases that are unions
         // as tuples of classes rather than unions.
@@ -3999,7 +4015,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                 }
                 else {
-                    type = getTypeOfMemberAccessWithBaseType(node, { type: functionClass ? (0, typeUtils_1.convertToInstance)(functionClass) : types_1.UnknownType.create() }, usage, flags).type;
+                    type = getTypeOfMemberAccessWithBaseType(node, {
+                        type: (prefetched === null || prefetched === void 0 ? void 0 : prefetched.functionClass)
+                            ? (0, typeUtils_1.convertToInstance)(prefetched.functionClass)
+                            : types_1.UnknownType.create(),
+                    }, usage, flags).type;
                 }
                 break;
             }
@@ -4523,8 +4543,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             isAsymmetric = false;
         }
         else {
-            let getterType = getEffectiveTypeOfSymbol(getterSymbolResult.symbol);
-            const setterType = getEffectiveTypeOfSymbol(setterSymbolResult.symbol);
+            let getterType = getTypeOfMember(getterSymbolResult);
+            const setterType = getTypeOfMember(setterSymbolResult);
             // If this is an overload, find the appropriate overload.
             if ((0, types_1.isOverloaded)(getterType)) {
                 const getOverloads = types_1.OverloadedType.getOverloads(getterType).filter((overload) => {
@@ -4626,8 +4646,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         argList.push({
             argCategory: 0 /* ArgCategory.Simple */,
             typeResult: {
-                type: strClass && (0, types_1.isInstantiableClass)(strClass)
-                    ? types_1.ClassType.cloneWithLiteral(types_1.ClassType.cloneAsInstance(strClass), memberName)
+                type: (prefetched === null || prefetched === void 0 ? void 0 : prefetched.strClass) && (0, types_1.isInstantiableClass)(prefetched.strClass)
+                    ? types_1.ClassType.cloneWithLiteral(types_1.ClassType.cloneAsInstance(prefetched.strClass), memberName)
                     : types_1.AnyType.create(),
             },
         });
@@ -4887,7 +4907,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     },
                 });
             }
-            else if ((0, types_1.isTypeVarTuple)(param) && tupleClass && (0, types_1.isInstantiableClass)(tupleClass)) {
+            else if ((0, types_1.isTypeVarTuple)(param) && (prefetched === null || prefetched === void 0 ? void 0 : prefetched.tupleClass) && (0, types_1.isInstantiableClass)(prefetched.tupleClass)) {
                 defaultType = (0, tuples_1.makeTupleObject)(evaluatorInterface, [{ type: types_1.UnknownType.create(), isUnbounded: true }], 
                 /* isUnpacked */ true);
             }
@@ -5709,10 +5729,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             setTypeResultForNode(node, { type: types_1.UnknownType.create() });
         }
         else if (node.nodeType === 18 /* ParseNodeType.Dictionary */ && supportsDictExpression) {
-            const inlinedTypeDict = typedDictClass && (0, types_1.isInstantiableClass)(typedDictClass)
-                ? (0, typedDicts_1.createTypedDictTypeInlined)(evaluatorInterface, node, typedDictClass)
+            const inlinedTypeDict = (prefetched === null || prefetched === void 0 ? void 0 : prefetched.typedDictClass) && (0, types_1.isInstantiableClass)(prefetched.typedDictClass)
+                ? (0, typedDicts_1.createTypedDictTypeInlined)(evaluatorInterface, node, prefetched.typedDictClass)
                 : undefined;
-            const keyTypeFallback = strClass && (0, types_1.isInstantiableClass)(strClass) ? strClass : types_1.UnknownType.create();
+            const keyTypeFallback = (prefetched === null || prefetched === void 0 ? void 0 : prefetched.strClass) && (0, types_1.isInstantiableClass)(prefetched.strClass)
+                ? prefetched.strClass
+                : types_1.UnknownType.create();
             typeResult = {
                 type: keyTypeFallback,
                 inlinedTypeDict,
@@ -6091,7 +6113,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return getNoneType();
     }
     function getTypeOfSuperCall(node) {
-        var _a, _b;
+        var _a, _b, _c;
         if (node.d.args.length > 2) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.superCallArgCount(), node.d.args[2]);
         }
@@ -6251,7 +6273,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             else if (effectiveTargetClass &&
                 !(0, types_1.isAnyOrUnknown)(effectiveTargetClass) &&
                 !(0, typeUtils_1.derivesFromAnyOrUnknown)(effectiveTargetClass)) {
-                resultType = objectClass !== null && objectClass !== void 0 ? objectClass : types_1.UnknownType.create();
+                resultType = (_b = prefetched === null || prefetched === void 0 ? void 0 : prefetched.objectClass) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
             }
             else {
                 resultType = types_1.UnknownType.create();
@@ -6269,7 +6291,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     // If this is a zero-argument form of super(), synthesize
                     // a Self type to bind to.
                     bindToSelfType = types_1.TypeBase.cloneForCondition(types_1.TypeVarType.cloneAsBound((0, typeUtils_1.synthesizeTypeVarForSelfCls)(types_1.ClassType.cloneIncludeSubclasses(bindToType, /* includeSubclasses */ false), 
-                    /* isClsParam */ false)), (_b = bindToType.props) === null || _b === void 0 ? void 0 : _b.condition);
+                    /* isClsParam */ false)), (_c = bindToType.props) === null || _c === void 0 ? void 0 : _c.condition);
                 }
             }
             const type = resultIsInstance ? (0, typeUtils_1.convertToInstance)(resultType, /* includeSubclasses */ false) : resultType;
@@ -6304,9 +6326,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return { type: resultIsInstance ? (0, typeUtils_1.convertToInstance)(nextBaseClassType) : nextBaseClassType };
                 }
                 // There's not much we can say about the type. Simply return object or type.
-                if (typeClass && (0, types_1.isInstantiableClass)(typeClass)) {
+                if ((prefetched === null || prefetched === void 0 ? void 0 : prefetched.typeClass) && (0, types_1.isInstantiableClass)(prefetched.typeClass)) {
                     return {
-                        type: resultIsInstance ? getObjectType() : (0, typeUtils_1.convertToInstance)(typeClass),
+                        type: resultIsInstance ? getObjectType() : (0, typeUtils_1.convertToInstance)(prefetched.typeClass),
                     };
                 }
             }
@@ -7294,7 +7316,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // If this is a tuple with specified element types, use those
                 // specified types rather than using the more generic iterator
                 // type which will be a union of all element types.
-                const combinedArgType = (0, typeUtils_1.combineSameSizedTuples)(makeTopLevelTypeVarsConcrete(argType), tupleClass);
+                const combinedArgType = (0, typeUtils_1.combineSameSizedTuples)(makeTopLevelTypeVarsConcrete(argType), prefetched === null || prefetched === void 0 ? void 0 : prefetched.tupleClass);
                 if ((0, types_1.isClassInstance)(combinedArgType) && (0, typeUtils_1.isTupleClass)(combinedArgType)) {
                     const tupleTypeArgs = (_a = combinedArgType.priv.tupleTypeArgs) !== null && _a !== void 0 ? _a : [];
                     if (tupleTypeArgs.length !== 1 || !tupleTypeArgs[0].isUnbounded) {
@@ -7847,8 +7869,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                     else {
                         const strObjType = getBuiltInObject(errorNode, 'str');
-                        if (supportsKeysAndGetItemClass &&
-                            (0, types_1.isInstantiableClass)(supportsKeysAndGetItemClass) &&
+                        if ((prefetched === null || prefetched === void 0 ? void 0 : prefetched.supportsKeysAndGetItemClass) &&
+                            (0, types_1.isInstantiableClass)(prefetched.supportsKeysAndGetItemClass) &&
                             strObjType &&
                             (0, types_1.isClassInstance)(strObjType)) {
                             const mappingConstraints = new constraintTracker_1.ConstraintTracker();
@@ -7858,9 +7880,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             if ((0, types_1.isTypeVar)(argType)) {
                                 isValidMappingType = true;
                             }
-                            else if (assignType(types_1.ClassType.cloneAsInstance(supportsKeysAndGetItemClass), argType, 
+                            else if (assignType(types_1.ClassType.cloneAsInstance(prefetched.supportsKeysAndGetItemClass), argType, 
                             /* diag */ undefined, mappingConstraints)) {
-                                const specializedMapping = solveAndApplyConstraints(supportsKeysAndGetItemClass, mappingConstraints);
+                                const specializedMapping = solveAndApplyConstraints(prefetched.supportsKeysAndGetItemClass, mappingConstraints);
                                 const typeArgs = specializedMapping.priv.typeArgs;
                                 if (typeArgs && typeArgs.length >= 2) {
                                     if (assignType(strObjType, typeArgs[0])) {
@@ -8848,7 +8870,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return { isCompatible: false, argType, isTypeIncomplete, skippedBareTypeVarExpectedType, condition };
         }
         if (!options.skipUnknownArgCheck) {
-            const simplifiedType = (0, types_1.removeUnbound)(argType);
+            const simplifiedType = makeTopLevelTypeVarsConcrete((0, types_1.removeUnbound)(argType));
             const fileInfo = AnalyzerNodeInfo.getFileInfo(argParam.errorNode);
             function getDiagAddendum() {
                 const diagAddendum = new diagnostic_1.DiagnosticAddendum();
@@ -9318,7 +9340,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // in the Python specification: The static type checker will treat
     // the new type as if it were a subclass of the original type.
     function createNewType(errorNode, argList) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
         let className = '';
         if (argList.length !== 2) {
@@ -9344,12 +9366,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let baseClass = getTypeOfArgExpectingType(argList[1]).type;
         let isBaseClassAny = false;
         if ((0, types_1.isAnyOrUnknown)(baseClass)) {
-            baseClass = objectClass !== null && objectClass !== void 0 ? objectClass : types_1.UnknownType.create();
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.newTypeAnyOrUnknown(), (_c = argList[1].node) !== null && _c !== void 0 ? _c : errorNode);
+            baseClass = (_c = prefetched === null || prefetched === void 0 ? void 0 : prefetched.objectClass) !== null && _c !== void 0 ? _c : types_1.UnknownType.create();
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.newTypeAnyOrUnknown(), (_d = argList[1].node) !== null && _d !== void 0 ? _d : errorNode);
             isBaseClassAny = true;
         }
         // Specifically disallow Annotated.
-        if (((_d = baseClass.props) === null || _d === void 0 ? void 0 : _d.specialForm) &&
+        if (((_e = baseClass.props) === null || _e === void 0 ? void 0 : _e.specialForm) &&
             (0, types_1.isClassInstance)(baseClass.props.specialForm) &&
             types_1.ClassType.isBuiltIn(baseClass.props.specialForm, 'Annotated')) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.newTypeNotAClass(), argList[1].node || errorNode);
@@ -9417,8 +9439,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function getTypeOfConstant(node, flags) {
         let type;
         if (node.d.constType === 26 /* KeywordType.None */) {
-            if (noneTypeClass) {
-                type = (flags & 128 /* EvalFlags.InstantiableType */) !== 0 ? noneTypeClass : (0, typeUtils_1.convertToInstance)(noneTypeClass);
+            if (prefetched === null || prefetched === void 0 ? void 0 : prefetched.noneTypeClass) {
+                type =
+                    (flags & 128 /* EvalFlags.InstantiableType */) !== 0
+                        ? prefetched.noneTypeClass
+                        : (0, typeUtils_1.convertToInstance)(prefetched.noneTypeClass);
                 if (isTypeFormSupported(node)) {
                     type = types_1.TypeBase.cloneWithTypeForm(type, (0, typeUtils_1.convertToInstance)(type));
                 }
@@ -9510,15 +9535,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 return handleSubtype(subtype);
             }
             if ((0, typeUtils_1.isNoneInstance)(subtype)) {
-                if (objectClass && (0, types_1.isInstantiableClass)(objectClass)) {
+                if ((prefetched === null || prefetched === void 0 ? void 0 : prefetched.objectClass) && (0, types_1.isInstantiableClass)(prefetched.objectClass)) {
                     // Use 'object' for 'None'.
-                    return handleSubtype(types_1.ClassType.cloneAsInstance(objectClass));
+                    return handleSubtype(types_1.ClassType.cloneAsInstance(prefetched.objectClass));
                 }
             }
             if ((0, typeUtils_1.isNoneTypeClass)(subtype)) {
-                if (typeClass && (0, types_1.isInstantiableClass)(typeClass)) {
+                if ((prefetched === null || prefetched === void 0 ? void 0 : prefetched.typeClass) && (0, types_1.isInstantiableClass)(prefetched.typeClass)) {
                     // Use 'type' for 'type[None]'.
-                    return handleSubtype(types_1.ClassType.cloneAsInstance(typeClass));
+                    return handleSubtype(types_1.ClassType.cloneAsInstance(prefetched.typeClass));
                 }
             }
             magicMethodSupported = false;
@@ -9805,8 +9830,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             else if (entryNode.nodeType === 19 /* ParseNodeType.DictionaryExpandEntry */) {
                 let expectedType;
                 if (expectedKeyType && expectedValueType) {
-                    if (supportsKeysAndGetItemClass && (0, types_1.isInstantiableClass)(supportsKeysAndGetItemClass)) {
-                        expectedType = types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(supportsKeysAndGetItemClass, [expectedKeyType, expectedValueType]));
+                    if ((prefetched === null || prefetched === void 0 ? void 0 : prefetched.supportsKeysAndGetItemClass) &&
+                        (0, types_1.isInstantiableClass)(prefetched.supportsKeysAndGetItemClass)) {
+                        expectedType = types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(prefetched.supportsKeysAndGetItemClass, [
+                            expectedKeyType,
+                            expectedValueType,
+                        ]));
                     }
                 }
                 const entryInferenceContext = (0, typeUtils_1.makeInferenceContext)(expectedType);
@@ -9829,8 +9858,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 else if ((0, types_1.isClassInstance)(unexpandedType) && types_1.ClassType.isTypedDictClass(unexpandedType)) {
                     // Handle dictionary expansion for a TypedDict.
-                    if (strClass && (0, types_1.isInstantiableClass)(strClass)) {
-                        const strObject = types_1.ClassType.cloneAsInstance(strClass);
+                    if ((prefetched === null || prefetched === void 0 ? void 0 : prefetched.strClass) && (0, types_1.isInstantiableClass)(prefetched.strClass)) {
+                        const strObject = types_1.ClassType.cloneAsInstance(prefetched.strClass);
                         const tdEntries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluatorInterface, unexpandedType, 
                         /* allowNarrowed */ true);
                         tdEntries.knownItems.forEach((entry, name) => {
@@ -9852,9 +9881,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         addUnknown = false;
                     }
                 }
-                else if (supportsKeysAndGetItemClass && (0, types_1.isInstantiableClass)(supportsKeysAndGetItemClass)) {
+                else if ((prefetched === null || prefetched === void 0 ? void 0 : prefetched.supportsKeysAndGetItemClass) &&
+                    (0, types_1.isInstantiableClass)(prefetched.supportsKeysAndGetItemClass)) {
                     const mappingConstraints = new constraintTracker_1.ConstraintTracker();
-                    supportsKeysAndGetItemClass = (0, typeUtils_1.selfSpecializeClass)(supportsKeysAndGetItemClass);
+                    const supportsKeysAndGetItemClass = (0, typeUtils_1.selfSpecializeClass)(prefetched.supportsKeysAndGetItemClass);
                     if (assignType(types_1.ClassType.cloneAsInstance(supportsKeysAndGetItemClass), unexpandedType, 
                     /* diag */ undefined, mappingConstraints, 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */)) {
                         const specializedMapping = solveAndApplyConstraints(supportsKeysAndGetItemClass, mappingConstraints);
@@ -10691,7 +10721,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     // Creates an Optional[X] type.
     function createOptionalType(classType, errorNode, typeArgs, flags) {
-        var _a;
+        var _a, _b, _c;
         if (!typeArgs) {
             // If no type arguments are provided, the resulting type
             // depends on whether we're evaluating a type annotation or
@@ -10710,14 +10740,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (!validateTypeArg(typeArgs[0])) {
             typeArg0Type = types_1.UnknownType.create();
         }
-        let optionalType = (0, types_1.combineTypes)([typeArg0Type, noneTypeClass !== null && noneTypeClass !== void 0 ? noneTypeClass : types_1.UnknownType.create()]);
-        if (unionTypeClass && (0, types_1.isInstantiableClass)(unionTypeClass)) {
-            optionalType = types_1.TypeBase.cloneAsSpecialForm(optionalType, types_1.ClassType.cloneAsInstance(unionTypeClass));
+        let optionalType = (0, types_1.combineTypes)([typeArg0Type, (_a = prefetched === null || prefetched === void 0 ? void 0 : prefetched.noneTypeClass) !== null && _a !== void 0 ? _a : types_1.UnknownType.create()]);
+        if ((prefetched === null || prefetched === void 0 ? void 0 : prefetched.unionTypeClass) && (0, types_1.isInstantiableClass)(prefetched.unionTypeClass)) {
+            optionalType = types_1.TypeBase.cloneAsSpecialForm(optionalType, types_1.ClassType.cloneAsInstance(prefetched.unionTypeClass));
         }
-        if ((_a = typeArg0Type.props) === null || _a === void 0 ? void 0 : _a.typeForm) {
+        if ((_b = typeArg0Type.props) === null || _b === void 0 ? void 0 : _b.typeForm) {
             const typeFormType = (0, types_1.combineTypes)([
                 typeArg0Type.props.typeForm,
-                (0, typeUtils_1.convertToInstance)(noneTypeClass !== null && noneTypeClass !== void 0 ? noneTypeClass : types_1.UnknownType.create()),
+                (0, typeUtils_1.convertToInstance)((_c = prefetched === null || prefetched === void 0 ? void 0 : prefetched.noneTypeClass) !== null && _c !== void 0 ? _c : types_1.UnknownType.create()),
             ]);
             optionalType = types_1.TypeBase.cloneWithTypeForm(optionalType, typeFormType);
         }
@@ -10741,6 +10771,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     // Creates a type that represents a Literal.
     function createLiteralType(classType, node, flags) {
+        var _a;
         if (node.d.items.length === 0) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.literalEmptyArgs(), node.d.leftExpr);
             return types_1.UnknownType.create();
@@ -10797,7 +10828,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     type = cloneBuiltinClassWithLiteral(node, classType, 'bool', false);
                 }
                 else if (itemExpr.d.constType === 26 /* KeywordType.None */) {
-                    type = noneTypeClass !== null && noneTypeClass !== void 0 ? noneTypeClass : types_1.UnknownType.create();
+                    type = (_a = prefetched === null || prefetched === void 0 ? void 0 : prefetched.noneTypeClass) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
                 }
             }
             else if (itemExpr.nodeType === 55 /* ParseNodeType.UnaryOperation */) {
@@ -10847,8 +10878,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             literalTypes.push(type);
         }
         let result = (0, types_1.combineTypes)(literalTypes, { skipElideRedundantLiterals: true });
-        if ((0, types_1.isUnion)(result) && unionTypeClass && (0, types_1.isInstantiableClass)(unionTypeClass)) {
-            result = types_1.TypeBase.cloneAsSpecialForm(result, types_1.ClassType.cloneAsInstance(unionTypeClass));
+        if ((0, types_1.isUnion)(result) && (prefetched === null || prefetched === void 0 ? void 0 : prefetched.unionTypeClass) && (0, types_1.isInstantiableClass)(prefetched.unionTypeClass)) {
+            result = types_1.TypeBase.cloneAsSpecialForm(result, types_1.ClassType.cloneAsInstance(prefetched.unionTypeClass));
         }
         if (isTypeFormSupported(node) && isValidTypeForm) {
             result = types_1.TypeBase.cloneWithTypeForm(result, (0, typeUtils_1.convertToInstance)(result));
@@ -11352,8 +11383,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             isValidTypeForm = false;
         }
         let unionType = (0, types_1.combineTypes)(types, { skipElideRedundantLiterals: true });
-        if (unionTypeClass && (0, types_1.isInstantiableClass)(unionTypeClass)) {
-            unionType = types_1.TypeBase.cloneAsSpecialForm(unionType, types_1.ClassType.cloneAsInstance(unionTypeClass));
+        if ((prefetched === null || prefetched === void 0 ? void 0 : prefetched.unionTypeClass) && (0, types_1.isInstantiableClass)(prefetched.unionTypeClass)) {
+            unionType = types_1.TypeBase.cloneAsSpecialForm(unionType, types_1.ClassType.cloneAsInstance(prefetched.unionTypeClass));
         }
         if (!isValidTypeForm || types.some((t) => { var _a; return !((_a = t.props) === null || _a === void 0 ? void 0 : _a.typeForm); })) {
             if ((_a = unionType.props) === null || _a === void 0 ? void 0 : _a.typeForm) {
@@ -11552,6 +11583,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // Handles some special-case type annotations that are found
     // within the typings.pyi file.
     function handleTypingStubTypeAnnotation(node) {
+        var _a;
         if (!node.parent || node.parent.nodeType !== 54 /* ParseNodeType.TypeAnnotation */) {
             return undefined;
         }
@@ -11624,7 +11656,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // Handle 'LiteralString' specially because we want it to act as
             // though it derives from 'str'.
             if (assignedName === 'LiteralString') {
-                specialType.shared.baseClasses.push(strClass !== null && strClass !== void 0 ? strClass : types_1.AnyType.create());
+                specialType.shared.baseClasses.push((_a = prefetched === null || prefetched === void 0 ? void 0 : prefetched.strClass) !== null && _a !== void 0 ? _a : types_1.AnyType.create());
                 (0, typeUtils_1.computeMroLinearization)(specialType);
                 if (isTypeFormSupported(node)) {
                     specialType = types_1.TypeBase.cloneWithTypeForm(specialType, (0, typeUtils_1.convertToInstance)(specialType));
@@ -12056,6 +12088,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                     argType = (0, typeUtils_1.stripTypeFormRecursive)(argType);
                     if (!(0, types_1.isAnyOrUnknown)(argType) && !(0, types_1.isUnbound)(argType)) {
+                        // If the specified base class is type(T), use the metaclass
+                        // of T if it's known.
+                        if ((0, types_1.isClass)(argType) &&
+                            types_1.TypeBase.getInstantiableDepth(argType) > 0 &&
+                            argType.shared.effectiveMetaclass &&
+                            (0, types_1.isClass)(argType.shared.effectiveMetaclass)) {
+                            argType = argType.shared.effectiveMetaclass;
+                        }
                         if ((0, typeUtils_1.isMetaclassInstance)(argType)) {
                             (0, debug_1.assert)((0, types_1.isClassInstance)(argType));
                             argType =
@@ -12371,11 +12411,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             // Determine the effective metaclass.
             if (metaclassNode) {
-                const metaclassType = getTypeOfExpression(metaclassNode, exprFlags).type;
+                let metaclassType = getTypeOfExpression(metaclassNode, exprFlags).type;
                 if ((0, types_1.isInstantiableClass)(metaclassType) || (0, types_1.isUnknown)(metaclassType)) {
                     if ((0, typeUtils_1.requiresSpecialization)(metaclassType, { ignorePseudoGeneric: true })) {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.metaclassIsGeneric(), metaclassNode);
                     }
+                    // If the specified metaclass is type(T), use the metaclass
+                    // of T if it's known.
+                    if (types_1.TypeBase.getInstantiableDepth(metaclassType) > 0 &&
+                        (0, types_1.isClass)(metaclassType) &&
+                        metaclassType.shared.effectiveMetaclass &&
+                        (0, types_1.isClass)(metaclassType.shared.effectiveMetaclass)) {
+                        metaclassType = metaclassType.shared.effectiveMetaclass;
+                    }
                     classType.shared.declaredMetaclass = metaclassType;
                     if ((0, types_1.isInstantiableClass)(metaclassType)) {
                         if ((0, enums_1.isEnumMetaclass)(metaclassType)) {
@@ -12647,12 +12695,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return paramTypes;
     }
     function computeEffectiveMetaclass(classType, errorNode) {
+        var _a;
         let effectiveMetaclass = classType.shared.declaredMetaclass;
         let reportedMetaclassConflict = false;
         if (!effectiveMetaclass || (0, types_1.isInstantiableClass)(effectiveMetaclass)) {
             for (const baseClass of classType.shared.baseClasses) {
                 if ((0, types_1.isInstantiableClass)(baseClass)) {
-                    const baseClassMeta = baseClass.shared.effectiveMetaclass || typeClass;
+                    const baseClassMeta = (_a = baseClass.shared.effectiveMetaclass) !== null && _a !== void 0 ? _a : prefetched === null || prefetched === void 0 ? void 0 : prefetched.typeClass;
                     if (baseClassMeta && (0, types_1.isInstantiableClass)(baseClassMeta)) {
                         // Make sure there is no metaclass conflict.
                         if (!effectiveMetaclass) {
@@ -13735,6 +13784,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         const exceptionTypeResult = getTypeOfExpression(node.d.typeExpr);
         const exceptionTypes = exceptionTypeResult.type;
+        let includesBaseException = false;
         function getExceptionType(exceptionType, errorNode) {
             var _a, _b;
             exceptionType = makeTopLevelTypeVarsConcrete(exceptionType);
@@ -13742,6 +13792,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 return exceptionType;
             }
             if ((0, types_1.isInstantiableClass)(exceptionType)) {
+                if (types_1.ClassType.isBuiltIn(exceptionType, 'BaseException')) {
+                    includesBaseException = true;
+                }
                 return types_1.ClassType.cloneAsInstance(exceptionType);
             }
             if ((0, types_1.isClassInstance)(exceptionType)) {
@@ -13768,9 +13821,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             return getExceptionType(subType, node.d.typeExpr);
         });
-        // If this is an except group, wrap the exception type in an BaseExceptionGroup.
+        // If this is an except group, wrap the exception type in an ExceptionGroup
+        // or BaseExceptionGroup depending on whether the target exception is
+        // a BaseException.
         if (node.d.isExceptGroup) {
-            targetType = getBuiltInObject(node, 'BaseExceptionGroup', [targetType]);
+            targetType = getBuiltInObject(node, includesBaseException ? 'BaseExceptionGroup' : 'ExceptionGroup', [
+                targetType,
+            ]);
         }
         if (node.d.name) {
             assignTypeToExpression(node.d.name, { type: targetType }, node.d.name);
@@ -14769,8 +14826,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         return { type: types_1.UnknownType.create() };
                     }
                 }
-                if (typeClass && (0, types_1.isInstantiableClass)(typeClass)) {
-                    let typeType = createSpecialType(typeClass, typeArgs, 1, 
+                if ((prefetched === null || prefetched === void 0 ? void 0 : prefetched.typeClass) && (0, types_1.isInstantiableClass)(prefetched.typeClass)) {
+                    let typeType = createSpecialType(prefetched.typeClass, typeArgs, 1, 
                     /* allowParamSpec */ undefined, 
                     /* isSpecialForm */ false);
                     if ((0, types_1.isInstantiableClass)(typeType)) {
@@ -15164,9 +15221,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // aliased symbols in outer scopes if they haven't yet been assigned
         // within the local scope.
         let scopeTypeHonorsCodeFlow = scopeType !== 2 /* ScopeType.Function */ && scopeType !== 1 /* ScopeType.Comprehension */;
-        // Type parameter scopes don't honor code flow, but if the symbol is resolved
-        // using the proxy scope for the type parameter scope, we should use code flow.
-        if (scopeType === 0 /* ScopeType.TypeParameter */ && symbolWithScope && symbolWithScope.scope === scope) {
+        // Type parameter scopes don't honor code flow.
+        if ((symbolWithScope === null || symbolWithScope === void 0 ? void 0 : symbolWithScope.scope.type) === 0 /* ScopeType.TypeParameter */) {
             scopeTypeHonorsCodeFlow = false;
         }
         if (symbolWithScope && honorCodeFlow && scopeTypeHonorsCodeFlow) {
@@ -15980,6 +16036,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         'TypedDict',
                         'NamedTuple',
                         'NewType',
+                        'TypeAliasType',
                     ];
                     if ((0, types_1.isInstantiableClass)(callType) && types_1.ClassType.isBuiltIn(callType, exemptBuiltins)) {
                         isUnambiguousType = true;
@@ -16840,12 +16897,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (types_1.ClassType.isBuiltIn(destType, 'Mapping')) {
                 const mappingValueType = (0, typedDicts_1.getTypedDictMappingEquivalent)(evaluatorInterface, srcType);
                 if (mappingValueType &&
-                    mappingClass &&
-                    (0, types_1.isInstantiableClass)(mappingClass) &&
-                    strClass &&
-                    (0, types_1.isInstantiableClass)(strClass)) {
-                    srcType = types_1.ClassType.specialize(mappingClass, [
-                        types_1.ClassType.cloneAsInstance(strClass),
+                    (prefetched === null || prefetched === void 0 ? void 0 : prefetched.mappingClass) &&
+                    (0, types_1.isInstantiableClass)(prefetched.mappingClass) &&
+                    (prefetched === null || prefetched === void 0 ? void 0 : prefetched.strClass) &&
+                    (0, types_1.isInstantiableClass)(prefetched.strClass)) {
+                    srcType = types_1.ClassType.specialize(prefetched.mappingClass, [
+                        types_1.ClassType.cloneAsInstance(prefetched.strClass),
                         mappingValueType,
                     ]);
                 }
@@ -16853,11 +16910,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             else if (types_1.ClassType.isBuiltIn(destType, ['dict', 'MutableMapping'])) {
                 const dictValueType = (0, typedDicts_1.getTypedDictDictEquivalent)(evaluatorInterface, srcType, recursionCount);
                 if (dictValueType &&
-                    dictClass &&
-                    (0, types_1.isInstantiableClass)(dictClass) &&
-                    strClass &&
-                    (0, types_1.isInstantiableClass)(strClass)) {
-                    srcType = types_1.ClassType.specialize(dictClass, [types_1.ClassType.cloneAsInstance(strClass), dictValueType]);
+                    (prefetched === null || prefetched === void 0 ? void 0 : prefetched.dictClass) &&
+                    (0, types_1.isInstantiableClass)(prefetched.dictClass) &&
+                    prefetched.strClass &&
+                    (0, types_1.isInstantiableClass)(prefetched.strClass)) {
+                    srcType = types_1.ClassType.specialize(prefetched.dictClass, [
+                        types_1.ClassType.cloneAsInstance(prefetched.strClass),
+                        dictValueType,
+                    ]);
                 }
             }
         }
@@ -17179,7 +17239,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 errorSource = localize_1.LocAddendum.typeVarIsCovariant;
             }
             else if (variance === 4 /* Variance.Contravariant */) {
-                effectiveFlags = (flags ^ 2 /* AssignTypeFlags.Contravariant */) | 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */;
+                effectiveFlags = flags | 2 /* AssignTypeFlags.Contravariant */ | 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */;
                 errorSource = localize_1.LocAddendum.typeVarIsContravariant;
             }
             else {
@@ -17620,10 +17680,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                 }
                 else if (types_1.ClassType.isBuiltIn(concreteSrcType, 'LiteralString') &&
-                    strClass &&
-                    (0, types_1.isInstantiableClass)(strClass) &&
+                    (prefetched === null || prefetched === void 0 ? void 0 : prefetched.strClass) &&
+                    (0, types_1.isInstantiableClass)(prefetched.strClass) &&
                     (flags & 1 /* AssignTypeFlags.Invariant */) === 0) {
-                    concreteSrcType = types_1.ClassType.cloneAsInstance(strClass);
+                    concreteSrcType = types_1.ClassType.cloneAsInstance(prefetched.strClass);
                 }
                 if (!assignClass(types_1.ClassType.cloneAsInstantiable(destType), types_1.ClassType.cloneAsInstantiable(concreteSrcType), diag, constraints, flags, recursionCount, 
                 /* reportErrorsUsingObjType */ true)) {
@@ -17638,8 +17698,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return assignType(destCallbackType, concreteSrcType, diag, constraints, flags, recursionCount);
                 }
                 // All functions are considered instances of "builtins.function".
-                if (functionClass) {
-                    return assignType(destType, (0, typeUtils_1.convertToInstance)(functionClass), diag, constraints, flags, recursionCount);
+                if (prefetched === null || prefetched === void 0 ? void 0 : prefetched.functionClass) {
+                    return assignType(destType, (0, typeUtils_1.convertToInstance)(prefetched.functionClass), diag, constraints, flags, recursionCount);
                 }
             }
             else if ((0, types_1.isModule)(concreteSrcType)) {
@@ -17669,9 +17729,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if ((0, types_1.isAnyOrUnknown)(metaclass)) {
                         return true;
                     }
-                    else {
-                        return assignClass(types_1.ClassType.cloneAsInstantiable(destType), metaclass, diag, constraints, flags, recursionCount, 
-                        /* reportErrorsUsingObjType */ false);
+                    if (assignClass(types_1.ClassType.cloneAsInstantiable(destType), metaclass, 
+                    /* diag */ undefined, constraints, flags, recursionCount, 
+                    /* reportErrorsUsingObjType */ true)) {
+                        return true;
                     }
                 }
             }
@@ -17792,8 +17853,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // Are we trying to assign None to a protocol?
         if ((0, typeUtils_1.isNoneInstance)(srcType) && (0, types_1.isClassInstance)(destType) && types_1.ClassType.isProtocolClass(destType)) {
-            if (noneTypeClass && (0, types_1.isInstantiableClass)(noneTypeClass)) {
-                return (0, protocols_1.assignClassToProtocol)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destType), types_1.ClassType.cloneAsInstance(noneTypeClass), diag, constraints, flags, recursionCount);
+            if ((prefetched === null || prefetched === void 0 ? void 0 : prefetched.noneTypeClass) && (0, types_1.isInstantiableClass)(prefetched.noneTypeClass)) {
+                return (0, protocols_1.assignClassToProtocol)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destType), types_1.ClassType.cloneAsInstance(prefetched.noneTypeClass), diag, constraints, flags, recursionCount);
             }
         }
         if ((0, typeUtils_1.isNoneInstance)(destType)) {
@@ -18315,8 +18376,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 for (const field of types_1.ClassType.getSymbolTable(mroClass)) {
                     if (field[0] !== '__call__' && !field[1].isIgnoredForProtocolMatch()) {
                         let fieldIsPartOfFunction = false;
-                        if (functionClass && (0, types_1.isClass)(functionClass)) {
-                            if (types_1.ClassType.getSymbolTable(functionClass).has(field[0])) {
+                        if ((prefetched === null || prefetched === void 0 ? void 0 : prefetched.functionClass) && (0, types_1.isClass)(prefetched.functionClass)) {
+                            if (types_1.ClassType.getSymbolTable(prefetched.functionClass).has(field[0])) {
                                 fieldIsPartOfFunction = true;
                             }
                         }
@@ -18939,9 +19000,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     // type at runtime.
                     if ((0, types_1.isClassInstance)(srcReturnType) &&
                         types_1.ClassType.isBuiltIn(srcReturnType, ['TypeGuard', 'TypeIs']) &&
-                        boolClass &&
-                        (0, types_1.isInstantiableClass)(boolClass)) {
-                        if (assignType(destReturnType, types_1.ClassType.cloneAsInstance(boolClass), returnDiag === null || returnDiag === void 0 ? void 0 : returnDiag.createAddendum(), constraints, flags, recursionCount)) {
+                        (prefetched === null || prefetched === void 0 ? void 0 : prefetched.boolClass) &&
+                        (0, types_1.isInstantiableClass)(prefetched.boolClass)) {
+                        if (assignType(destReturnType, types_1.ClassType.cloneAsInstance(prefetched.boolClass), returnDiag === null || returnDiag === void 0 ? void 0 : returnDiag.createAddendum(), constraints, flags, recursionCount)) {
                             isReturnTypeCompatible = true;
                         }
                     }
@@ -19480,7 +19541,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // Now check the return type.
         const baseReturnType = getEffectiveReturnType(baseMethod);
-        const overrideReturnType = getEffectiveReturnType(overrideMethod);
+        const overrideReturnType = solveAndApplyConstraints(getEffectiveReturnType(overrideMethod), constraints);
         if (!assignType(baseReturnType, overrideReturnType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, 0 /* AssignTypeFlags.Default */)) {
             diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideReturnType().format({
                 baseType: printType(baseReturnType),