@zzzen/pyright-internal 1.2.0-dev.20261018 → 1.2.0-dev.20261108

package/dist/analyzer/typeEvaluator/specialFormCreation.js

@@ -0,0 +1,1728 @@
+"use strict";
+/*
+ * specialFormCreation.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ *
+ * specialFormCreation implementation, using evaluator-owned dependencies and state.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSpecialFormCreation = createSpecialFormCreation;
+const collectionUtils_1 = require("../../common/collectionUtils");
+const debug_1 = require("../../common/debug");
+const diagnostic_1 = require("../../common/diagnostic");
+const diagnosticRules_1 = require("../../common/diagnosticRules");
+const pythonVersion_1 = require("../../common/pythonVersion");
+const localize_1 = require("../../localization/localize");
+const analyzerFileInfo_1 = require("../analyzerFileInfo");
+const constraintTracker_1 = require("../constraintTracker");
+const decorators_1 = require("../decorators");
+const ParseTreeUtils = __importStar(require("../parseTreeUtils"));
+const tuples_1 = require("../tuples");
+const types_1 = require("../types");
+const typeUtils_1 = require("../typeUtils");
+// Synthesizes typing special forms and validates their arguments through evaluator callbacks.
+function createSpecialFormCreation(context) {
+    const { addDiagnostic, applyUnpackToTupleLike, getScopeIdForNode, getTypeOfClass, getTupleClassType, getTypeVarScopesForNode, getTypingType, nodeInfo, validateTypeMetadata, assignType, convertTypeArgToInstance, getTypeOfAnnotation, makeTopLevelTypeVarsConcrete, printType, getBuiltInType, solveAndApplyConstraints, getTypeOfExpression, } = context;
+    function reportUseOfTypeCheckOnly(type, node) {
+        let isTypeCheckingOnly = false;
+        let name = '';
+        if ((0, types_1.isInstantiableClass)(type) && !type.priv.includeSubclasses) {
+            isTypeCheckingOnly = types_1.ClassType.isTypeCheckOnly(type);
+            name = type.shared.name;
+        }
+        else if ((0, types_1.isFunction)(type)) {
+            isTypeCheckingOnly = types_1.FunctionType.isTypeCheckOnly(type);
+            name = type.shared.name;
+        }
+        if (isTypeCheckingOnly) {
+            const fileInfo = nodeInfo.getFileInfo(node);
+            if (!fileInfo.isStubFile) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeCheckOnly().format({ name }), node);
+            }
+        }
+    }
+    function enforceClassTypeVarScope(node, type) {
+        const scopeId = type.priv.freeTypeVar?.priv.scopeId ?? type.priv.scopeId;
+        if (!scopeId) {
+            return true;
+        }
+        const enclosingClass = ParseTreeUtils.getEnclosingClass(node);
+        if (enclosingClass) {
+            const liveTypeVarScopeIds = getTypeVarScopesForNode(enclosingClass);
+            if (!liveTypeVarScopeIds.includes(scopeId)) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarInvalidForMemberVariable().format({
+                    name: types_1.TypeVarType.getReadableName(type),
+                }), node);
+                return false;
+            }
+        }
+        return true;
+    }
+    function adjustTypeArgsForTypeVarTuple(typeArgs, typeParams, errorNode) {
+        const variadicIndex = typeParams.findIndex((param) => (0, types_1.isTypeVarTuple)(param));
+        // Is there a *tuple[T, ...] somewhere in the type arguments that we can expand if needed?
+        let srcUnboundedTupleType;
+        const findUnboundedTupleIndex = (startArgIndex) => {
+            return typeArgs.findIndex((arg, index) => {
+                if (index < startArgIndex) {
+                    return false;
+                }
+                if ((0, types_1.isUnpackedClass)(arg.type) &&
+                    arg.type.priv.tupleTypeArgs &&
+                    arg.type.priv.tupleTypeArgs.length === 1 &&
+                    arg.type.priv.tupleTypeArgs[0].isUnbounded) {
+                    srcUnboundedTupleType = arg.type.priv.tupleTypeArgs[0].type;
+                    return true;
+                }
+                return false;
+            });
+        };
+        let srcUnboundedTupleIndex = findUnboundedTupleIndex(0);
+        // Allow only one unpacked tuple that maps to a TypeVarTuple.
+        if (srcUnboundedTupleIndex >= 0) {
+            const secondUnboundedTupleIndex = findUnboundedTupleIndex(srcUnboundedTupleIndex + 1);
+            if (secondUnboundedTupleIndex >= 0) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.variadicTypeArgsTooMany(), typeArgs[secondUnboundedTupleIndex].node);
+            }
+        }
+        if (srcUnboundedTupleType &&
+            srcUnboundedTupleIndex >= 0 &&
+            variadicIndex >= 0 &&
+            typeArgs.length < typeParams.length) {
+            // "Smear" the tuple type across type argument slots prior to the TypeVarTuple.
+            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 TypeVarTuple.
+            while (typeArgs.length < typeParams.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 somewhere in the list?
+        if (variadicIndex >= 0) {
+            const variadicTypeVar = typeParams[variadicIndex];
+            // If the type param list ends with a ParamSpec with a default value,
+            // we can ignore it for purposes of finding type args that map to the
+            // TypeVarTuple.
+            let typeParamCount = typeParams.length;
+            while (typeParamCount > 0) {
+                const lastTypeParam = typeParams[typeParamCount - 1];
+                if (!(0, types_1.isParamSpec)(lastTypeParam) || !lastTypeParam.shared.isDefaultExplicit) {
+                    break;
+                }
+                typeParamCount--;
+            }
+            if (variadicIndex < typeArgs.length) {
+                // If there are typeArg lists at the end, these should map to ParamSpecs rather
+                // than the TypeVarTuple, so exclude them.
+                let variadicEndIndex = variadicIndex + 1 + typeArgs.length - typeParamCount;
+                while (variadicEndIndex > variadicIndex) {
+                    if (!typeArgs[variadicEndIndex - 1].typeList) {
+                        break;
+                    }
+                    variadicEndIndex--;
+                }
+                const variadicTypeResults = typeArgs.slice(variadicIndex, variadicEndIndex);
+                // If the type args consist of a lone TypeVarTuple, don't wrap it in a tuple.
+                if (variadicTypeResults.length === 1 && (0, types_1.isTypeVarTuple)(variadicTypeResults[0].type)) {
+                    validateTypeVarTupleIsUnpacked(variadicTypeResults[0].type, variadicTypeResults[0].node);
+                }
+                else {
+                    variadicTypeResults.forEach((arg, index) => {
+                        validateTypeArg(arg, {
+                            allowEmptyTuple: index === 0,
+                            allowTypeVarTuple: true,
+                            allowUnpackedTuples: true,
+                        });
+                    });
+                    const variadicTypes = [];
+                    if (variadicTypeResults.length !== 1 || !variadicTypeResults[0].isEmptyTupleShorthand) {
+                        variadicTypeResults.forEach((typeResult) => {
+                            if ((0, types_1.isUnpackedClass)(typeResult.type) && typeResult.type.priv.tupleTypeArgs) {
+                                (0, collectionUtils_1.appendArray)(variadicTypes, typeResult.type.priv.tupleTypeArgs);
+                            }
+                            else {
+                                variadicTypes.push({
+                                    type: (0, typeUtils_1.convertToInstance)(typeResult.type),
+                                    isUnbounded: false,
+                                });
+                            }
+                        });
+                    }
+                    const tupleObject = (0, tuples_1.makeTupleObject)(context, variadicTypes, /* isUnpacked */ true);
+                    typeArgs = [
+                        ...typeArgs.slice(0, variadicIndex),
+                        { node: typeArgs[variadicIndex].node, type: tupleObject },
+                        ...typeArgs.slice(variadicEndIndex, typeArgs.length),
+                    ];
+                }
+            }
+            else if (!variadicTypeVar.shared.isDefaultExplicit) {
+                // Add an empty tuple that maps to the TypeVarTuple type parameter.
+                typeArgs.push({
+                    node: errorNode,
+                    type: (0, tuples_1.makeTupleObject)(context, [], /* isUnpacked */ true),
+                });
+            }
+        }
+        return typeArgs;
+    }
+    function validateTypeVarTupleIsUnpacked(type, node) {
+        if (!type.priv.isUnpacked) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unpackedTypeVarTupleExpected().format({
+                name1: type.shared.name,
+                name2: type.shared.name,
+            }), node);
+            return false;
+        }
+        return true;
+    }
+    function validateTypeArg(argResult, options) {
+        if (argResult.typeList) {
+            if (!options?.allowTypeArgList) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgListNotAllowed(), argResult.node);
+                return false;
+            }
+            else {
+                argResult.typeList.forEach((typeArg) => {
+                    validateTypeArg(typeArg);
+                });
+            }
+        }
+        if ((0, typeUtils_1.isEllipsisType)(argResult.type)) {
+            if (!options?.allowTypeArgList) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.ellipsisContext(), argResult.node);
+                return false;
+            }
+        }
+        if ((0, types_1.isModule)(argResult.type)) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.moduleAsType(), argResult.node);
+            return false;
+        }
+        if ((0, types_1.isParamSpec)(argResult.type)) {
+            if (!options?.allowParamSpec) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.paramSpecContext(), argResult.node);
+                return false;
+            }
+        }
+        if ((0, types_1.isTypeVarTuple)(argResult.type) && !argResult.type.priv.isInUnion) {
+            if (!options?.allowTypeVarTuple) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeVarTupleContext(), argResult.node);
+                return false;
+            }
+            else {
+                validateTypeVarTupleIsUnpacked(argResult.type, argResult.node);
+            }
+        }
+        if (!options?.allowEmptyTuple && argResult.isEmptyTupleShorthand) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.zeroLengthTupleNotAllowed(), argResult.node);
+            return false;
+        }
+        if ((0, types_1.isUnpackedClass)(argResult.type)) {
+            if (!options?.allowUnpackedTuples) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unpackedArgInTypeArgument(), argResult.node);
+                return false;
+            }
+        }
+        return true;
+    }
+    function createCallableType(classType, typeArgs, errorNode) {
+        let functionType = types_1.FunctionType.createInstantiable(0 /* FunctionTypeFlags.None */);
+        let paramSpec;
+        let isValidTypeForm = true;
+        types_1.TypeBase.setSpecialForm(functionType, types_1.ClassType.cloneAsInstance(classType));
+        functionType.shared.declaredReturnType = types_1.UnknownType.create();
+        functionType.shared.typeVarScopeId = getScopeIdForNode(errorNode);
+        if (typeArgs && typeArgs.length > 0) {
+            functionType.priv.isCallableWithTypeArgs = true;
+            if (typeArgs[0].typeList) {
+                const typeList = typeArgs[0].typeList;
+                let sawUnpacked = false;
+                let reportedUnpackedError = false;
+                const noteSawUnpacked = (entry) => {
+                    // Make sure we have at most one unpacked TypeVarTuple.
+                    if (sawUnpacked) {
+                        if (!reportedUnpackedError) {
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.variadicTypeArgsTooMany(), entry.node);
+                            reportedUnpackedError = true;
+                            isValidTypeForm = false;
+                        }
+                    }
+                    sawUnpacked = true;
+                };
+                typeList.forEach((entry, index) => {
+                    let entryType = entry.type;
+                    let paramCategory = 0 /* ParamCategory.Simple */;
+                    const paramName = `__p${index.toString()}`;
+                    if ((0, types_1.isTypeVarTuple)(entryType)) {
+                        validateTypeVarTupleIsUnpacked(entryType, entry.node);
+                        paramCategory = 1 /* ParamCategory.ArgsList */;
+                        noteSawUnpacked(entry);
+                    }
+                    else if (validateTypeArg(entry, { allowUnpackedTuples: true })) {
+                        if ((0, types_1.isUnpackedClass)(entryType)) {
+                            paramCategory = 1 /* ParamCategory.ArgsList */;
+                            if (entryType.priv.tupleTypeArgs?.some((typeArg) => (0, types_1.isTypeVarTuple)(typeArg.type) || typeArg.isUnbounded)) {
+                                noteSawUnpacked(entry);
+                            }
+                        }
+                    }
+                    else {
+                        entryType = types_1.UnknownType.create();
+                    }
+                    types_1.FunctionType.addParam(functionType, types_1.FunctionParam.create(paramCategory, (0, typeUtils_1.convertToInstance)(entryType), types_1.FunctionParamFlags.NameSynthesized | types_1.FunctionParamFlags.TypeDeclared, paramName));
+                });
+                if (typeList.length > 0) {
+                    types_1.FunctionType.addPositionOnlyParamSeparator(functionType);
+                }
+            }
+            else if ((0, typeUtils_1.isEllipsisType)(typeArgs[0].type)) {
+                types_1.FunctionType.addDefaultParams(functionType);
+                functionType.shared.flags |= 32768 /* FunctionTypeFlags.GradualCallableForm */;
+            }
+            else if ((0, types_1.isParamSpec)(typeArgs[0].type)) {
+                paramSpec = typeArgs[0].type;
+            }
+            else {
+                if ((0, types_1.isInstantiableClass)(typeArgs[0].type) && types_1.ClassType.isBuiltIn(typeArgs[0].type, 'Concatenate')) {
+                    const concatTypeArgs = typeArgs[0].type.priv.typeArgs;
+                    if (concatTypeArgs && concatTypeArgs.length > 0) {
+                        concatTypeArgs.forEach((typeArg, index) => {
+                            if (index === concatTypeArgs.length - 1) {
+                                types_1.FunctionType.addPositionOnlyParamSeparator(functionType);
+                                if ((0, types_1.isParamSpec)(typeArg)) {
+                                    paramSpec = typeArg;
+                                }
+                                else if ((0, typeUtils_1.isEllipsisType)(typeArg)) {
+                                    types_1.FunctionType.addDefaultParams(functionType);
+                                    functionType.shared.flags |= 32768 /* FunctionTypeFlags.GradualCallableForm */;
+                                }
+                            }
+                            else {
+                                types_1.FunctionType.addParam(functionType, types_1.FunctionParam.create(0 /* ParamCategory.Simple */, typeArg, types_1.FunctionParamFlags.NameSynthesized | types_1.FunctionParamFlags.TypeDeclared, `__p${index}`));
+                            }
+                        });
+                    }
+                }
+                else {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.callableFirstArg(), typeArgs[0].node);
+                    isValidTypeForm = false;
+                }
+            }
+            if (typeArgs.length > 1) {
+                let typeArg1Type = typeArgs[1].type;
+                if (!validateTypeArg(typeArgs[1])) {
+                    typeArg1Type = types_1.UnknownType.create();
+                }
+                functionType.shared.declaredReturnType = (0, typeUtils_1.convertToInstance)(typeArg1Type);
+            }
+            else {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportMissingTypeArgument, localize_1.LocMessage.callableSecondArg(), errorNode);
+                functionType.shared.declaredReturnType = types_1.UnknownType.create();
+                isValidTypeForm = false;
+            }
+            if (typeArgs.length > 2) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.callableExtraArgs(), typeArgs[2].node);
+                isValidTypeForm = false;
+            }
+        }
+        else {
+            types_1.FunctionType.addDefaultParams(functionType, /* useUnknown */ true);
+            functionType.shared.flags |= 32768 /* FunctionTypeFlags.GradualCallableForm */;
+            if (typeArgs && typeArgs.length === 0) {
+                isValidTypeForm = false;
+            }
+        }
+        if (paramSpec) {
+            types_1.FunctionType.addParamSpecVariadics(functionType, (0, typeUtils_1.convertToInstance)(paramSpec));
+        }
+        if (isValidTypeForm) {
+            functionType = types_1.TypeBase.cloneWithTypeForm(functionType, (0, typeUtils_1.convertToInstance)(functionType));
+        }
+        return functionType;
+    }
+    function createOptionalType(classType, errorNode, typeArgs, flags) {
+        if (!typeArgs) {
+            // If no type arguments are provided, the resulting type
+            // depends on whether we're evaluating a type annotation or
+            // we're in some other context.
+            if ((flags & (256 /* EvalFlags.TypeExpression */ | 1073741824 /* EvalFlags.TypeFormArg */)) !== 0) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.optionalExtraArgs(), errorNode);
+                return types_1.UnknownType.create();
+            }
+            return classType;
+        }
+        if (typeArgs.length !== 1) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.optionalExtraArgs(), errorNode);
+            return types_1.UnknownType.create();
+        }
+        let typeArg0Type = typeArgs[0].type;
+        if (!validateTypeArg(typeArgs[0])) {
+            typeArg0Type = types_1.UnknownType.create();
+        }
+        let optionalType = (0, types_1.combineTypes)([typeArg0Type, context.prefetched?.noneTypeClass ?? types_1.UnknownType.create()]);
+        if (context.prefetched?.unionTypeClass && (0, types_1.isInstantiableClass)(context.prefetched.unionTypeClass)) {
+            optionalType = types_1.TypeBase.cloneAsSpecialForm(optionalType, types_1.ClassType.cloneAsInstance(context.prefetched.unionTypeClass));
+        }
+        if (typeArg0Type.props?.typeForm) {
+            const typeFormType = (0, types_1.combineTypes)([
+                typeArg0Type.props.typeForm,
+                (0, typeUtils_1.convertToInstance)(context.prefetched?.noneTypeClass ?? types_1.UnknownType.create()),
+            ]);
+            optionalType = types_1.TypeBase.cloneWithTypeForm(optionalType, typeFormType);
+        }
+        return optionalType;
+    }
+    function createClassVarType(classType, errorNode, typeArgs, flags) {
+        if (flags & (131072 /* EvalFlags.NoClassVar */ | 1073741824 /* EvalFlags.TypeFormArg */)) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.classVarNotAllowed(), errorNode);
+            return (flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0 ? types_1.UnknownType.create() : types_1.AnyType.create();
+        }
+        if (!typeArgs) {
+            return classType;
+        }
+        else if (typeArgs.length === 0) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.classVarFirstArgMissing(), errorNode);
+            return types_1.UnknownType.create();
+        }
+        else if (typeArgs.length > 1) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.classVarTooManyArgs(), typeArgs[1].node);
+            return types_1.UnknownType.create();
+        }
+        const type = typeArgs[0].type;
+        // A ClassVar should not allow TypeVars or generic types parameterized
+        // by TypeVars.
+        if ((0, typeUtils_1.requiresSpecialization)(type, { ignorePseudoGeneric: true, ignoreSelf: true })) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.classVarWithTypeVar(), typeArgs[0].node ?? errorNode);
+        }
+        return type;
+    }
+    function createTypeFormType(classType, errorNode, typeArgs) {
+        if (!typeArgs) {
+            const specializedType = types_1.ClassType.specialize(classType, [types_1.AnyType.create()]);
+            return types_1.TypeBase.cloneWithTypeForm(specializedType, types_1.ClassType.cloneAsInstance(specializedType));
+        }
+        if (typeArgs.length === 0) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgsTooFew().format({
+                name: classType.priv.aliasName || classType.shared.name,
+                expected: 1,
+                received: 0,
+            }), errorNode);
+            return types_1.UnknownType.create();
+        }
+        if (typeArgs.length > 1) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgsTooMany().format({
+                name: classType.priv.aliasName || classType.shared.name,
+                expected: 1,
+                received: typeArgs.length,
+            }), typeArgs[1].node);
+            return types_1.UnknownType.create();
+        }
+        const convertedTypeArgs = typeArgs.map((typeArg) => {
+            return (0, typeUtils_1.convertToInstance)(validateTypeArg(typeArg) ? typeArg.type : types_1.UnknownType.create());
+        });
+        let resultType = types_1.ClassType.specialize(classType, convertedTypeArgs);
+        resultType = types_1.TypeBase.cloneWithTypeForm(resultType, (0, typeUtils_1.convertToInstance)(resultType));
+        return resultType;
+    }
+    function createTypeGuardType(classType, errorNode, typeArgs, flags) {
+        // If no type arguments are provided, the resulting type
+        // depends on whether we're evaluating a type annotation or
+        // we're in some other context.
+        if (!typeArgs) {
+            if ((flags & (256 /* EvalFlags.TypeExpression */ | 1073741824 /* EvalFlags.TypeFormArg */)) !== 0) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeGuardArgCount(), errorNode);
+            }
+            return (flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0 ? types_1.UnknownType.create() : classType;
+        }
+        else if (typeArgs.length !== 1) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeGuardArgCount(), errorNode);
+            return types_1.UnknownType.create();
+        }
+        const convertedTypeArgs = typeArgs.map((typeArg) => {
+            return (0, typeUtils_1.convertToInstance)(validateTypeArg(typeArg) ? typeArg.type : types_1.UnknownType.create());
+        });
+        let resultType = types_1.ClassType.specialize(classType, convertedTypeArgs);
+        resultType = types_1.TypeBase.cloneWithTypeForm(resultType, (0, typeUtils_1.convertToInstance)(resultType));
+        return resultType;
+    }
+    function createRequiredOrReadOnlyType(classType, errorNode, typeArgs, flags) {
+        // If no type arguments are provided, the resulting type
+        // depends on whether we're evaluating a type annotation or
+        // we're in some other context.
+        const typeExpressionFlags = 256 /* EvalFlags.TypeExpression */ | 1073741824 /* EvalFlags.TypeFormArg */;
+        if (!typeArgs && (flags & typeExpressionFlags) === 0) {
+            return { type: classType };
+        }
+        if (!typeArgs || typeArgs.length !== 1) {
+            if ((flags & typeExpressionFlags) !== 0) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, classType.shared.name === 'ReadOnly'
+                    ? localize_1.LocMessage.readOnlyArgCount()
+                    : classType.shared.name === 'Required'
+                        ? localize_1.LocMessage.requiredArgCount()
+                        : localize_1.LocMessage.notRequiredArgCount(), errorNode);
+            }
+            return { type: (flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0 ? types_1.UnknownType.create() : classType };
+        }
+        const typeArgType = typeArgs[0].type;
+        // Make sure this is used only in a dataclass.
+        const containingClassNode = ParseTreeUtils.getEnclosingClass(errorNode, /* stopAtFunction */ true);
+        const classTypeInfo = containingClassNode ? getTypeOfClass(containingClassNode) : undefined;
+        let isUsageLegal = false;
+        if (classTypeInfo &&
+            (0, types_1.isInstantiableClass)(classTypeInfo.classType) &&
+            types_1.ClassType.isTypedDictClass(classTypeInfo.classType)) {
+            // The only legal usage is when used in a type annotation statement.
+            if (ParseTreeUtils.isNodeContainedWithinNodeType(errorNode, 54 /* ParseNodeType.TypeAnnotation */)) {
+                isUsageLegal = true;
+            }
+        }
+        let isReadOnly = typeArgs[0].isReadOnly;
+        let isRequired = typeArgs[0].isRequired;
+        let isNotRequired = typeArgs[0].isNotRequired;
+        if (classType.shared.name === 'ReadOnly') {
+            if ((flags & 2097152 /* EvalFlags.AllowReadOnly */) !== 0) {
+                isUsageLegal = true;
+            }
+            // Nested ReadOnly are not allowed.
+            if (typeArgs[0].isReadOnly) {
+                isUsageLegal = false;
+            }
+            isReadOnly = true;
+        }
+        else {
+            if ((flags & 1048576 /* EvalFlags.AllowRequired */) !== 0) {
+                isUsageLegal = true;
+            }
+            // Nested Required/NotRequired are not allowed.
+            if (typeArgs[0].isRequired || typeArgs[0].isNotRequired) {
+                isUsageLegal = false;
+            }
+            isRequired = classType.shared.name === 'Required';
+            isNotRequired = classType.shared.name === 'NotRequired';
+        }
+        if (!isUsageLegal) {
+            if ((flags & typeExpressionFlags) !== 0) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, classType.shared.name === 'ReadOnly'
+                    ? localize_1.LocMessage.readOnlyNotInTypedDict()
+                    : classType.shared.name === 'Required'
+                        ? localize_1.LocMessage.requiredNotInTypedDict()
+                        : localize_1.LocMessage.notRequiredNotInTypedDict(), errorNode);
+            }
+            return { type: (flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0 ? types_1.UnknownType.create() : classType };
+        }
+        return { type: typeArgType, isReadOnly, isRequired, isNotRequired };
+    }
+    function createUnpackType(classType, errorNode, typeArgs, flags) {
+        if (!typeArgs || typeArgs.length !== 1) {
+            if ((flags & (256 /* EvalFlags.TypeExpression */ | 1073741824 /* EvalFlags.TypeFormArg */)) !== 0) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unpackArgCount(), errorNode);
+            }
+            return (flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0 ? types_1.UnknownType.create() : classType;
+        }
+        const typeArgType = typeArgs[0].type;
+        if ((flags & 4194304 /* EvalFlags.AllowUnpackedTuple */) !== 0) {
+            const unpackedType = applyUnpackToTupleLike(typeArgType);
+            if (unpackedType) {
+                return unpackedType;
+            }
+            if ((flags & (256 /* EvalFlags.TypeExpression */ | 1073741824 /* EvalFlags.TypeFormArg */)) === 0) {
+                return classType;
+            }
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unpackExpectedTypeVarTuple(), errorNode);
+            return types_1.UnknownType.create();
+        }
+        if ((flags & 8388608 /* EvalFlags.AllowUnpackedTypedDict */) !== 0) {
+            if ((0, types_1.isInstantiableClass)(typeArgType) && types_1.ClassType.isTypedDictClass(typeArgType)) {
+                return types_1.ClassType.cloneForUnpacked(typeArgType);
+            }
+            if ((flags & 256 /* EvalFlags.TypeExpression */) === 0) {
+                return classType;
+            }
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unpackExpectedTypedDict(), errorNode);
+            return types_1.UnknownType.create();
+        }
+        if ((flags & (256 /* EvalFlags.TypeExpression */ | 1073741824 /* EvalFlags.TypeFormArg */)) === 0) {
+            return classType;
+        }
+        if ((flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0) {
+            if ((0, types_1.isUnknown)(typeArgType)) {
+                return typeArgType;
+            }
+            if ((0, types_1.isTypeVar)(typeArgType) && !typeArgType.priv.scopeId) {
+                return types_1.UnknownType.create();
+            }
+        }
+        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unpackNotAllowed(), errorNode);
+        return types_1.UnknownType.create();
+    }
+    function createFinalType(classType, errorNode, typeArgs, flags) {
+        if (flags & (16 /* EvalFlags.NoFinal */ | 1073741824 /* EvalFlags.TypeFormArg */)) {
+            if ((flags & (256 /* EvalFlags.TypeExpression */ | 1073741824 /* EvalFlags.TypeFormArg */)) !== 0) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.finalContext(), errorNode);
+            }
+            return (flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0 ? types_1.UnknownType.create() : classType;
+        }
+        if ((flags & 256 /* EvalFlags.TypeExpression */) === 0 || !typeArgs || typeArgs.length === 0) {
+            return classType;
+        }
+        if (typeArgs.length > 1) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.finalTooManyArgs(), errorNode);
+        }
+        return types_1.TypeBase.cloneAsSpecialForm(typeArgs[0].type, classType);
+    }
+    function createConcatenateType(classType, errorNode, typeArgs, flags) {
+        if ((flags & 134217728 /* EvalFlags.AllowConcatenate */) === 0) {
+            if ((flags & (256 /* EvalFlags.TypeExpression */ | 1073741824 /* EvalFlags.TypeFormArg */)) !== 0) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.concatenateContext(), errorNode);
+            }
+            return (flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0 ? types_1.UnknownType.create() : classType;
+        }
+        if (!typeArgs || typeArgs.length === 0) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.concatenateTypeArgsMissing(), errorNode);
+        }
+        else {
+            typeArgs.forEach((typeArg, index) => {
+                if (index === typeArgs.length - 1) {
+                    if (!(0, types_1.isParamSpec)(typeArg.type) && !(0, typeUtils_1.isEllipsisType)(typeArg.type)) {
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.concatenateParamSpecMissing(), typeArg.node);
+                    }
+                }
+                else {
+                    if ((0, types_1.isParamSpec)(typeArg.type)) {
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.paramSpecContext(), typeArg.node);
+                    }
+                    else if ((0, types_1.isUnpackedTypeVarTuple)(typeArg.type)) {
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeVarTupleContext(), typeArg.node);
+                    }
+                    else if ((0, types_1.isUnpackedClass)(typeArg.type)) {
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unpackedArgInTypeArgument(), typeArg.node);
+                    }
+                }
+            });
+        }
+        return createSpecialType(classType, typeArgs, /* paramLimit */ undefined, /* allowParamSpec */ true);
+    }
+    function createAnnotatedType(classType, errorNode, typeArgs, flags) {
+        let type;
+        const typeExprFlags = 256 /* EvalFlags.TypeExpression */ | 33554432 /* EvalFlags.NoConvertSpecialForm */;
+        if ((flags & typeExprFlags) === 0) {
+            type = types_1.ClassType.cloneAsInstance(classType);
+            if (typeArgs && typeArgs.length >= 1 && typeArgs[0].type.props?.typeForm) {
+                type = types_1.TypeBase.cloneWithTypeForm(type, typeArgs[0].type.props.typeForm);
+            }
+            return { type };
+        }
+        if (typeArgs && typeArgs.length > 0) {
+            type = typeArgs[0].type;
+            if (typeArgs.length < 2) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.annotatedTypeArgMissing(), errorNode);
+            }
+            else {
+                type = validateAnnotatedMetadata(errorNode, typeArgs[0].type, typeArgs.slice(1));
+            }
+        }
+        if (!type || !typeArgs || typeArgs.length === 0) {
+            return { type: types_1.AnyType.create() };
+        }
+        if (typeArgs[0].typeList) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgListNotAllowed(), typeArgs[0].node);
+        }
+        return {
+            type: types_1.TypeBase.cloneAsSpecialForm(type, types_1.ClassType.cloneAsInstance(classType)),
+            isReadOnly: typeArgs[0].isReadOnly,
+            isRequired: typeArgs[0].isRequired,
+            isNotRequired: typeArgs[0].isNotRequired,
+        };
+    }
+    function validateAnnotatedMetadata(errorNode, baseType, metaArgs) {
+        for (const metaArg of metaArgs) {
+            validateTypeMetadata(errorNode, baseType, metaArg);
+        }
+        return baseType;
+    }
+    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) {
+                typeArgs = [];
+            }
+            else {
+                let sawUnpacked = false;
+                const noteSawUnpacked = (typeArg) => {
+                    if (sawUnpacked) {
+                        if (!reportedUnpackedError) {
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.variadicTypeArgsTooMany(), typeArg.node);
+                            reportedUnpackedError = true;
+                        }
+                    }
+                    sawUnpacked = true;
+                };
+                let reportedUnpackedError = false;
+                // Verify that we didn't receive any inappropriate types.
+                typeArgs.forEach((typeArg, index) => {
+                    (0, debug_1.assert)(typeArgs !== undefined);
+                    if ((0, typeUtils_1.isEllipsisType)(typeArg.type)) {
+                        if (!isTupleTypeParam) {
+                            if (!allowParamSpec) {
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.ellipsisContext(), typeArg.node);
+                            }
+                        }
+                        else if (typeArgs.length !== 2 || index !== 1) {
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.ellipsisSecondArg(), typeArg.node);
+                        }
+                        else {
+                            if ((0, types_1.isTypeVarTuple)(typeArgs[0].type) && !typeArgs[0].type.priv.isInUnion) {
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeVarTupleContext(), typeArgs[0].node);
+                            }
+                            else if ((0, types_1.isUnpackedClass)(typeArgs[0].type)) {
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.ellipsisAfterUnpacked(), typeArg.node);
+                            }
+                        }
+                    }
+                    else if ((0, types_1.isParamSpec)(typeArg.type) && allowParamSpec) {
+                        // Nothing to do - this is allowed.
+                    }
+                    else if (paramLimit === undefined && (0, types_1.isTypeVarTuple)(typeArg.type)) {
+                        if (!typeArg.type.priv.isInUnion) {
+                            noteSawUnpacked(typeArg);
+                        }
+                        validateTypeVarTupleIsUnpacked(typeArg.type, typeArg.node);
+                    }
+                    else if (paramLimit === undefined && (0, types_1.isUnpackedClass)(typeArg.type)) {
+                        if ((0, typeUtils_1.isUnboundedTupleClass)(typeArg.type)) {
+                            noteSawUnpacked(typeArg);
+                        }
+                        validateTypeArg(typeArg, { allowUnpackedTuples: true });
+                    }
+                    else {
+                        validateTypeArg(typeArg);
+                    }
+                });
+            }
+        }
+        let typeArgTypes = typeArgs ? typeArgs.map((t) => (0, typeUtils_1.convertToInstance)(t.type)) : [];
+        // Make sure the argument list count is correct.
+        if (paramLimit !== undefined) {
+            if (typeArgs && typeArgTypes.length > paramLimit) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgsTooMany().format({
+                    name: classType.priv.aliasName || classType.shared.name,
+                    expected: paramLimit,
+                    received: typeArgTypes.length,
+                }), typeArgs[paramLimit].node);
+                typeArgTypes = typeArgTypes.slice(0, paramLimit);
+            }
+            else if (typeArgTypes.length < paramLimit) {
+                // Fill up the remainder of the slots with unknown types.
+                while (typeArgTypes.length < paramLimit) {
+                    typeArgTypes.push(types_1.UnknownType.create());
+                }
+            }
+        }
+        // Handle tuple type params as a special case.
+        let returnType;
+        if (isTupleTypeParam) {
+            const tupleTypeArgTypes = [];
+            // If no type args are provided and it's a tuple, default to [Unknown, ...].
+            if (!typeArgs) {
+                tupleTypeArgTypes.push({ type: types_1.UnknownType.create(), isUnbounded: true });
+            }
+            else {
+                typeArgs.forEach((typeArg, index) => {
+                    if (index === 1 && (0, typeUtils_1.isEllipsisType)(typeArgTypes[index])) {
+                        if (tupleTypeArgTypes.length === 1 && !tupleTypeArgTypes[0].isUnbounded) {
+                            tupleTypeArgTypes[0] = { type: tupleTypeArgTypes[0].type, isUnbounded: true };
+                        }
+                    }
+                    else if ((0, types_1.isUnpackedClass)(typeArg.type) && typeArg.type.priv.tupleTypeArgs) {
+                        (0, collectionUtils_1.appendArray)(tupleTypeArgTypes, typeArg.type.priv.tupleTypeArgs);
+                    }
+                    else {
+                        tupleTypeArgTypes.push({ type: typeArgTypes[index], isUnbounded: false });
+                    }
+                });
+            }
+            returnType = (0, typeUtils_1.specializeTupleClass)(classType, tupleTypeArgTypes, typeArgs !== undefined);
+        }
+        else {
+            returnType = types_1.ClassType.specialize(classType, typeArgTypes, typeArgs !== undefined);
+        }
+        if (isSpecialForm) {
+            returnType = types_1.TypeBase.cloneAsSpecialForm(returnType, classType);
+        }
+        return returnType;
+    }
+    function createUnionType(classType, errorNode, typeArgs, flags) {
+        const fileInfo = nodeInfo.getFileInfo(errorNode);
+        const types = [];
+        let allowSingleTypeArg = false;
+        let isValidTypeForm = true;
+        if (!typeArgs) {
+            // If no type arguments are provided, the resulting type
+            // depends on whether we're evaluating a type annotation or
+            // we're in some other context.
+            if ((flags & (256 /* EvalFlags.TypeExpression */ | 1073741824 /* EvalFlags.TypeFormArg */)) !== 0) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unionTypeArgCount(), errorNode);
+                return types_1.NeverType.createNever();
+            }
+            return classType;
+        }
+        for (const typeArg of typeArgs) {
+            let typeArgType = typeArg.type;
+            // This is an experimental feature because Unions of unpacked TypeVarTuples are not officially supported.
+            if (!validateTypeArg(typeArg, {
+                allowTypeVarTuple: fileInfo.diagnosticRuleSet.enableExperimentalFeatures,
+            })) {
+                typeArgType = types_1.UnknownType.create();
+            }
+            if ((0, types_1.isTypeVar)(typeArgType) && (0, types_1.isUnpackedTypeVarTuple)(typeArgType)) {
+                // This is an experimental feature because Unions of unpacked TypeVarTuples are not officially supported.
+                if (fileInfo.diagnosticRuleSet.enableExperimentalFeatures) {
+                    // If this is an unpacked TypeVar, note that it is in a union so we can
+                    // differentiate between Unpack[Vs] and Union[Unpack[Vs]].
+                    typeArgType = types_1.TypeVarType.cloneForUnpacked(typeArgType, /* isInUnion */ true);
+                    allowSingleTypeArg = true;
+                }
+                else {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unionUnpackedTypeVarTuple(), errorNode);
+                    typeArgType = types_1.UnknownType.create();
+                    isValidTypeForm = false;
+                }
+            }
+            types.push(typeArgType);
+        }
+        // Validate that we received at least two type arguments. One type argument
+        // is allowed if it's an unpacked TypeVarTuple or tuple. None is also allowed
+        // since it is used to define NoReturn in typeshed stubs). No type arguments,
+        // as in "Union[()]", is a runtime error.
+        if (types.length === 0 || (types.length === 1 && !allowSingleTypeArg && !(0, typeUtils_1.isNoneInstance)(types[0]))) {
+            if ((flags & (256 /* EvalFlags.TypeExpression */ | 1073741824 /* EvalFlags.TypeFormArg */)) !== 0) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.unionTypeArgCount(), errorNode);
+            }
+            isValidTypeForm = false;
+        }
+        let unionType = (0, types_1.combineTypes)(types, { skipElideRedundantLiterals: true });
+        if (context.prefetched?.unionTypeClass && (0, types_1.isInstantiableClass)(context.prefetched.unionTypeClass)) {
+            unionType = types_1.TypeBase.cloneAsSpecialForm(unionType, types_1.ClassType.cloneAsInstance(context.prefetched.unionTypeClass));
+        }
+        if (!isValidTypeForm || types.some((t) => !t.props?.typeForm)) {
+            if (unionType.props?.typeForm) {
+                unionType = types_1.TypeBase.cloneWithTypeForm(unionType, undefined);
+            }
+        }
+        else {
+            const typeFormType = (0, types_1.combineTypes)(types.map((t) => t.props.typeForm));
+            unionType = types_1.TypeBase.cloneWithTypeForm(unionType, typeFormType);
+        }
+        return unionType;
+    }
+    function createGenericType(classType, errorNode, typeArgs, flags) {
+        if (!typeArgs) {
+            // If no type arguments are provided, the resulting type
+            // depends on whether we're evaluating a type annotation or
+            // we're in some other context.
+            if ((flags & (256 /* EvalFlags.TypeExpression */ | 262144 /* EvalFlags.NoNakedGeneric */ | 1073741824 /* EvalFlags.TypeFormArg */)) !== 0) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.genericTypeArgMissing(), errorNode);
+            }
+            return (flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0 ? types_1.UnknownType.create() : classType;
+        }
+        if ((flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.genericNotAllowed(), errorNode);
+            return types_1.UnknownType.create();
+        }
+        const uniqueTypeVars = [];
+        if (typeArgs) {
+            // Make sure there's at least one type arg.
+            if (typeArgs.length === 0) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.genericTypeArgMissing(), errorNode);
+            }
+            // Make sure that all of the type args are typeVars and are unique.
+            typeArgs.forEach((typeArg) => {
+                if (!(0, types_1.isTypeVar)(typeArg.type)) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.genericTypeArgTypeVar(), typeArg.node);
+                }
+                else {
+                    if (uniqueTypeVars.some((t) => (0, types_1.isTypeSame)(t, typeArg.type))) {
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.genericTypeArgUnique(), typeArg.node);
+                    }
+                    uniqueTypeVars.push(typeArg.type);
+                }
+            });
+        }
+        return createSpecialType(classType, typeArgs, /* paramLimit */ undefined, /* allowParamSpec */ true);
+    }
+    function transformTypeForTypeAlias(type, errorNode, typeAliasPlaceholder, isPep695TypeVarType, typeParamNodes) {
+        // If this is a recursive type alias that hasn't yet been fully resolved
+        // (i.e. there is no boundType associated with it), don't apply the transform.
+        if ((0, typeUtils_1.isTypeAliasPlaceholder)(type)) {
+            return type;
+        }
+        const sharedInfo = typeAliasPlaceholder.shared.recursiveAlias;
+        (0, debug_1.assert)(sharedInfo !== undefined);
+        let typeParams = sharedInfo.typeParams;
+        if (!typeParams) {
+            // Determine if there are any generic type parameters associated
+            // with this type alias.
+            typeParams = [];
+            (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParams, (0, typeUtils_1.getTypeVarArgsRecursive)(type));
+            // Don't include any synthesized type variables.
+            typeParams = typeParams.filter((typeVar) => !typeVar.shared.isSynthesized);
+        }
+        // Convert all type variables to instances.
+        typeParams = typeParams.map((typeVar) => {
+            if (types_1.TypeBase.isInstance(typeVar)) {
+                return typeVar;
+            }
+            return (0, typeUtils_1.convertToInstance)(typeVar);
+        });
+        // See if the type alias includes a TypeVarTuple followed by a TypeVar
+        // with a default value. This isn't allowed.
+        const firstTypeVarTupleIndex = typeParams.findIndex((typeVar) => (0, types_1.isTypeVarTuple)(typeVar));
+        if (firstTypeVarTupleIndex >= 0) {
+            const typeVarWithDefaultIndex = typeParams.findIndex((typeVar, index) => index > firstTypeVarTupleIndex && !(0, types_1.isParamSpec)(typeVar) && typeVar.shared.isDefaultExplicit);
+            if (typeVarWithDefaultIndex >= 0) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarWithDefaultFollowsVariadic().format({
+                    typeVarName: typeParams[typeVarWithDefaultIndex].shared.name,
+                    variadicName: typeParams[firstTypeVarTupleIndex].shared.name,
+                }), typeParamNodes ? typeParamNodes[typeVarWithDefaultIndex].d.name : errorNode);
+            }
+        }
+        // Validate the default types for all type parameters.
+        typeParams.forEach((typeParam, index) => {
+            (0, debug_1.assert)(typeParams !== undefined);
+            let bestErrorNode = errorNode;
+            if (typeParamNodes && index < typeParamNodes.length) {
+                bestErrorNode = typeParamNodes[index].d.defaultExpr ?? typeParamNodes[index].d.name;
+            }
+            validateTypeParamDefault(bestErrorNode, typeParam, typeParams.slice(0, index), sharedInfo.typeVarScopeId);
+        });
+        // Verify that we have at most one TypeVarTuple.
+        const variadics = typeParams.filter((param) => (0, types_1.isTypeVarTuple)(param));
+        if (variadics.length > 1) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.variadicTypeParamTooManyAlias().format({
+                names: variadics.map((v) => `"${v.shared.name}"`).join(', '),
+            }), errorNode);
+        }
+        if (!sharedInfo.isTypeAliasType && !isPep695TypeVarType) {
+            const boundTypeVars = typeParams.filter((typeVar) => typeVar.priv.scopeId !== sharedInfo.typeVarScopeId &&
+                typeVar.priv.scopeType === 0 /* TypeVarScopeType.Class */);
+            if (boundTypeVars.length > 0) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.genericTypeAliasBoundTypeVar().format({
+                    names: boundTypeVars.map((t) => `${t.shared.name}`).join(', '),
+                }), errorNode);
+            }
+        }
+        if (!types_1.TypeBase.isInstantiable(type)) {
+            return type;
+        }
+        sharedInfo.typeParams = typeParams.length > 0 ? typeParams : undefined;
+        let typeAlias = types_1.TypeBase.cloneForTypeAlias(type, {
+            shared: sharedInfo,
+            typeArgs: undefined,
+        });
+        // All PEP 695 type aliases are special forms because they are
+        // TypeAliasType objects at runtime.
+        if (sharedInfo.isTypeAliasType || isPep695TypeVarType) {
+            const typeAliasTypeClass = getTypingType(errorNode, 'TypeAliasType');
+            if (typeAliasTypeClass && (0, types_1.isInstantiableClass)(typeAliasTypeClass)) {
+                typeAlias = types_1.TypeBase.cloneAsSpecialForm(typeAlias, types_1.ClassType.cloneAsInstance(typeAliasTypeClass));
+            }
+        }
+        // Delete the TypeForm info. The type alias serves as its own TypeForm info.
+        if (typeAlias.props?.typeForm) {
+            typeAlias = types_1.TypeBase.cloneWithTypeForm(typeAlias, undefined);
+        }
+        return typeAlias;
+    }
+    function validateTypeParamDefault(errorNode, typeParam, otherLiveTypeParams, scopeId) {
+        if (!typeParam.shared.isDefaultExplicit && !typeParam.shared.isSynthesized && !types_1.TypeVarType.isSelf(typeParam)) {
+            const typeVarWithDefault = otherLiveTypeParams.find((param) => param.shared.isDefaultExplicit && param.priv.scopeId === scopeId);
+            if (typeVarWithDefault) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarWithoutDefault().format({
+                    name: typeParam.shared.name,
+                    other: typeVarWithDefault.shared.name,
+                }), errorNode);
+            }
+            return;
+        }
+        const invalidTypeVars = new Set();
+        (0, typeUtils_1.validateTypeVarDefault)(typeParam, otherLiveTypeParams, invalidTypeVars);
+        // If we found one or more unapplied type variable, report an error.
+        if (invalidTypeVars.size > 0) {
+            const diag = new diagnostic_1.DiagnosticAddendum();
+            invalidTypeVars.forEach((name) => {
+                diag.addMessage(localize_1.LocAddendum.typeVarDefaultOutOfScope().format({ name }));
+            });
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarDefaultInvalidTypeVar().format({
+                name: typeParam.shared.name,
+            }) + diag.getString(), errorNode);
+        }
+    }
+    function verifyGenericTypeParams(errorNode, typeVars, genericTypeVars) {
+        const missingFromGeneric = typeVars.filter((typeVar) => {
+            return !genericTypeVars.some((genericTypeVar) => genericTypeVar.shared.name === typeVar.shared.name);
+        });
+        if (missingFromGeneric.length > 0) {
+            const diag = new diagnostic_1.DiagnosticAddendum();
+            diag.addMessage(localize_1.LocAddendum.typeVarsMissing().format({
+                names: missingFromGeneric.map((typeVar) => `"${typeVar.shared.name}"`).join(', '),
+            }));
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarsNotInGenericOrProtocol() + diag.getString(), errorNode);
+        }
+    }
+    function transformTypeArgsForParamSpec(typeParams, typeArgs, errorNode) {
+        if (typeParams.length !== 1 || !(0, types_1.isParamSpec)(typeParams[0]) || !typeArgs) {
+            return typeArgs;
+        }
+        if (typeArgs.length > 1) {
+            for (const typeArg of typeArgs) {
+                if ((0, types_1.isParamSpec)(typeArg.type)) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.paramSpecContext(), typeArg.node);
+                    return undefined;
+                }
+                if ((0, typeUtils_1.isEllipsisType)(typeArg.type)) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.ellipsisContext(), typeArg.node);
+                    return undefined;
+                }
+                if ((0, types_1.isInstantiableClass)(typeArg.type) && types_1.ClassType.isBuiltIn(typeArg.type, 'Concatenate')) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.concatenateContext(), typeArg.node);
+                    return undefined;
+                }
+                if (typeArg.typeList) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgListNotAllowed(), typeArg.node);
+                    return undefined;
+                }
+            }
+        }
+        if (typeArgs.length === 1) {
+            // Don't transform a type list.
+            if (typeArgs[0].typeList) {
+                return typeArgs;
+            }
+            const typeArgType = typeArgs[0].type;
+            // Don't transform a single ParamSpec or ellipsis.
+            if ((0, types_1.isParamSpec)(typeArgType) || (0, typeUtils_1.isEllipsisType)(typeArgType)) {
+                return typeArgs;
+            }
+            // Don't transform a Concatenate.
+            if ((0, types_1.isInstantiableClass)(typeArgType) && types_1.ClassType.isBuiltIn(typeArgType, 'Concatenate')) {
+                return typeArgs;
+            }
+        }
+        // Package up the type arguments into a type list.
+        return [
+            {
+                type: types_1.UnknownType.create(),
+                node: typeArgs.length > 0 ? typeArgs[0].node : errorNode,
+                typeList: typeArgs,
+            },
+        ];
+    }
+    function createSpecializedClassType(classType, typeArgs, flags, errorNode) {
+        let isValidTypeForm = true;
+        // Handle the special-case classes that are not defined
+        // in the type stubs.
+        if (types_1.ClassType.isSpecialBuiltIn(classType)) {
+            const aliasedName = classType.priv.aliasName || classType.shared.name;
+            switch (aliasedName) {
+                case 'Callable': {
+                    return { type: createCallableType(classType, typeArgs, errorNode) };
+                }
+                case 'Never':
+                case 'NoReturn': {
+                    if (typeArgs && typeArgs.length > 0) {
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgsExpectingNone().format({ name: aliasedName }), typeArgs[0].node);
+                    }
+                    let resultType = aliasedName === 'Never' ? types_1.NeverType.createNever() : types_1.NeverType.createNoReturn();
+                    resultType = types_1.TypeBase.cloneAsSpecialForm(resultType, classType);
+                    resultType = types_1.TypeBase.cloneWithTypeForm(resultType, (0, typeUtils_1.convertToInstance)(resultType));
+                    return { type: resultType };
+                }
+                case 'Optional': {
+                    return { type: createOptionalType(classType, errorNode, typeArgs, flags) };
+                }
+                case 'Type': {
+                    let typeType = createSpecialType(classType, typeArgs, 1, 
+                    /* allowParamSpec */ undefined, 
+                    /* isSpecialForm */ false);
+                    if ((0, types_1.isInstantiableClass)(typeType)) {
+                        typeType = (0, typeUtils_1.explodeGenericClass)(typeType);
+                    }
+                    typeType = types_1.TypeBase.cloneWithTypeForm(typeType, (0, typeUtils_1.convertToInstance)(typeType));
+                    return { type: typeType };
+                }
+                case 'ClassVar': {
+                    return { type: createClassVarType(classType, errorNode, typeArgs, flags) };
+                }
+                case 'Protocol': {
+                    if ((flags &
+                        (67108864 /* EvalFlags.NoNonTypeSpecialForms */ | 256 /* EvalFlags.TypeExpression */ | 1073741824 /* EvalFlags.TypeFormArg */)) !==
+                        0) {
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.protocolNotAllowed(), errorNode);
+                    }
+                    typeArgs?.forEach((typeArg) => {
+                        if (typeArg.typeList || !(0, types_1.isTypeVar)(typeArg.type)) {
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.protocolTypeArgMustBeTypeParam(), typeArg.node);
+                        }
+                    });
+                    return {
+                        type: createSpecialType(classType, typeArgs, 
+                        /* paramLimit */ undefined, 
+                        /* allowParamSpec */ true),
+                    };
+                }
+                case 'TypedDict': {
+                    if ((flags &
+                        (67108864 /* EvalFlags.NoNonTypeSpecialForms */ | 256 /* EvalFlags.TypeExpression */ | 1073741824 /* EvalFlags.TypeFormArg */)) !==
+                        0) {
+                        const isInlinedTypedDict = nodeInfo.getFileInfo(errorNode).diagnosticRuleSet.enableExperimentalFeatures && !!typeArgs;
+                        if (!isInlinedTypedDict) {
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typedDictNotAllowed(), errorNode);
+                        }
+                    }
+                    isValidTypeForm = false;
+                    break;
+                }
+                case 'Literal': {
+                    if ((flags &
+                        (67108864 /* EvalFlags.NoNonTypeSpecialForms */ | 256 /* EvalFlags.TypeExpression */ | 1073741824 /* EvalFlags.TypeFormArg */)) !==
+                        0) {
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.literalNotAllowed(), errorNode);
+                    }
+                    isValidTypeForm = false;
+                    break;
+                }
+                case 'TypeAlias': {
+                    if ((flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0) {
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeAnnotationVariable(), errorNode);
+                    }
+                    isValidTypeForm = false;
+                    break;
+                }
+                case 'Tuple': {
+                    return {
+                        type: createSpecialType(classType, typeArgs, 
+                        /* paramLimit */ undefined, 
+                        /* allowParamSpec */ false, 
+                        /* isSpecialForm */ false),
+                    };
+                }
+                case 'Union': {
+                    return { type: createUnionType(classType, errorNode, typeArgs, flags) };
+                }
+                case 'Generic': {
+                    return { type: createGenericType(classType, errorNode, typeArgs, flags) };
+                }
+                case 'Final': {
+                    return { type: createFinalType(classType, errorNode, typeArgs, flags) };
+                }
+                case 'Annotated': {
+                    return createAnnotatedType(classType, errorNode, typeArgs, flags);
+                }
+                case 'Concatenate': {
+                    return { type: createConcatenateType(classType, errorNode, typeArgs, flags) };
+                }
+                case 'TypeGuard':
+                case 'TypeIs': {
+                    return { type: createTypeGuardType(classType, errorNode, typeArgs, flags) };
+                }
+                case 'Unpack': {
+                    return { type: createUnpackType(classType, errorNode, typeArgs, flags) };
+                }
+                case 'Required':
+                case 'NotRequired': {
+                    return createRequiredOrReadOnlyType(classType, errorNode, typeArgs, flags);
+                }
+                case 'ReadOnly': {
+                    return createRequiredOrReadOnlyType(classType, errorNode, typeArgs, flags);
+                }
+                case 'Self': {
+                    return { type: createSelfType(classType, errorNode, typeArgs, flags) };
+                }
+                case 'LiteralString': {
+                    return { type: createSpecialType(classType, typeArgs, 0) };
+                }
+                case 'TypeForm': {
+                    return { type: createTypeFormType(classType, errorNode, typeArgs) };
+                }
+            }
+        }
+        const fileInfo = nodeInfo.getFileInfo(errorNode);
+        if (fileInfo.isStubFile ||
+            pythonVersion_1.PythonVersion.isGreaterOrEqualTo(fileInfo.executionEnvironment.pythonVersion, pythonVersion_1.pythonVersion3_9) ||
+            (0, analyzerFileInfo_1.isAnnotationEvaluationPostponed)(nodeInfo.getFileInfo(errorNode)) ||
+            (flags & 4 /* EvalFlags.ForwardRefs */) !== 0) {
+            // Handle "type" specially, since it needs to act like "Type"
+            // in Python 3.9 and newer.
+            if (types_1.ClassType.isBuiltIn(classType, 'type') && typeArgs) {
+                if (typeArgs.length >= 1) {
+                    // Treat type[function] as illegal.
+                    if ((0, types_1.isFunctionOrOverloaded)(typeArgs[0].type)) {
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeAnnotationWithCallable(), typeArgs[0].node);
+                        return { type: types_1.UnknownType.create() };
+                    }
+                }
+                if (context.prefetched?.typeClass && (0, types_1.isInstantiableClass)(context.prefetched.typeClass)) {
+                    let typeType = createSpecialType(context.prefetched.typeClass, typeArgs, 1, 
+                    /* allowParamSpec */ undefined, 
+                    /* isSpecialForm */ false);
+                    if ((0, types_1.isInstantiableClass)(typeType)) {
+                        typeType = (0, typeUtils_1.explodeGenericClass)(typeType);
+                    }
+                    typeType = types_1.TypeBase.cloneWithTypeForm(typeType, (0, typeUtils_1.convertToInstance)(typeType));
+                    return { type: typeType };
+                }
+            }
+            // Handle "tuple" specially, since it needs to act like "Tuple"
+            // in Python 3.9 and newer.
+            if ((0, typeUtils_1.isTupleClass)(classType)) {
+                let specializedClass = createSpecialType(classType, typeArgs, 
+                /* paramLimit */ undefined, 
+                /* allowParamSpec */ undefined, 
+                /* isSpecialForm */ false);
+                specializedClass = types_1.TypeBase.cloneWithTypeForm(specializedClass, (0, typeUtils_1.convertToInstance)(specializedClass));
+                return { type: specializedClass };
+            }
+        }
+        let typeArgCount = typeArgs ? typeArgs.length : 0;
+        // Make sure the argument list count is correct.
+        const typeParams = types_1.ClassType.isPseudoGenericClass(classType) ? [] : types_1.ClassType.getTypeParams(classType);
+        // If there are no type parameters or args, the class is already specialized.
+        // No need to do any more work.
+        if (typeParams.length === 0 && typeArgCount === 0) {
+            return { type: classType };
+        }
+        const variadicTypeParamIndex = typeParams.findIndex((param) => (0, types_1.isTypeVarTuple)(param));
+        if (typeArgs) {
+            let minTypeArgCount = typeParams.length;
+            const firstDefaultParamIndex = typeParams.findIndex((param) => !!param.shared.isDefaultExplicit);
+            if (firstDefaultParamIndex >= 0) {
+                minTypeArgCount = firstDefaultParamIndex;
+            }
+            // Classes that accept inlined type dict type args allow only one.
+            if (typeArgs.length > 0 && typeArgs[0].inlinedTypeDict) {
+                if (typeArgs.length > 1) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeArgsTooMany().format({
+                        name: classType.priv.aliasName || classType.shared.name,
+                        expected: 1,
+                        received: typeArgCount,
+                    }), typeArgs[1].node);
+                }
+                let inlinedTypeDict = typeArgs[0].inlinedTypeDict;
+                if ((flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0) {
+                    inlinedTypeDict = types_1.TypeBase.cloneWithTypeForm(inlinedTypeDict, (0, typeUtils_1.convertToInstance)(inlinedTypeDict));
+                }
+                return { type: inlinedTypeDict };
+            }
+            else if (typeArgCount > typeParams.length) {
+                if (!types_1.ClassType.isPartiallyEvaluated(classType) && !types_1.ClassType.isTupleClass(classType)) {
+                    if (typeParams.length === 0) {
+                        isValidTypeForm = false;
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeArgsExpectingNone().format({
+                            name: classType.priv.aliasName || classType.shared.name,
+                        }), typeArgs[typeParams.length].node);
+                    }
+                    else if (typeParams.length !== 1 || !(0, types_1.isParamSpec)(typeParams[0])) {
+                        isValidTypeForm = false;
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeArgsTooMany().format({
+                            name: classType.priv.aliasName || classType.shared.name,
+                            expected: typeParams.length,
+                            received: typeArgCount,
+                        }), typeArgs[typeParams.length].node);
+                    }
+                    typeArgCount = typeParams.length;
+                }
+            }
+            else if (typeArgCount < minTypeArgCount) {
+                isValidTypeForm = false;
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeArgsTooFew().format({
+                    name: classType.priv.aliasName || classType.shared.name,
+                    expected: minTypeArgCount,
+                    received: typeArgCount,
+                }), typeArgs.length > 0 ? typeArgs[0].node.parent : errorNode);
+            }
+            typeArgs.forEach((typeArg, index) => {
+                if (!typeArg.type.props?.typeForm) {
+                    isValidTypeForm = false;
+                }
+                if (index === variadicTypeParamIndex) {
+                    // The types that make up the tuple that maps to the
+                    // TypeVarTuple have already been validated when the tuple
+                    // object was created in adjustTypeArgsForTypeVarTuple.
+                    if ((0, types_1.isClassInstance)(typeArg.type) && (0, typeUtils_1.isTupleClass)(typeArg.type)) {
+                        return;
+                    }
+                    if ((0, types_1.isTypeVarTuple)(typeArg.type)) {
+                        if (!validateTypeVarTupleIsUnpacked(typeArg.type, typeArg.node)) {
+                            isValidTypeForm = false;
+                        }
+                        return;
+                    }
+                }
+                const typeParam = index < typeParams.length ? typeParams[index] : undefined;
+                const isParamSpecTarget = typeParam && (0, types_1.isParamSpec)(typeParam);
+                if (!validateTypeArg(typeArg, {
+                    allowParamSpec: true,
+                    allowTypeArgList: isParamSpecTarget,
+                })) {
+                    isValidTypeForm = false;
+                }
+            });
+        }
+        // Handle ParamSpec arguments and fill in any missing type arguments with Unknown.
+        const fullTypeParams = types_1.ClassType.getTypeParams(classType);
+        typeArgs = transformTypeArgsForParamSpec(fullTypeParams, typeArgs, errorNode);
+        if (!typeArgs) {
+            isValidTypeForm = false;
+        }
+        let typeArgTypes = resolveClassTypeArguments(classType, fullTypeParams, typeArgs, flags);
+        typeArgTypes = typeArgTypes.map((typeArgType, index) => {
+            if (index < typeArgCount) {
+                const diag = new diagnostic_1.DiagnosticAddendum();
+                let adjustedTypeArgType = applyTypeArgToTypeVar(typeParams[index], typeArgType, diag);
+                // Determine if the variance must match.
+                if (adjustedTypeArgType && (flags & 16384 /* EvalFlags.EnforceVarianceConsistency */) !== 0) {
+                    const destType = typeParams[index];
+                    const declaredVariance = destType.shared.declaredVariance;
+                    if (!(0, typeUtils_1.isVarianceOfTypeArgCompatible)(adjustedTypeArgType, declaredVariance)) {
+                        diag.addMessage(localize_1.LocAddendum.varianceMismatchForClass().format({
+                            typeVarName: printType(adjustedTypeArgType),
+                            className: classType.shared.name,
+                        }));
+                        adjustedTypeArgType = undefined;
+                    }
+                }
+                if (adjustedTypeArgType) {
+                    typeArgType = adjustedTypeArgType;
+                }
+                else {
+                    // Avoid emitting this error for a partially-constructed class.
+                    if (!(0, types_1.isClassInstance)(typeArgType) || !types_1.ClassType.isPartiallyEvaluated(typeArgType)) {
+                        (0, debug_1.assert)(typeArgs !== undefined);
+                        isValidTypeForm = false;
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeVarAssignmentMismatch().format({
+                            type: printType(typeArgType),
+                            name: types_1.TypeVarType.getReadableName(typeParams[index]),
+                        }) + diag.getString(), typeArgs[index].node);
+                    }
+                }
+            }
+            return typeArgType;
+        });
+        // If the class is partially constructed and doesn't yet have
+        // type parameters, assume that the number and types of supplied type
+        // arguments are correct.
+        if (typeArgs && classType.shared.typeParams.length === 0 && types_1.ClassType.isPartiallyEvaluated(classType)) {
+            typeArgTypes = typeArgs.map((t) => (0, typeUtils_1.convertToInstance)(t.type));
+        }
+        let specializedClass = types_1.ClassType.specialize(classType, typeArgTypes, typeArgs !== undefined);
+        specializedClass = types_1.TypeBase.cloneWithTypeForm(specializedClass, isValidTypeForm ? (0, typeUtils_1.convertToInstance)(specializedClass) : undefined);
+        return { type: specializedClass };
+    }
+    function resolveClassTypeArguments(classType, typeParams, typeArgs, flags) {
+        const typeArgTypes = [];
+        const constraints = new constraintTracker_1.ConstraintTracker();
+        typeParams.forEach((typeParam, index) => {
+            if (typeArgs && index < typeArgs.length) {
+                if ((0, types_1.isParamSpec)(typeParam)) {
+                    const typeArg = typeArgs[index];
+                    const functionType = types_1.FunctionType.createSynthesizedInstance('', 65536 /* FunctionTypeFlags.ParamSpecValue */);
+                    if ((0, typeUtils_1.isEllipsisType)(typeArg.type)) {
+                        types_1.FunctionType.addDefaultParams(functionType);
+                        functionType.shared.flags |= 32768 /* FunctionTypeFlags.GradualCallableForm */;
+                        typeArgTypes.push(functionType);
+                        constraints.setBounds(typeParam, functionType);
+                        return;
+                    }
+                    if (typeArg.typeList) {
+                        typeArg.typeList.forEach((paramType, paramIndex) => {
+                            types_1.FunctionType.addParam(functionType, types_1.FunctionParam.create(0 /* ParamCategory.Simple */, (0, typeUtils_1.convertToInstance)(paramType.type), types_1.FunctionParamFlags.NameSynthesized | types_1.FunctionParamFlags.TypeDeclared, `__p${paramIndex}`));
+                        });
+                        if (typeArg.typeList.length > 0) {
+                            types_1.FunctionType.addPositionOnlyParamSeparator(functionType);
+                        }
+                        typeArgTypes.push(functionType);
+                        constraints.setBounds(typeParam, functionType);
+                        return;
+                    }
+                    if ((0, types_1.isInstantiableClass)(typeArg.type) && types_1.ClassType.isBuiltIn(typeArg.type, 'Concatenate')) {
+                        const concatTypeArgs = typeArg.type.priv.typeArgs;
+                        if (concatTypeArgs && concatTypeArgs.length > 0) {
+                            concatTypeArgs.forEach((typeArg, index) => {
+                                if (index === concatTypeArgs.length - 1) {
+                                    if ((0, types_1.isParamSpec)(typeArg)) {
+                                        types_1.FunctionType.addParamSpecVariadics(functionType, typeArg);
+                                    }
+                                    else if ((0, typeUtils_1.isEllipsisType)(typeArg)) {
+                                        types_1.FunctionType.addDefaultParams(functionType);
+                                        functionType.shared.flags |= 32768 /* FunctionTypeFlags.GradualCallableForm */;
+                                    }
+                                }
+                                else {
+                                    types_1.FunctionType.addParam(functionType, types_1.FunctionParam.create(0 /* ParamCategory.Simple */, typeArg, types_1.FunctionParamFlags.NameSynthesized | types_1.FunctionParamFlags.TypeDeclared, `__p${index}`));
+                                }
+                            });
+                        }
+                        typeArgTypes.push(functionType);
+                        return;
+                    }
+                }
+                const typeArgType = convertTypeArgToInstance(typeArgs[index].type, flags);
+                typeArgTypes.push(typeArgType);
+                constraints.setBounds(typeParam, typeArgType);
+                return;
+            }
+            const solvedDefaultType = solveAndApplyConstraints(typeParam, constraints, {
+                replaceUnsolved: {
+                    scopeIds: (0, typeUtils_1.getTypeVarScopeIds)(classType),
+                    tupleClassType: getTupleClassType(),
+                },
+            });
+            typeArgTypes.push(solvedDefaultType);
+            constraints.setBounds(typeParam, solvedDefaultType);
+        });
+        return typeArgTypes;
+    }
+    function applyTypeArgToTypeVar(destType, srcType, diag) {
+        if ((0, types_1.isAnyOrUnknown)(srcType)) {
+            return srcType;
+        }
+        let effectiveSrcType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(srcType);
+        if ((0, types_1.isTypeVar)(srcType)) {
+            if ((0, types_1.isTypeSame)(srcType, destType)) {
+                return srcType;
+            }
+            effectiveSrcType = makeTopLevelTypeVarsConcrete(srcType);
+        }
+        // If this is a partially-evaluated class, don't perform any further
+        // checks. Assume in this case that the type is compatible with the
+        // bound or constraint.
+        if ((0, types_1.isClass)(effectiveSrcType) && types_1.ClassType.isPartiallyEvaluated(effectiveSrcType)) {
+            return srcType;
+        }
+        // If there's a bound type, make sure the source is derived from it.
+        if (destType.shared.boundType && !(0, typeUtils_1.isTypeAliasPlaceholder)(effectiveSrcType)) {
+            if (!assignType(destType.shared.boundType, effectiveSrcType, diag.createAddendum(), 
+            /* constraints */ undefined)) {
+                // Avoid adding a message that will confuse users if the TypeVar was
+                // synthesized for internal purposes.
+                if (!destType.shared.isSynthesized) {
+                    diag.addMessage(localize_1.LocAddendum.typeBound().format({
+                        sourceType: printType(effectiveSrcType),
+                        destType: printType(destType.shared.boundType),
+                        name: types_1.TypeVarType.getReadableName(destType),
+                    }));
+                }
+                return undefined;
+            }
+        }
+        if ((0, types_1.isParamSpec)(destType)) {
+            if ((0, types_1.isParamSpec)(srcType)) {
+                return srcType;
+            }
+            if ((0, types_1.isFunction)(srcType) && types_1.FunctionType.isParamSpecValue(srcType)) {
+                return srcType;
+            }
+            if ((0, types_1.isClassInstance)(srcType) && types_1.ClassType.isBuiltIn(srcType, 'Concatenate')) {
+                return srcType;
+            }
+            diag.addMessage(localize_1.LocAddendum.typeParamSpec().format({
+                type: printType(srcType),
+                name: types_1.TypeVarType.getReadableName(destType),
+            }));
+            return undefined;
+        }
+        if ((0, types_1.isParamSpec)(srcType)) {
+            diag.addMessage(localize_1.LocMessage.paramSpecContext());
+            return undefined;
+        }
+        // If there are no constraints, we're done.
+        const constraints = destType.shared.constraints;
+        if (constraints.length === 0) {
+            return srcType;
+        }
+        if ((0, typeUtils_1.isTypeAliasPlaceholder)(srcType)) {
+            return srcType;
+        }
+        if ((0, types_1.isTypeVar)(srcType) && types_1.TypeVarType.hasConstraints(srcType)) {
+            // Make sure all the source constraint types map to constraint types in the dest.
+            if (srcType.shared.constraints.every((sourceConstraint) => {
+                return constraints.some((destConstraint) => assignType(destConstraint, sourceConstraint));
+            })) {
+                return srcType;
+            }
+        }
+        else {
+            let bestConstraintSoFar;
+            // Try to find the best (narrowest) match among the constraints.
+            for (const constraint of constraints) {
+                if (assignType(constraint, effectiveSrcType)) {
+                    // Don't allow Never to match unless the constraint is also explicitly Never.
+                    if (!(0, types_1.isNever)(effectiveSrcType) || (0, types_1.isNever)(constraint)) {
+                        if (!bestConstraintSoFar || assignType(bestConstraintSoFar, constraint)) {
+                            bestConstraintSoFar = constraint;
+                        }
+                    }
+                }
+            }
+            if (bestConstraintSoFar) {
+                return bestConstraintSoFar;
+            }
+        }
+        diag.addMessage(localize_1.LocAddendum.typeConstrainedTypeVar().format({
+            type: printType(srcType),
+            name: types_1.TypeVarType.getReadableName(destType),
+        }));
+        return undefined;
+    }
+    function createSelfType(classType, errorNode, typeArgs, flags) {
+        // Self doesn't support any type arguments.
+        if (typeArgs && typeArgs.length > 0) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeArgsExpectingNone().format({
+                name: classType.shared.name,
+            }), typeArgs[0].node ?? errorNode);
+        }
+        let enclosingClass = ParseTreeUtils.getEnclosingClass(errorNode);
+        // If `Self` appears anywhere outside of the class body (e.g. a decorator,
+        // base class list, metaclass argument, type parameter list), it is
+        // considered illegal.
+        if (enclosingClass && !ParseTreeUtils.isNodeContainedWithin(errorNode, enclosingClass.d.suite)) {
+            enclosingClass = undefined;
+        }
+        const enclosingClassTypeResult = enclosingClass ? getTypeOfClass(enclosingClass) : undefined;
+        if (!enclosingClassTypeResult) {
+            if ((flags & (256 /* EvalFlags.TypeExpression */ | 128 /* EvalFlags.InstantiableType */ | 1073741824 /* EvalFlags.TypeFormArg */)) !== 0) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.selfTypeContext(), errorNode);
+            }
+            return types_1.UnknownType.create();
+        }
+        else if ((0, typeUtils_1.isInstantiableMetaclass)(enclosingClassTypeResult.classType)) {
+            // If `Self` appears within a metaclass, it is considered illegal.
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.selfTypeMetaclass(), errorNode);
+            return types_1.UnknownType.create();
+        }
+        const enclosingFunction = ParseTreeUtils.getEnclosingFunction(errorNode);
+        if (enclosingFunction) {
+            const functionInfo = (0, decorators_1.getFunctionInfoFromDecorators)(context, enclosingFunction, 
+            /* isInClass */ true, nodeInfo);
+            const isInnerFunction = !!ParseTreeUtils.getEnclosingFunction(enclosingFunction);
+            if (!isInnerFunction) {
+                // Check for static methods.
+                if (functionInfo.flags & 4 /* FunctionTypeFlags.StaticMethod */) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.selfTypeContext(), errorNode);
+                    return types_1.UnknownType.create();
+                }
+                if (enclosingFunction.d.params.length > 0) {
+                    const firstParamTypeAnnotation = ParseTreeUtils.getTypeAnnotationForParam(enclosingFunction, 0);
+                    if (firstParamTypeAnnotation &&
+                        !ParseTreeUtils.isNodeContainedWithin(errorNode, firstParamTypeAnnotation)) {
+                        const annotationType = getTypeOfAnnotation(firstParamTypeAnnotation, {
+                            typeVarGetsCurScope: true,
+                        });
+                        if (!(0, types_1.isTypeVar)(annotationType) || !types_1.TypeVarType.isSelf(annotationType)) {
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.selfTypeWithTypedSelfOrCls(), errorNode);
+                        }
+                    }
+                }
+            }
+        }
+        let result = (0, typeUtils_1.synthesizeTypeVarForSelfCls)(enclosingClassTypeResult.classType, /* isClsParam */ true);
+        if (enclosingClass) {
+            // If "Self" is used as a type expression within a function suite, it needs
+            // to be marked as bound.
+            const enclosingSuite = ParseTreeUtils.getEnclosingClassOrFunctionSuite(errorNode);
+            if (enclosingSuite && ParseTreeUtils.isNodeContainedWithin(enclosingSuite, enclosingClass)) {
+                if (enclosingClass.d.suite !== enclosingSuite) {
+                    result = types_1.TypeVarType.cloneAsBound(result);
+                }
+            }
+        }
+        return result;
+    }
+    function cloneBuiltinClassWithLiteral(node, literalClassType, builtInName, value) {
+        const type = getBuiltInType(node, builtInName);
+        if ((0, types_1.isInstantiableClass)(type)) {
+            const literalType = types_1.ClassType.cloneWithLiteral(type, value);
+            types_1.TypeBase.setSpecialForm(literalType, literalClassType);
+            return literalType;
+        }
+        return types_1.UnknownType.create();
+    }
+    function createLiteralType(classType, node, flags) {
+        if (node.d.items.length === 0) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.literalEmptyArgs(), node.d.leftExpr);
+            return types_1.UnknownType.create();
+        }
+        // As per the specification, we support None, int, bool, str, bytes literals
+        // plus enum values.
+        const literalTypes = [];
+        let isValidTypeForm = true;
+        for (const item of node.d.items) {
+            let type;
+            const itemExpr = item.d.valueExpr;
+            if (item.d.argCategory !== 0 /* ArgCategory.Simple */) {
+                if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unpackedArgInTypeArgument(), itemExpr);
+                    type = types_1.UnknownType.create();
+                    isValidTypeForm = false;
+                }
+            }
+            else if (item.d.name) {
+                if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.keywordArgInTypeArgument(), itemExpr);
+                    type = types_1.UnknownType.create();
+                    isValidTypeForm = false;
+                }
+            }
+            else if (itemExpr.nodeType === 48 /* ParseNodeType.StringList */ &&
+                itemExpr.d.strings.every((stringNode) => stringNode.nodeType === 49 /* ParseNodeType.String */)) {
+                const isBytes = (itemExpr.d.strings[0].d.token.flags & 32 /* StringTokenFlags.Bytes */) !== 0;
+                const value = itemExpr.d.strings.map((s) => s.d.value).join('');
+                if (isBytes) {
+                    type = cloneBuiltinClassWithLiteral(node, classType, 'bytes', value);
+                }
+                else {
+                    type = cloneBuiltinClassWithLiteral(node, classType, 'str', value);
+                }
+                if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+                    itemExpr.d.strings.forEach((stringNode) => {
+                        if ((stringNode.d.token.flags & 1024 /* StringTokenFlags.NamedUnicodeEscape */) !== 0) {
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.literalNamedUnicodeEscape(), stringNode);
+                            isValidTypeForm = false;
+                        }
+                    });
+                }
+            }
+            else if (itemExpr.nodeType === 40 /* ParseNodeType.Number */) {
+                if (!itemExpr.d.isImaginary && itemExpr.d.isInteger) {
+                    type = cloneBuiltinClassWithLiteral(node, classType, 'int', itemExpr.d.value);
+                }
+            }
+            else if (itemExpr.nodeType === 14 /* ParseNodeType.Constant */) {
+                if (itemExpr.d.constType === 34 /* KeywordType.True */) {
+                    type = cloneBuiltinClassWithLiteral(node, classType, 'bool', true);
+                }
+                else if (itemExpr.d.constType === 15 /* KeywordType.False */) {
+                    type = cloneBuiltinClassWithLiteral(node, classType, 'bool', false);
+                }
+                else if (itemExpr.d.constType === 27 /* KeywordType.None */) {
+                    type = context.prefetched?.noneTypeClass ?? types_1.UnknownType.create();
+                }
+            }
+            else if (itemExpr.nodeType === 55 /* ParseNodeType.UnaryOperation */) {
+                if (itemExpr.d.operator === 33 /* OperatorType.Subtract */ || itemExpr.d.operator === 0 /* OperatorType.Add */) {
+                    if (itemExpr.d.expr.nodeType === 40 /* ParseNodeType.Number */) {
+                        if (!itemExpr.d.expr.d.isImaginary && itemExpr.d.expr.d.isInteger) {
+                            type = cloneBuiltinClassWithLiteral(node, classType, 'int', itemExpr.d.operator === 33 /* OperatorType.Subtract */
+                                ? -itemExpr.d.expr.d.value
+                                : itemExpr.d.expr.d.value);
+                        }
+                    }
+                }
+            }
+            if (!type) {
+                const exprType = getTypeOfExpression(itemExpr, (flags & (4 /* EvalFlags.ForwardRefs */ | 256 /* EvalFlags.TypeExpression */)) | 33554432 /* EvalFlags.NoConvertSpecialForm */);
+                // Is this an enum type?
+                if ((0, types_1.isClassInstance)(exprType.type) &&
+                    types_1.ClassType.isEnumClass(exprType.type) &&
+                    exprType.type.priv.literalValue !== undefined) {
+                    type = types_1.ClassType.cloneAsInstantiable(exprType.type);
+                }
+                else {
+                    // Is this a type alias to an existing literal type?
+                    let isLiteralType = true;
+                    (0, typeUtils_1.doForEachSubtype)(exprType.type, (subtype) => {
+                        if (!(0, types_1.isInstantiableClass)(subtype) || subtype.priv.literalValue === undefined) {
+                            if (!(0, typeUtils_1.isNoneTypeClass)(subtype)) {
+                                isLiteralType = false;
+                            }
+                        }
+                    });
+                    if (isLiteralType) {
+                        type = exprType.type;
+                    }
+                }
+            }
+            if (!type) {
+                if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.literalUnsupportedType(), item);
+                    type = types_1.UnknownType.create();
+                    isValidTypeForm = false;
+                }
+                else {
+                    return types_1.ClassType.cloneAsInstance(classType);
+                }
+            }
+            literalTypes.push(type);
+        }
+        let result = (0, types_1.combineTypes)(literalTypes, { skipElideRedundantLiterals: true });
+        if ((0, types_1.isUnion)(result) &&
+            context.prefetched?.unionTypeClass &&
+            (0, types_1.isInstantiableClass)(context.prefetched.unionTypeClass)) {
+            result = types_1.TypeBase.cloneAsSpecialForm(result, types_1.ClassType.cloneAsInstance(context.prefetched.unionTypeClass));
+        }
+        if (isValidTypeForm) {
+            result = types_1.TypeBase.cloneWithTypeForm(result, (0, typeUtils_1.convertToInstance)(result));
+        }
+        return result;
+    }
+    return {
+        reportUseOfTypeCheckOnly,
+        enforceClassTypeVarScope,
+        adjustTypeArgsForTypeVarTuple,
+        validateTypeArg,
+        createTypeFormType,
+        transformTypeForTypeAlias,
+        validateTypeParamDefault,
+        verifyGenericTypeParams,
+        transformTypeArgsForParamSpec,
+        createSpecializedClassType,
+        createSelfType,
+        createLiteralType,
+    };
+}
+//# sourceMappingURL=specialFormCreation.js.map