@zzzen/pyright-internal 1.2.0-dev.20240107 → 1.2.0-dev.20240114

package/dist/analyzer/typeEvaluator.js

@@ -187,6 +187,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     let noneType;
     let objectType;
     let typeClassType;
+    let unionClassType;
     let awaitableProtocolType;
     let functionObj;
     let tupleClassType;
@@ -462,6 +463,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             objectType = getBuiltInObject(node, 'object');
             typeClassType = getBuiltInType(node, 'type');
             functionObj = getBuiltInObject(node, 'function');
+            unionClassType = getTypesType(node, 'UnionType');
+            if (unionClassType && (0, types_1.isClass)(unionClassType)) {
+                unionClassType.details.flags |= 1073741824 /* ClassTypeFlags.SpecialFormClass */;
+            }
             // Initialize and cache "Collection" to break a cyclical dependency
             // that occurs when resolving tuple below.
             getTypingType(node, 'Collection');
@@ -482,6 +487,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // Fall back on 'Mapping' if 'SupportsKeysAndGetItem' is not available.
                 mappingType = getTypingType(node, 'Mapping');
             }
+            // Wire up the `Any` class to the special-form version of our internal AnyType.
+            const objectClass = getBuiltInType(node, 'object');
+            if (objectClass &&
+                (0, types_1.isInstantiableClass)(objectClass) &&
+                typeClassType &&
+                (0, types_1.isInstantiableClass)(typeClassType)) {
+                const anyClass = types_1.ClassType.createInstantiable('Any', 'typing.Any', 'typing', uri_1.Uri.empty(), 1 /* ClassTypeFlags.BuiltInClass */, 
+                /* typeSourceId */ -1, 
+                /* declaredMetaclass */ undefined, 
+                /* effectiveMetaclass */ typeClassType);
+                anyClass.details.baseClasses.push(objectClass);
+                (0, typeUtils_1.computeMroLinearization)(anyClass);
+                const anySpecialForm = types_1.AnyType.createSpecialForm();
+                if ((0, types_1.isAny)(anySpecialForm)) {
+                    anySpecialForm.specialForm = anyClass;
+                }
+            }
         }
     }
     function getTypeOfExpression(node, flags = 0 /* EvaluatorFlags.None */, inferenceContext) {
@@ -755,7 +777,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const isEmptyVariadic = (0, types_1.isClassInstance)(typeResult.type) &&
                 types_1.ClassType.isTupleClass(typeResult.type) &&
                 ((_a = typeResult.type.tupleTypeArguments) === null || _a === void 0 ? void 0 : _a.length) === 0;
-            const isEllipsis = (0, types_1.isClassInstance)(typeResult.type) && types_1.ClassType.isBuiltIn(typeResult.type, 'ellipsis');
+            const isEllipsis = (0, types_1.isClassInstance)(typeResult.type) && types_1.ClassType.isBuiltIn(typeResult.type, ['EllipsisType', 'ellipsis']);
             if (!isEmptyVariadic && !isEllipsis) {
                 addExpectedClassDiagnostic(typeResult.type, node);
                 typeResult.type = types_1.UnknownType.create();
@@ -783,11 +805,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return typeResult;
     }
     function getTypeOfEllipsis(flags, typeResult, node) {
+        var _a, _b;
         if ((flags & 1 /* EvaluatorFlags.ConvertEllipsisToAny */) !== 0) {
             typeResult = { type: types_1.AnyType.create(/* isEllipsis */ true) };
         }
         else {
-            const ellipsisType = getBuiltInObject(node, 'ellipsis') || types_1.AnyType.create();
+            const ellipsisType = (_b = (_a = getBuiltInObject(node, 'EllipsisType')) !== null && _a !== void 0 ? _a : getBuiltInObject(node, 'ellipsis')) !== null && _b !== void 0 ? _b : types_1.AnyType.create();
             typeResult = { type: ellipsisType };
         }
         return typeResult;
@@ -1637,7 +1660,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return getDeclaredTypeForExpression(expression.valueExpression, usage);
             }
             case 35 /* ParseNodeType.MemberAccess */: {
-                const baseType = makeTopLevelTypeVarsConcrete(getTypeOfExpression(expression.leftExpression, 16777218 /* EvaluatorFlags.MemberAccessBaseDefaults */).type);
+                const baseType = makeTopLevelTypeVarsConcrete(getTypeOfExpression(expression.leftExpression, 2 /* EvaluatorFlags.MemberAccessBaseDefaults */).type);
                 let classMemberInfo;
                 if ((0, types_1.isClassInstance)(baseType)) {
                     classMemberInfo = (0, typeUtils_1.lookUpObjectMember)(baseType, expression.memberName.value, 64 /* MemberAccessFlags.DeclaredTypesOnly */);
@@ -1924,10 +1947,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getNoneType() {
         return noneType !== null && noneType !== void 0 ? noneType : types_1.UnknownType.create();
     }
+    function getUnionClassType() {
+        return unionClassType !== null && unionClassType !== void 0 ? unionClassType : types_1.UnknownType.create();
+    }
     function getTypingType(node, symbolName) {
         var _a;
         return ((_a = getTypeOfModule(node, symbolName, ['typing'])) !== null && _a !== void 0 ? _a : getTypeOfModule(node, symbolName, ['typing_extensions']));
     }
+    function getTypesType(node, symbolName) {
+        return getTypeOfModule(node, symbolName, ['types']);
+    }
     function getTypeshedType(node, symbolName) {
         return getTypeOfModule(node, symbolName, ['_typeshed']);
     }
@@ -2193,7 +2222,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         writeTypeCache(nameNode, { type: destType, isIncomplete: isTypeIncomplete }, 0 /* EvaluatorFlags.None */);
     }
     function assignTypeToMemberAccessNode(target, type, isTypeIncomplete, srcExpr, expectedTypeDiagAddendum) {
-        const baseTypeResult = getTypeOfExpression(target.leftExpression, 16777218 /* EvaluatorFlags.MemberAccessBaseDefaults */);
+        const baseTypeResult = getTypeOfExpression(target.leftExpression, 2 /* EvaluatorFlags.MemberAccessBaseDefaults */);
         const baseType = makeTopLevelTypeVarsConcrete(baseTypeResult.type);
         // Handle member accesses (e.g. self.x or cls.y).
         if (target.leftExpression.nodeType === 38 /* ParseNodeType.Name */) {
@@ -2653,7 +2682,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Is the source expression a TypeVar() call?
         if ((0, types_1.isTypeVar)(type)) {
             if (srcExpr && srcExpr.nodeType === 9 /* ParseNodeType.Call */) {
-                const callType = getTypeOfExpression(srcExpr.leftExpression, 16777218 /* EvaluatorFlags.CallBaseDefaults */).type;
+                const callType = getTypeOfExpression(srcExpr.leftExpression, 2 /* EvaluatorFlags.CallBaseDefaults */).type;
                 if ((0, types_1.isInstantiableClass)(callType) &&
                     (types_1.ClassType.isBuiltIn(callType, 'TypeVar') ||
                         types_1.ClassType.isBuiltIn(callType, 'TypeVarTuple') ||
@@ -2812,7 +2841,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 break;
             }
             case 35 /* ParseNodeType.MemberAccess */: {
-                const baseTypeResult = getTypeOfExpression(node.leftExpression, 16777218 /* EvaluatorFlags.MemberAccessBaseDefaults */);
+                const baseTypeResult = getTypeOfExpression(node.leftExpression, 2 /* EvaluatorFlags.MemberAccessBaseDefaults */);
                 const delAccessResult = getTypeOfMemberAccessWithBaseType(node, baseTypeResult, { method: 'del' }, 0 /* EvaluatorFlags.None */);
                 const resultToCache = {
                     type: delAccessResult.type,
@@ -2857,7 +2886,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
     }
     function getTypeOfName(node, flags) {
-        var _a;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         const name = node.value;
         let symbol;
@@ -3012,17 +3040,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) === 0) {
             reportUseOfTypeCheckOnly(type, node);
         }
-        if ((flags & 16777216 /* EvaluatorFlags.TreatPep695TypeAliasAsObject */) !== 0) {
-            if (((_a = type.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.name) && type.typeAliasInfo.isPep695Syntax && types_1.TypeBase.isSpecialForm(type)) {
-                const typeAliasType = getTypingType(node, 'TypeAliasType');
-                if (typeAliasType && (0, types_1.isInstantiableClass)(typeAliasType)) {
-                    type = types_1.ClassType.cloneAsInstance(typeAliasType);
-                }
-                else {
-                    type = types_1.UnknownType.create();
-                }
-            }
-        }
         if ((flags & 128 /* EvaluatorFlags.ExpectingInstantiableType */) !== 0) {
             if ((flags & 1024 /* EvaluatorFlags.AllowGenericClassType */) === 0) {
                 if ((0, types_1.isInstantiableClass)(type) && types_1.ClassType.isBuiltIn(type, 'Generic')) {
@@ -3269,6 +3286,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (param.details.defaultType || param.details.isParamSpec) {
                     defaultType = (0, typeUtils_1.applySolvedTypeVars)(param, typeVarContext, { unknownIfNotFound: true });
                 }
+                else if (param.details.isVariadic && tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
+                    defaultType = types_1.ClassType.cloneForUnpacked((0, typeUtils_1.specializeTupleClass)(types_1.ClassType.cloneAsInstance(tupleClassType), [
+                        { type: types_1.UnknownType.create(), isUnbounded: true },
+                    ]));
+                }
                 else {
                     defaultType = types_1.UnknownType.create();
                 }
@@ -3390,7 +3412,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getTypeOfMemberAccess(node, flags) {
         var _a;
         // Compute flags specifically for evaluating the left expression.
-        let leftExprFlags = 16777218 /* EvaluatorFlags.MemberAccessBaseDefaults */;
+        let leftExprFlags = 2 /* EvaluatorFlags.MemberAccessBaseDefaults */;
         leftExprFlags |=
             flags &
                 (256 /* EvaluatorFlags.ExpectingTypeAnnotation */ |
@@ -3461,8 +3483,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // cases where a type is passed as an argument (e.g. "defaultdict(list)").
         // It can also come up in cases like "isinstance(x, (list, dict))".
         // We need to check for functions as well to handle Callable.
-        if ((0, types_1.isInstantiableClass)(typeResult.type) ||
-            ((0, types_1.isFunction)(typeResult.type) && types_1.TypeBase.isSpecialForm(typeResult.type))) {
+        if (((0, types_1.isInstantiableClass)(typeResult.type) && !typeResult.type.includeSubclasses) ||
+            typeResult.type.specialForm) {
             const argNode = ParseTreeUtils.getParentNodeOfType(node, 1 /* ParseNodeType.Argument */);
             if (argNode && ((_a = argNode === null || argNode === void 0 ? void 0 : argNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 9 /* ParseNodeType.Call */) {
                 skipPartialUnknownCheck = true;
@@ -3493,12 +3515,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (baseTypeResult.isIncomplete && (0, types_1.isUnbound)(baseType)) {
             return { type: types_1.UnknownType.create(/* isIncomplete */ true), isIncomplete: true };
         }
-        // Handle the special case where the expression is an actual
-        // UnionType special form.
-        if ((0, types_1.isUnion)(baseType) && types_1.TypeBase.isSpecialForm(baseType)) {
-            if (objectType) {
-                baseType = objectType;
-            }
+        if (baseType.specialForm) {
+            baseType = baseType.specialForm;
         }
         if ((0, types_1.isParamSpec)(baseType) && baseType.paramSpecAccess) {
             baseType = makeTopLevelTypeVarsConcrete(baseType);
@@ -4348,7 +4366,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
-        const indexTypeResult = getTypeOfIndexWithBaseType(node, baseTypeResult, { method: 'get' }, flags & ~16777216 /* EvaluatorFlags.TreatPep695TypeAliasAsObject */);
+        const indexTypeResult = getTypeOfIndexWithBaseType(node, baseTypeResult, { method: 'get' }, flags);
         if ((0, codeFlowTypes_1.isCodeFlowSupportedForReference)(node)) {
             // We limit type narrowing for index expressions to built-in types that are
             // known to have symmetric __getitem__ and __setitem__ methods (i.e. the value
@@ -4387,8 +4405,42 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // the supplied type arguments to map to the type parameter list.
     function adjustTypeArgumentsForVariadicTypeVar(typeArgs, typeParameters, errorNode) {
         const variadicIndex = typeParameters.findIndex((param) => (0, types_1.isVariadicTypeVar)(param));
+        // Is there a *tuple[T, ...] somewhere in the type arguments that we can expand if needed?
+        let srcUnboundedTupleType;
+        let srcUnboundedTupleIndex = typeArgs.findIndex((arg) => {
+            if ((0, types_1.isUnpackedClass)(arg.type) &&
+                arg.type.tupleTypeArguments &&
+                arg.type.tupleTypeArguments.length === 1 &&
+                arg.type.tupleTypeArguments[0].isUnbounded) {
+                srcUnboundedTupleType = arg.type.tupleTypeArguments[0].type;
+                return true;
+            }
+            return false;
+        });
+        if (srcUnboundedTupleType &&
+            srcUnboundedTupleIndex >= 0 &&
+            variadicIndex >= 0 &&
+            typeArgs.length < typeParameters.length) {
+            // "Smear" the tuple type across type argument slots prior to the variadic type var.
+            while (variadicIndex > srcUnboundedTupleIndex) {
+                typeArgs = [
+                    ...typeArgs.slice(0, srcUnboundedTupleIndex),
+                    { node: typeArgs[srcUnboundedTupleIndex].node, type: srcUnboundedTupleType },
+                    ...typeArgs.slice(srcUnboundedTupleIndex),
+                ];
+                srcUnboundedTupleIndex++;
+            }
+            // "Smear" the tuple type across type argument slots following the variadic type var.
+            while (typeArgs.length < typeParameters.length) {
+                typeArgs = [
+                    ...typeArgs.slice(0, srcUnboundedTupleIndex + 1),
+                    { node: typeArgs[srcUnboundedTupleIndex].node, type: srcUnboundedTupleType },
+                    ...typeArgs.slice(srcUnboundedTupleIndex + 1),
+                ];
+            }
+        }
         // Do we need to adjust the type arguments to map to a variadic type
-        // param at the end of the list?
+        // param somewhere in the list?
         if (variadicIndex >= 0) {
             const variadicTypeVar = typeParameters[variadicIndex];
             if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
@@ -4697,7 +4749,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 if (types_1.ClassType.isSpecialBuiltIn(concreteSubtype, 'Literal')) {
                     // Special-case Literal types.
-                    return createLiteralType(node, flags);
+                    return createLiteralType(concreteSubtype, node, flags);
                 }
                 if (types_1.ClassType.isBuiltIn(concreteSubtype, 'InitVar')) {
                     // Special-case InitVar, used in data classes.
@@ -5114,7 +5166,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             else {
-                if (value >= tupleTypeArgs.length) {
+                if (value > tupleTypeArgs.length) {
                     return undefined;
                 }
                 else if (unboundedIndex >= 0 && value > unboundedIndex) {
@@ -5195,16 +5247,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const typeResult = getTypeArgTypeResult(arg.valueExpression, index);
                 if (arg.argumentCategory !== 0 /* ArgumentCategory.Simple */) {
                     if (arg.argumentCategory === 1 /* ArgumentCategory.UnpackedList */) {
-                        if ((0, types_1.isVariadicTypeVar)(typeResult.type) && !typeResult.type.isVariadicUnpacked) {
-                            typeResult.type = types_1.TypeVarType.cloneForUnpacked(typeResult.type);
-                        }
-                        else if ((0, types_1.isInstantiableClass)(typeResult.type) &&
-                            !typeResult.type.includeSubclasses &&
-                            (0, typeUtils_1.isTupleClass)(typeResult.type)) {
-                            typeResult.type = types_1.ClassType.cloneForUnpacked(typeResult.type);
-                        }
-                        else {
-                            addError(localize_1.Localizer.Diagnostic.unpackNotAllowed(), arg.valueExpression);
+                        if (!(options === null || options === void 0 ? void 0 : options.isAnnotatedClass) || index === 0) {
+                            if ((0, types_1.isVariadicTypeVar)(typeResult.type) && !typeResult.type.isVariadicUnpacked) {
+                                typeResult.type = types_1.TypeVarType.cloneForUnpacked(typeResult.type);
+                            }
+                            else if ((0, types_1.isInstantiableClass)(typeResult.type) &&
+                                !typeResult.type.includeSubclasses &&
+                                (0, typeUtils_1.isTupleClass)(typeResult.type)) {
+                                typeResult.type = types_1.ClassType.cloneForUnpacked(typeResult.type);
+                            }
+                            else {
+                                addError(localize_1.Localizer.Diagnostic.unpackNotAllowed(), arg.valueExpression);
+                            }
                         }
                     }
                 }
@@ -5447,7 +5501,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             baseTypeResult = getTypeOfLambdaForCall(node, inferenceContext);
         }
         else {
-            baseTypeResult = getTypeOfExpression(node.leftExpression, 16777218 /* EvaluatorFlags.CallBaseDefaults */ | (flags & 4 /* EvaluatorFlags.AllowForwardReferences */));
+            baseTypeResult = getTypeOfExpression(node.leftExpression, 2 /* EvaluatorFlags.CallBaseDefaults */ | (flags & 4 /* EvaluatorFlags.AllowForwardReferences */));
         }
         const argList = ParseTreeUtils.getArgumentsByRuntimeOrder(node).map((arg) => {
             const functionArg = {
@@ -5578,7 +5632,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         function getLambdaType() {
-            return getTypeOfExpression(node.leftExpression, 16777218 /* EvaluatorFlags.CallBaseDefaults */, (0, typeUtils_1.makeInferenceContext)(expectedType));
+            return getTypeOfExpression(node.leftExpression, 2 /* EvaluatorFlags.CallBaseDefaults */, (0, typeUtils_1.makeInferenceContext)(expectedType));
         }
         // If one or more of the arguments are incomplete, use speculative mode
         // for the lambda evaluation because it may need to be reevaluated once
@@ -5588,7 +5642,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             : getLambdaType();
         // If bidirectional type inference failed, use normal type inference instead.
         if (typeResult.typeErrors) {
-            typeResult = getTypeOfExpression(node.leftExpression, 16777218 /* EvaluatorFlags.CallBaseDefaults */);
+            typeResult = getTypeOfExpression(node.leftExpression, 2 /* EvaluatorFlags.CallBaseDefaults */);
         }
         return typeResult;
     }
@@ -6360,7 +6414,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return { returnType: types_1.UnknownType.create(), argumentErrors: true, overloadsUsedForCall };
         }
         recursionCount++;
-        if (types_1.TypeBase.isSpecialForm(callTypeResult.type)) {
+        // Special forms are not callable.
+        if (callTypeResult.type.specialForm) {
             const exprNode = errorNode.nodeType === 9 /* ParseNodeType.Call */ ? errorNode.leftExpression : errorNode;
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.objectNotCallable().format({
                 type: printType(callTypeResult.type, { expandTypeAlias: true }),
@@ -6659,14 +6714,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (className === 'NewType') {
                 return { returnType: createNewType(errorNode, argList) };
             }
-            if (className === 'Protocol' ||
-                className === 'Generic' ||
-                className === 'Callable' ||
-                className === 'Concatenate' ||
-                className === 'Type') {
+            if (types_1.ClassType.isSpecialFormClass(expandedCallType)) {
                 const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
                 addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeNotIntantiable().format({ type: className }), errorNode);
-                return { returnType: types_1.AnyType.create(), argumentErrors: true };
+                return { returnType: types_1.UnknownType.create(), argumentErrors: true };
             }
             if ((0, types_1.isClass)(unexpandedCallType) && (0, enums_1.isKnownEnumType)(className)) {
                 return {
@@ -8266,8 +8317,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     ? 512 /* EvaluatorFlags.AllowMissingTypeArgs */ |
                         8 /* EvaluatorFlags.EvaluateStringLiteralAsType */ |
                         32 /* EvaluatorFlags.DisallowParamSpec */ |
-                        64 /* EvaluatorFlags.DisallowTypeVarTuple */ |
-                        16777216 /* EvaluatorFlags.TreatPep695TypeAliasAsObject */
+                        64 /* EvaluatorFlags.DisallowTypeVarTuple */
                     : 2 /* EvaluatorFlags.DoNotSpecialize */;
                 const exprTypeResult = getTypeOfExpression(argParam.argument.valueExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedType, !!(typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete), signatureTracker));
                 argType = exprTypeResult.type;
@@ -8386,8 +8436,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
+        let assignTypeFlags = skipSolveTypeVars ? 8 /* AssignTypeFlags.SkipSolveTypeVars */ : 0 /* AssignTypeFlags.Default */;
+        if (argParam.isinstanceParam) {
+            assignTypeFlags |= 32768 /* AssignTypeFlags.AllowIsinstanceSpecialForms */;
+        }
         if (!assignType(argParam.paramType, argType, diag.createAddendum(), typeVarContext, 
-        /* srcTypeVarContext */ undefined, skipSolveTypeVars ? 8 /* AssignTypeFlags.SkipSolveTypeVars */ : undefined)) {
+        /* srcTypeVarContext */ undefined, assignTypeFlags)) {
             // Mismatching parameter types are common in untyped code; don't bother spending time
             // printing types if the diagnostic is disabled.
             const fileInfo = AnalyzerNodeInfo.getFileInfo(argParam.errorNode);
@@ -8746,7 +8800,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 functionType.details.paramSpec = typeResult.type;
                 return functionType;
             }
-            if ((0, types_1.isClassInstance)(typeResult.type) && types_1.ClassType.isBuiltIn(typeResult.type, 'ellipsis')) {
+            if ((0, types_1.isClassInstance)(typeResult.type) &&
+                types_1.ClassType.isBuiltIn(typeResult.type, ['EllipsisType', 'ellipsis'])) {
                 types_1.FunctionType.addDefaultParameters(functionType);
                 return functionType;
             }
@@ -8902,17 +8957,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             isBaseClassAny = true;
         }
         if (!(0, types_1.isInstantiableClass)(baseClass)) {
-            addError(localize_1.Localizer.Diagnostic.newTypeNotAClass(), argList[1].node || errorNode);
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.newTypeNotAClass(), argList[1].node || errorNode);
             return undefined;
         }
         if (types_1.ClassType.isProtocolClass(baseClass) || types_1.ClassType.isTypedDictClass(baseClass)) {
-            addError(localize_1.Localizer.Diagnostic.newTypeProtocolClass(), argList[1].node || errorNode);
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.newTypeProtocolClass(), argList[1].node || errorNode);
         }
         else if (baseClass.literalValue !== undefined) {
-            addError(localize_1.Localizer.Diagnostic.newTypeLiteral(), argList[1].node || errorNode);
-        }
-        else if (types_1.ClassType.isNewTypeClass(baseClass)) {
-            addError(localize_1.Localizer.Diagnostic.newTypeNewTypeClass(), argList[1].node || errorNode);
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.newTypeLiteral(), argList[1].node || errorNode);
         }
         let classFlags = baseClass.details.flags & ~(1 /* ClassTypeFlags.BuiltInClass */ | 2 /* ClassTypeFlags.SpecialBuiltIn */);
         classFlags |= 4096 /* ClassTypeFlags.Final */ | 268435456 /* ClassTypeFlags.NewTypeClass */ | 536870912 /* ClassTypeFlags.ValidTypeAliasClass */;
@@ -9846,9 +9898,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // or the final expression contain an "await" operator anywhere within
         // the expression, it is treated as an async generator.
         let isAsync = node.forIfNodes.some((comp) => {
-            return ((comp.nodeType === 33 /* ParseNodeType.ListComprehensionFor */ && comp.isAsync) ||
-                (comp.nodeType === 34 /* ParseNodeType.ListComprehensionIf */ &&
-                    ParseTreeUtils.containsAwaitNode(comp.testExpression)));
+            if (comp.nodeType === 33 /* ParseNodeType.ListComprehensionFor */ && comp.isAsync) {
+                return true;
+            }
+            return ParseTreeUtils.containsAwaitNode(comp);
         });
         let type = types_1.UnknownType.create();
         if (ParseTreeUtils.containsAwaitNode(node.expression)) {
@@ -9863,14 +9916,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             typeErrors = true;
         }
         const elementType = elementTypeResult.type;
-        // Handle the special case where a generator function (e.g. `(await x for x in y)`)
-        // is expected to be an AsyncGenerator.
-        if (!isAsync &&
-            inferenceContext &&
-            (0, types_1.isClassInstance)(inferenceContext.expectedType) &&
-            types_1.ClassType.isBuiltIn(inferenceContext.expectedType, 'AsyncGenerator')) {
-            isAsync = true;
-        }
         const builtInIteratorType = getTypingType(node, isAsync ? 'AsyncGenerator' : 'Generator');
         if (builtInIteratorType && (0, types_1.isInstantiableClass)(builtInIteratorType)) {
             type = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(builtInIteratorType, isAsync ? [elementType, getNoneType()] : [elementType, getNoneType(), getNoneType()], 
@@ -10057,9 +10102,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // to two arguments.The first argument, if present, should be an ellipsis,
     // a ParamSpec, a Concatenate, or a list of positional parameter types.
     // The second argument, if present, should specify the return type.
-    function createCallableType(typeArgs, errorNode) {
+    function createCallableType(classType, typeArgs, errorNode) {
         const functionType = types_1.FunctionType.createInstantiable(0 /* FunctionTypeFlags.None */);
-        types_1.TypeBase.setSpecialForm(functionType);
+        functionType.specialForm = classType;
         functionType.details.declaredReturnType = types_1.UnknownType.create();
         functionType.details.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(errorNode);
         if (typeArgs && typeArgs.length > 0) {
@@ -10192,9 +10237,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             addExpectedClassDiagnostic(typeArg0Type, typeArgs[0].node);
             typeArg0Type = types_1.UnknownType.create();
         }
-        const optionalType = (0, types_1.combineTypes)([typeArg0Type, noneClassType !== null && noneClassType !== void 0 ? noneClassType : types_1.UnknownType.create()]);
-        if ((0, types_1.isUnion)(optionalType)) {
-            types_1.TypeBase.setSpecialForm(optionalType);
+        let optionalType = (0, types_1.combineTypes)([typeArg0Type, noneClassType !== null && noneClassType !== void 0 ? noneClassType : types_1.UnknownType.create()]);
+        if (unionClassType && (0, types_1.isInstantiableClass)(unionClassType)) {
+            optionalType = types_1.TypeBase.cloneAsSpecialForm(optionalType, unionClassType);
         }
         return optionalType;
     }
@@ -10205,15 +10250,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return types_1.UnknownType.create();
     }
-    function cloneBuiltinClassWithLiteral(node, builtInName, value) {
+    function cloneBuiltinClassWithLiteral(node, literalClassType, builtInName, value) {
         const type = getBuiltInType(node, builtInName);
         if ((0, types_1.isInstantiableClass)(type)) {
-            return types_1.ClassType.cloneWithLiteral(type, value);
+            const literalType = types_1.ClassType.cloneWithLiteral(type, value);
+            literalType.specialForm = literalClassType;
+            return literalType;
         }
         return types_1.UnknownType.create();
     }
     // Creates a type that represents a Literal.
-    function createLiteralType(node, flags) {
+    function createLiteralType(classType, node, flags) {
         if (node.items.length === 0) {
             addError(localize_1.Localizer.Diagnostic.literalEmptyArgs(), node.baseExpression);
             return types_1.UnknownType.create();
@@ -10236,33 +10283,36 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const isBytes = (itemExpr.strings[0].token.flags & 32 /* StringTokenFlags.Bytes */) !== 0;
                 const value = itemExpr.strings.map((s) => s.value).join('');
                 if (isBytes) {
-                    type = cloneBuiltinClassWithLiteral(node, 'bytes', value);
+                    type = cloneBuiltinClassWithLiteral(node, classType, 'bytes', value);
                 }
                 else {
-                    type = cloneBuiltinClassWithLiteral(node, 'str', value);
+                    type = cloneBuiltinClassWithLiteral(node, classType, 'str', value);
                 }
             }
             else if (itemExpr.nodeType === 40 /* ParseNodeType.Number */) {
                 if (!itemExpr.isImaginary && itemExpr.isInteger) {
-                    type = cloneBuiltinClassWithLiteral(node, 'int', itemExpr.value);
+                    type = cloneBuiltinClassWithLiteral(node, classType, 'int', itemExpr.value);
                 }
             }
             else if (itemExpr.nodeType === 11 /* ParseNodeType.Constant */) {
                 if (itemExpr.constType === 33 /* KeywordType.True */) {
-                    type = cloneBuiltinClassWithLiteral(node, 'bool', true);
+                    type = cloneBuiltinClassWithLiteral(node, classType, 'bool', true);
                 }
                 else if (itemExpr.constType === 15 /* KeywordType.False */) {
-                    type = cloneBuiltinClassWithLiteral(node, 'bool', false);
+                    type = cloneBuiltinClassWithLiteral(node, classType, 'bool', false);
                 }
                 else if (itemExpr.constType === 26 /* KeywordType.None */) {
                     type = noneClassType !== null && noneClassType !== void 0 ? noneClassType : types_1.UnknownType.create();
                 }
             }
-            else if (itemExpr.nodeType === 55 /* ParseNodeType.UnaryOperation */ &&
-                itemExpr.operator === 33 /* OperatorType.Subtract */) {
-                if (itemExpr.expression.nodeType === 40 /* ParseNodeType.Number */) {
-                    if (!itemExpr.expression.isImaginary && itemExpr.expression.isInteger) {
-                        type = cloneBuiltinClassWithLiteral(node, 'int', -itemExpr.expression.value);
+            else if (itemExpr.nodeType === 55 /* ParseNodeType.UnaryOperation */) {
+                if (itemExpr.operator === 33 /* OperatorType.Subtract */ || itemExpr.operator === 0 /* OperatorType.Add */) {
+                    if (itemExpr.expression.nodeType === 40 /* ParseNodeType.Number */) {
+                        if (!itemExpr.expression.isImaginary && itemExpr.expression.isInteger) {
+                            type = cloneBuiltinClassWithLiteral(node, classType, 'int', itemExpr.operator === 33 /* OperatorType.Subtract */
+                                ? -itemExpr.expression.value
+                                : itemExpr.expression.value);
+                        }
                     }
                 }
             }
@@ -10561,7 +10611,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // Creates one of several "special" types that are defined in typing.pyi
     // but not declared in their entirety. This includes the likes of "Tuple",
     // "Dict", etc.
-    function createSpecialType(classType, typeArgs, paramLimit, allowParamSpec = false, isCallable = false) {
+    function createSpecialType(classType, typeArgs, paramLimit, allowParamSpec = false, isSpecialForm = true) {
         const isTupleTypeParam = types_1.ClassType.isTupleClass(classType);
         if (typeArgs) {
             if (isTupleTypeParam && typeArgs.length === 1 && typeArgs[0].isEmptyTupleShorthand) {
@@ -10665,8 +10715,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else {
             returnType = types_1.ClassType.cloneForSpecialization(classType, typeArgTypes, typeArgs !== undefined);
         }
-        if (!isCallable) {
-            types_1.TypeBase.setSpecialForm(returnType);
+        if (isSpecialForm) {
+            returnType = types_1.TypeBase.cloneAsSpecialForm(returnType, classType);
         }
         return returnType;
     }
@@ -10729,9 +10779,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (types.length === 1 && !allowSingleTypeArg && !(0, typeUtils_1.isNoneInstance)(types[0])) {
             addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.unionTypeArgCount(), errorNode);
         }
-        const unionType = (0, types_1.combineTypes)(types);
-        if ((0, types_1.isUnion)(unionType)) {
-            types_1.TypeBase.setSpecialForm(unionType);
+        let unionType = (0, types_1.combineTypes)(types);
+        if (unionClassType && (0, types_1.isInstantiableClass)(unionClassType)) {
+            unionType = types_1.TypeBase.cloneAsSpecialForm(unionType, unionClassType);
         }
         return unionType;
     }
@@ -10822,11 +10872,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         const fileInfo = AnalyzerNodeInfo.getFileInfo(name);
-        const typeAlias = types_1.TypeBase.cloneForTypeAlias(type, name.value, ParseTreeUtils.getClassFullName(name, fileInfo.moduleName, name.value), fileInfo.moduleName, fileInfo.fileUri, typeAliasScopeId, isPep695Syntax, typeParameters.length > 0 ? typeParameters : undefined);
+        let typeAlias = types_1.TypeBase.cloneForTypeAlias(type, name.value, ParseTreeUtils.getClassFullName(name, fileInfo.moduleName, name.value), fileInfo.moduleName, fileInfo.fileUri, typeAliasScopeId, isPep695Syntax, typeParameters.length > 0 ? typeParameters : undefined);
         // All PEP 695 type aliases are special forms because they are
         // TypeAliasType objects at runtime.
         if (isPep695Syntax || isPep695TypeVarType) {
-            typeAlias.flags |= 8 /* TypeFlags.SpecialForm */;
+            const typeAliasTypeClass = getTypingType(errorNode, 'TypeAliasType');
+            if (typeAliasTypeClass && (0, types_1.isInstantiableClass)(typeAliasTypeClass)) {
+                typeAlias = types_1.TypeBase.cloneAsSpecialForm(typeAlias, typeAliasTypeClass);
+            }
         }
         return typeAlias;
     }
@@ -10837,6 +10890,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         /* typeSourceId */ 0, 
         /* declaredMetaclass */ undefined, 
         /* effectiveMetaclass */ undefined);
+        if (aliasMapEntry.isSpecialForm) {
+            specialClassType.details.flags |= 1073741824 /* ClassTypeFlags.SpecialFormClass */;
+        }
         const specialBuiltInClassDeclaration = ((_a = AnalyzerNodeInfo.getDeclaration(node)) !== null && _a !== void 0 ? _a : (node.parent ? AnalyzerNodeInfo.getDeclaration(node.parent) : undefined));
         specialClassType.details.declaration = specialBuiltInClassDeclaration;
         if (fileInfo.isTypingExtensionsStubFile) {
@@ -10894,28 +10950,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const assignedName = nameNode.value;
         const specialTypes = new Map([
             ['Tuple', { alias: 'tuple', module: 'builtins' }],
-            ['Generic', { alias: '', module: 'builtins' }],
-            ['Protocol', { alias: '', module: 'builtins' }],
-            ['Callable', { alias: '', module: 'builtins' }],
+            ['Generic', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['Protocol', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['Callable', { alias: '', module: 'builtins', isSpecialForm: true }],
             ['Type', { alias: 'type', module: 'builtins' }],
-            ['ClassVar', { alias: '', module: 'builtins' }],
-            ['Final', { alias: '', module: 'builtins' }],
-            ['Literal', { alias: '', module: 'builtins' }],
+            ['ClassVar', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['Final', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['Literal', { alias: '', module: 'builtins', isSpecialForm: true }],
             ['TypedDict', { alias: '_TypedDict', module: 'self' }],
-            ['Union', { alias: '', module: 'builtins' }],
-            ['Optional', { alias: '', module: 'builtins' }],
-            ['Annotated', { alias: '', module: 'builtins' }],
-            ['TypeAlias', { alias: '', module: 'builtins' }],
-            ['Concatenate', { alias: '', module: 'builtins' }],
-            ['TypeGuard', { alias: '', module: 'builtins' }],
-            ['Unpack', { alias: '', module: 'builtins' }],
-            ['Required', { alias: '', module: 'builtins' }],
-            ['NotRequired', { alias: '', module: 'builtins' }],
-            ['Self', { alias: '', module: 'builtins' }],
-            ['NoReturn', { alias: '', module: 'builtins' }],
-            ['Never', { alias: '', module: 'builtins' }],
-            ['LiteralString', { alias: '', module: 'builtins' }],
-            ['ReadOnly', { alias: '', module: 'builtins' }],
+            ['Union', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['Optional', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['Annotated', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['TypeAlias', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['Concatenate', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['TypeGuard', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['Unpack', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['Required', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['NotRequired', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['Self', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['NoReturn', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['Never', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['LiteralString', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['ReadOnly', { alias: '', module: 'builtins', isSpecialForm: true }],
         ]);
         const aliasMapEntry = specialTypes.get(assignedName);
         if (aliasMapEntry) {
@@ -11127,7 +11183,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     callLeftNode.leftExpression.nodeType === 38 /* ParseNodeType.Name */)) {
                 // See if this is a call to TypedDict. We want to support
                 // recursive type references in a TypedDict call.
-                const callType = getTypeOfExpression(callLeftNode, 16777218 /* EvaluatorFlags.CallBaseDefaults */).type;
+                const callType = getTypeOfExpression(callLeftNode, 2 /* EvaluatorFlags.CallBaseDefaults */).type;
                 if ((0, types_1.isInstantiableClass)(callType) && types_1.ClassType.isBuiltIn(callType, 'TypedDict')) {
                     return true;
                 }
@@ -11289,8 +11345,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 262144 /* EvaluatorFlags.DisallowNakedGeneric */ |
                 2048 /* EvaluatorFlags.DisallowTypeVarsWithScopeId */ |
                 8192 /* EvaluatorFlags.AssociateTypeVarsWithCurrentScope */ |
-                16384 /* EvaluatorFlags.EnforceTypeVarVarianceConsistency */ |
-                16777216 /* EvaluatorFlags.TreatPep695TypeAliasAsObject */;
+                16384 /* EvaluatorFlags.EnforceTypeVarVarianceConsistency */;
             if (fileInfo.isStubFile) {
                 exprFlags |= 4 /* EvaluatorFlags.AllowForwardReferences */;
             }
@@ -11319,7 +11374,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     // Any is allowed as a base class. Remove its "special form" flag to avoid
                     // false positive errors.
-                    if ((0, types_1.isAny)(argType) && types_1.TypeBase.isSpecialForm(argType)) {
+                    if ((0, types_1.isAny)(argType) && argType.specialForm) {
                         argType = types_1.AnyType.create();
                     }
                     if (!(0, types_1.isAnyOrUnknown)(argType) && !(0, types_1.isUnbound)(argType)) {
@@ -11374,6 +11429,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 addError(localize_1.Localizer.Diagnostic.baseClassCircular(), arg);
                                 argType = types_1.UnknownType.create();
                             }
+                            // If the class is attempting to derive from a TypeAliasType,
+                            // generate an error.
+                            if (argType.specialForm && types_1.ClassType.isBuiltIn(argType.specialForm, 'TypeAliasType')) {
+                                addError(localize_1.Localizer.Diagnostic.typeAliasTypeBaseClass(), arg);
+                                argType = types_1.UnknownType.create();
+                            }
                         }
                     }
                     if ((0, types_1.isUnknown)(argType)) {
@@ -13443,7 +13504,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         nodeToEvaluate = parent;
                         continue;
                     }
-                    flags = 16777218 /* EvaluatorFlags.CallBaseDefaults */;
+                    flags = 2 /* EvaluatorFlags.CallBaseDefaults */;
                     break;
                 }
             }
@@ -13791,7 +13852,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const aliasedName = classType.aliasName || classType.details.name;
             switch (aliasedName) {
                 case 'Callable': {
-                    return { type: createCallableType(typeArgs, errorNode) };
+                    return { type: createCallableType(classType, typeArgs, errorNode) };
                 }
                 case 'Never': {
                     if (typeArgs && typeArgs.length > 0) {
@@ -13809,7 +13870,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return { type: createOptionalType(classType, errorNode, typeArgs, flags) };
                 }
                 case 'Type': {
-                    let typeType = createSpecialType(classType, typeArgs, 1);
+                    let typeType = createSpecialType(classType, typeArgs, 1, 
+                    /* allowParamSpec */ undefined, 
+                    /* isSpecialForm */ false);
                     if ((0, types_1.isInstantiableClass)(typeType)) {
                         typeType = (0, typeUtils_1.explodeGenericClass)(typeType);
                     }
@@ -13847,7 +13910,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     break;
                 }
                 case 'Tuple': {
-                    return { type: createSpecialType(classType, typeArgs, /* paramLimit */ undefined) };
+                    return {
+                        type: createSpecialType(classType, typeArgs, 
+                        /* paramLimit */ undefined, 
+                        /* allowParamSpec */ false, 
+                        /* isSpecialForm */ false),
+                    };
                 }
                 case 'Union': {
                     return { type: createUnionType(classType, errorNode, typeArgs, flags) };
@@ -13906,7 +13974,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (typeClassType && (0, types_1.isInstantiableClass)(typeClassType)) {
                     let typeType = createSpecialType(typeClassType, typeArgs, 1, 
                     /* allowParamSpec */ undefined, 
-                    /* isCallable */ true);
+                    /* isSpecialForm */ false);
                     if ((0, types_1.isInstantiableClass)(typeType)) {
                         typeType = (0, typeUtils_1.explodeGenericClass)(typeType);
                     }
@@ -13920,7 +13988,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     type: createSpecialType(classType, typeArgs, 
                     /* paramLimit */ undefined, 
                     /* allowParamSpec */ undefined, 
-                    /* isCallable */ true),
+                    /* isSpecialForm */ false),
                 };
             }
         }
@@ -14918,7 +14986,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 // Special-case calls to certain built-in type functions.
                 if (((_a = resolvedDecl.inferredTypeSource) === null || _a === void 0 ? void 0 : _a.nodeType) === 9 /* ParseNodeType.Call */) {
-                    const baseTypeResult = getTypeOfExpression(resolvedDecl.inferredTypeSource.leftExpression, 16777218 /* EvaluatorFlags.CallBaseDefaults */);
+                    const baseTypeResult = getTypeOfExpression(resolvedDecl.inferredTypeSource.leftExpression, 2 /* EvaluatorFlags.CallBaseDefaults */);
                     const callType = baseTypeResult.type;
                     const exemptBuiltins = [
                         'TypeVar',
@@ -16205,6 +16273,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (destType === srcType && !(0, typeUtils_1.requiresSpecialization)(destType)) {
             return true;
         }
+        // If the source type is a special form, use the literal special form
+        // class rather than the symbolic form.
+        if (srcType.specialForm) {
+            let isSpecialFormExempt = false;
+            // A few special forms that are normally not compatible with type[T]
+            // are compatible specifically in the context of isinstance and issubclass.
+            if ((flags & 32768 /* AssignTypeFlags.AllowIsinstanceSpecialForms */) !== 0) {
+                if (types_1.ClassType.isBuiltIn(srcType.specialForm, ['Callable', 'UnionType', 'Generic'])) {
+                    isSpecialFormExempt = true;
+                }
+            }
+            if (!isSpecialFormExempt) {
+                srcType = srcType.specialForm;
+            }
+        }
         if (recursionCount > types_1.maxTypeRecursionCount) {
             return true;
         }
@@ -16402,7 +16485,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, types_1.isAnyOrUnknown)(destType)) {
             return true;
         }
-        if ((0, types_1.isAnyOrUnknown)(srcType) && !types_1.TypeBase.isSpecialForm(srcType)) {
+        if ((0, types_1.isAnyOrUnknown)(srcType) && !srcType.specialForm) {
             const targetTypeVarContext = (flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) === 0 ? destTypeVarContext : srcTypeVarContext;
             if (targetTypeVarContext) {
                 // If it's an ellipsis type, convert it to a regular "Any"
@@ -16507,8 +16590,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         return false;
                     }
                 }
-                if (assignClass(destType, expandedSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount, 
-                /* reportErrorsUsingObjType */ false)) {
+                if (!isSpecialFormClass(expandedSrcType, flags) &&
+                    assignClass(destType, expandedSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount, 
+                    /* reportErrorsUsingObjType */ false)) {
                     return true;
                 }
                 diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
@@ -16530,6 +16614,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if ((0, types_1.isClassInstance)(destType)) {
             if (types_1.ClassType.isBuiltIn(destType, 'type')) {
+                if ((0, types_1.isInstantiableClass)(srcType) && isSpecialFormClass(srcType, flags)) {
+                    return false;
+                }
                 if ((0, types_1.isAnyOrUnknown)(srcType) && (flags & 16 /* AssignTypeFlags.OverloadOverlapCheck */) !== 0) {
                     return false;
                 }
@@ -16631,7 +16718,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
             }
-            else if ((0, types_1.isAnyOrUnknown)(concreteSrcType) && !types_1.TypeBase.isSpecialForm(concreteSrcType)) {
+            else if ((0, types_1.isAnyOrUnknown)(concreteSrcType) && !concreteSrcType.specialForm) {
                 return (flags & 16 /* AssignTypeFlags.OverloadOverlapCheck */) === 0;
             }
             else if ((0, types_1.isUnion)(concreteSrcType)) {
@@ -16932,6 +17019,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return true;
     }
+    function isSpecialFormClass(classType, flags) {
+        if ((flags & 32768 /* AssignTypeFlags.AllowIsinstanceSpecialForms */) !== 0) {
+            return false;
+        }
+        return types_1.ClassType.isSpecialFormClass(classType);
+    }
     // Determines whether a type is "subsumed by" (i.e. is a proper subtype of) one
     // of the other type.
     function isTypeSubsumedByOtherType(type, otherType, allowAnyToSubsume, recursionCount = 0) {
@@ -18697,6 +18790,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         isNodeReachable,
         isAsymmetricAccessorAssignment,
         suppressDiagnostics,
+        isSpecialFormClass,
         getDeclarationsForStringNode,
         getDeclarationsForNameNode,
         getTypeForDeclaration,
@@ -18739,6 +18833,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         getTupleClassType,
         getObjectType,
         getNoneType,
+        getUnionClassType,
         getBuiltInObject,
         getTypingType,
         assignTypeArguments,